public void ParseNewAnonymousType()
{
int x = 1;
Expression <Func <int> > f = () => new { Value = x, x }.Value;
var p = new ExpressionParser(f.Body);
var node = p.Parse();
var expected = new MemberAccessNode
{
Container = new NewAnonymousTypeNode
{
Parameters = new[]
{
new MemberAssignmentNode
{
MemberName = "Value",
Value = new ConstantNode {
Text = "x", Value = "1"
}
},
new MemberAssignmentNode
{
MemberName = "x",
Value = new ConstantNode {
Text = "x", Value = "1"
}
}
}.ToList(),
Value = "{ Value = 1, x = 1 }"
},
MemberName = "Value",
MemberValue = "1"
};
Assert.AreEqual(expected, node);
}
public void ToODataString_EscapesThe_Uri()
{
//updatedat gt datetimeoffset'2014-04-04T07:00:00.0000000+00:00'
var datetime1 = new ConstantNode(new DateTimeOffset(2014, 4, 4, 7, 0, 0, TimeSpan.FromHours(0)));
var updatedAt = new MemberAccessNode(null, "updatedat");
var gt1 = new BinaryOperatorNode(BinaryOperatorKind.GreaterThan, updatedAt, datetime1);
// updatedat gt datetime'2014-04-04T07:0:0.000Z'
var datetime2 = new ConstantNode(new DateTime(2014, 4, 4, 7, 0, 0, DateTimeKind.Utc));
var someDate = new MemberAccessNode(null, "someDate");
var gt2 = new BinaryOperatorNode(BinaryOperatorKind.GreaterThan, someDate, datetime2);
// startswith(text,'this&''%%=,?#')
var text = new MemberAccessNode(null, "text");
var value = new ConstantNode("this&'%%=,?#");
var startswith = new FunctionCallNode("startswith", new QueryNode[] { text, value });
//updatedat gt datetimeoffset'2014-04-04T07:00:00.0000000+00:00' and startswith(text,'this&''%%=,?#')
var and2 = new BinaryOperatorNode(BinaryOperatorKind.And, gt2, startswith);
var and1 = new BinaryOperatorNode(BinaryOperatorKind.And, gt1, and2);
var desc = new MobileServiceTableQueryDescription("someTable") { Filter = and1 };
Assert.AreEqual(desc.ToODataString(), EscapedODataString);
}
public virtual AstNode VisitMemberAccess(MemberAccessNode n)
{
Visit(n.Instance);
Visit(n.MemberName);
Visit(n.GenericArguments);
return(n);
}
private void FormatValueExpression(MemberAccessNode me, ConstantNode ce, NodeExpression finalExpression)
{
if (ce.Value is null && !ce.ForceParameter)
{
return;
}
finalExpression.Append(' ');
var memberName = me.Parent != null ? $"{me.Parent.MemberName}.{me.MemberName}" : me.MemberName;
var parameterName = memberName.Replace(".", "");
var type = ce.ParameterType;
if (type != typeof(string) && (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type)))
{
parameterName += "Collection";
}
if (me.Formatter != null)
{
finalExpression.Append(me.Formatter($"@{parameterName}"));
}
else
{
finalExpression.Append($"@{parameterName}");
}
finalExpression.Parameters.Add(new NodeParameter(parameterName, ce.Value));
}
public void ToODataString_EscapesThe_Uri()
{
//updatedat gt datetimeoffset'2014-04-04T07:00:00.0000000+00:00'
var datetime1 = new ConstantNode(new DateTimeOffset(2014, 4, 4, 7, 0, 0, TimeSpan.FromHours(0)));
var updatedAt = new MemberAccessNode(null, "updatedat");
var gt1 = new BinaryOperatorNode(BinaryOperatorKind.GreaterThan, updatedAt, datetime1);
// updatedat gt datetime'2014-04-04T07:0:0.000Z'
var datetime2 = new ConstantNode(new DateTime(2014, 4, 4, 7, 0, 0, DateTimeKind.Utc));
var someDate = new MemberAccessNode(null, "someDate");
var gt2 = new BinaryOperatorNode(BinaryOperatorKind.GreaterThan, someDate, datetime2);
// startswith(text,'this&''%%=,?#')
var text = new MemberAccessNode(null, "text");
var value = new ConstantNode("this&'%%=,?#");
var startswith = new FunctionCallNode("startswith", new QueryNode[] { text, value });
//updatedat gt datetimeoffset'2014-04-04T07:00:00.0000000+00:00' and startswith(text,'this&''%%=,?#')
var and2 = new BinaryOperatorNode(BinaryOperatorKind.And, gt2, startswith);
var and1 = new BinaryOperatorNode(BinaryOperatorKind.And, gt1, and2);
var desc = new MobileServiceTableQueryDescription("someTable")
{
Filter = and1
};
Assert.AreEqual(desc.ToODataString(), EscapedODataString);
}
private void FormatMemberExpression(MemberAccessNode me, ConstantNode ce, NodeExpression finalExpression, IQueryMapping mapping)
{
var memberName = me.Parent != null ? $"{me.Parent.MemberName}.{me.MemberName}" : me.MemberName;
if (me.MemberName.StartsWith('@'))
{
var parameterName = (me.Parent != null ? $"{me.Parent.MemberName}{me.MemberName}" : me.MemberName)
.Replace(".", "")
.Replace("@", "");
var type = ce.ParameterType;
if (type != typeof(string) && (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type)))
{
parameterName += "Collection";
}
finalExpression.Append('@');
finalExpression.Append(parameterName);
}
else
{
if (!mapping.Mappings.TryGetValue(memberName, out var identifier))
{
identifier = memberName;
}
finalExpression.Append(identifier);
}
}
public override QueryNode Visit(MemberAccessNode nodeIn)
{
string memberName = SqlHelpers.FormatMember(nodeIn.MemberName);
this.sql.Append(memberName);
return(nodeIn);
}
public bool TryResolveNamespace(MemberAccessNode node, out ISyntaxElement resolved, out SymbolNode namespaceNode)
{
if (node.Left is ISyntaxToken token && _table.Defined(token.Name, out var symbol) && symbol.Type == SymbolType.Namespace)
{
namespaceNode = (SymbolNode)symbol;
resolved = node.Right;
return(true);
}
public void MemberAccessExpressionHasExpectedExpression()
{
IExpressionNode actual = TestObject.Build(TestMemberAccessExpression);
MemberAccessNode actualNode = actual.VerifyIsActually <MemberAccessNode>();
ParameterNode expressionNode = actualNode.Expression.VerifyIsActually <ParameterNode>();
Assert.AreSame(TestParameterExpression, expressionNode.SourceExpression);
}
public void Visit(MemberAccessNode memberAccess)
{
memberAccess.Left.Parent = memberAccess;
memberAccess.Right.Parent = memberAccess;
// Only visit the left side of member accesses
// The right side doesn't belong to the scope so it doesn't matter.
memberAccess.Left.Accept(this);
}
public void MemberAccessExpressionIsExpected()
{
Expression testExpression = TestMemberAccessExpression;
IExpressionNode actual = TestObject.Build(testExpression);
MemberAccessNode actualNode = actual.VerifyIsActually <MemberAccessNode>();
Assert.AreSame(testExpression, actualNode.SourceExpression);
}
protected override CrawlSyntaxNode VisitCall(CallNode call)
{
CallNode expr = (CallNode)base.VisitCall(call);
CrawlType resultType = CrawlType.ErrorType;
List <CrawlType> actualParameters = expr.Arguments.Select(x => x.Value.ResultType).ToList();
//Three posibilities exist:
//Method type is provided as method name in specific scope.
MemberAccessNode asMem = expr.Target as MemberAccessNode;
//Method type is provided as a method name. Find candidates and choose best fit.
VariableNode asVar = expr.Target as VariableNode;
if (expr.Target.ResultType is CrawlStatusType)
{
return(expr.WithResultType(expr.Target.ResultType));
}
else if (asVar != null)
{
var foo = asVar
.FindFirstScope();
var bar = foo
.FindSymbol(asVar.Name);
List <CrawlMethodType> candidates = bar
.SelectMany(GetMethodTypesFromTypeInformation)
.ToList();
resultType = BestParameterMatch(candidates, actualParameters);
}
else if (asMem != null)
{
List <CrawlMethodType> candidates = asMem
.Target.ResultType
.FindSymbol(asMem.Member.Value)
.SelectMany(GetMethodTypesFromTypeInformation)
.ToList();
resultType = BestParameterMatch(candidates, actualParameters);
}
//Method type is provided by some other expression. In this case it either matches or does not.
else
{
CrawlMethodType methodSignature = expr.Target.ResultType as CrawlMethodType;
if (methodSignature != null)
{
resultType = Call(methodSignature, actualParameters);
}
}
return(expr.WithResultType(resultType));
}
public void Init()
{
_testExpression = Expression.MakeMemberAccess(TestParameter, TestMember);
MockNodeFactory
.Setup(factory => factory.Build(TestParameter))
.Returns(MockExpressionNode.Object);
TestObject = new MemberAccessNode(
MockNodeFactory.Object,
TestExpression);
}
public static VariableSymbolTableEntry AccessMember(MemberAccessNode memberAccessNode)
{
try
{
return(AccessMember(memberAccessNode.Identifiers));
}
catch
{
DazelLogger.EmitError($"Member not found in {memberAccessNode}", memberAccessNode.Token);
}
return(null);
}
public bool ApplyBehaviour(List <ASTNode> nodes, int opIndex, OrderMethod caller)
{
if (nodes[opIndex - 1].Is <IdentifierNode>().Is <ThisNode>().Or <MemberAccessNode>() && nodes[opIndex + 1] is IdentifierNode accessId)
{
IExpr accessExpr = nodes[opIndex - 1] as IExpr;
nodes[opIndex - 1] = new MemberAccessNode(accessExpr, accessId, this.m_symbol, nodes[opIndex].Pos);
nodes.RemoveAt(opIndex + 1);
nodes.RemoveAt(opIndex);
return(true);
}
else
{
return(false);
}
}
public override ValueNode GetReturnType(List <ValueNode> parameters)
{
if (parameters[0] is ArrayNode coords && parameters[1] is MemberAccessNode memberAccess)
{
ValueNode = new TileExitValueNode(coords.ToVector2(), memberAccess)
{
Token = memberAccess.Token
};
MemberAccessNode = memberAccess;
return(ValueNode);
}
InvalidArgumentsException(parameters);
return(null);
}
public void ParseMemberAccess()
{
DateTime d = new DateTime(2010, 12, 25);
Expression <Func <int> > f = () => d.Day;
MemberAccessNode node = (MemberAccessNode)NaturalExpressionParser.Parse(f.Body);
MemberAccessNode expected = new MemberAccessNode
{
Container = new ConstantNode {
Text = "d", Value = d.ToString()
},
MemberName = "Day",
MemberValue = "25"
};
Assert.AreEqual(expected, node);
}
private void SetupForExpression(Expression <Func <TestEntity, int> > testExpression)
{
TestExpression = testExpression;
TestParameterExpression = TestExpression
.Parameters
.Single();
MockNodeFactory
.Setup(factory => factory.Build(TestExpression.Body))
.Returns(MockLambdaBodyNode.Object);
TestLambdaNode = new LambdaNode(MockNodeFactory.Object, TestExpression);
TestMemberExpression = (MemberExpression)TestExpression.Body;
MockNodeFactory
.Setup(factory => factory.Build(TestMemberExpression.Expression))
.Returns(MockMemberExpressionNode.Object);
TestMemberAccessNode = new MemberAccessNode(MockNodeFactory.Object, TestMemberExpression);
}
public override void VisitMemberAccess(MemberAccessNode memberAccessNode)
{
if (LambdaParameter != memberAccessNode.SourceExpression.Expression)
{
throw new InvalidOperationException("Property selection must be lambda parameter");
}
MemberInfo memberInfo = memberAccessNode
.SourceExpression
.Member;
if (!(memberInfo is PropertyInfo))
{
throw new InvalidOperationException("Must select a property");
}
SelectedProperty = memberInfo as PropertyInfo;
}
protected override CrawlSyntaxNode VisitMemberAccess(MemberAccessNode memberAccess)
{
var expr = (MemberAccessNode)base.VisitMemberAccess(memberAccess);
if (expr.Target.ResultType is CrawlStatusType)
{
return(expr.WithResultType(expr.Target.ResultType));
}
var results = expr.Target.ResultType.FindSymbol(expr.Member.Value);
if (results == null || results.Length == 0)
{
return(expr.WithResultType(CrawlType.ErrorType));
}
CrawlType resultType = expr.Target.ResultType.FindSymbol(expr.Member.Value)[0].Type;
return(expr.WithResultType(resultType));
}
public AstNode VisitMemberAccess(MemberAccessNode n)
{
Visit(n.Instance);
Visit(n.Operator);
Visit(n.MemberName);
if (!n.GenericArguments.IsNullOrEmpty())
{
Append("<");
Visit(n.GenericArguments[0]);
for (var i = 1; i < n.GenericArguments.Count; i++)
{
Append(", ");
Visit(n.GenericArguments[i]);
}
Append(">");
}
return(n);
}
private MemberAccessNode Process(MemberAccessNode node)
{
if (node.Type == null || node.Type == "void")
{
node.Type = "any";
}
if (node.Type != "any" || node.Member == null)
{
return(node);
}
Process(node.Member);
node.Type = node.Member.Type;
if (node.MemberType != node.Type)
{
node.MemberType = node.Type;
}
return(node);
}
public override void Visit(MemberAccessNode memberAccessNode)
{
ValueNode member = EnvironmentStore.AccessMember(memberAccessNode).ValueNode;
switch (member)
{
case ArrayNode arrayNode:
Result = Calculator.GetValue(arrayNode);
break;
case IntValueNode intValueNode:
Result = Calculator.GetValue(intValueNode.Value);
break;
case StringNode stringNode:
Result = Calculator.GetValue(stringNode.Value);
break;
case FloatValueNode floatValueNode:
Result = Calculator.GetValue(floatValueNode.Value);
break;
}
}
public MemberAccessNode VisitMemberAccess(DazelParser.MemberAccessContext context)
{
MemberAccessNode memberAccessNode;
// X.Y
if (context.children.Count == 3)
{
memberAccessNode = new MemberAccessNode
{
Token = context.Start,
Identifiers =
{
context.GetChild(0).GetText(),
context.GetChild(2).GetText(),
}
};
}
else if (context.children.Count == 5) // X.Y.Z
{
memberAccessNode = new MemberAccessNode
{
Token = context.Start,
Identifiers =
{
context.GetChild(0).GetText(),
context.GetChild(2).GetText(),
context.GetChild(4).GetText(),
}
};
}
else
{
throw new ArgumentException($"Member Access {context.GetChild(0).GetText()}");
}
return(memberAccessNode);
}
public override DynValue Visit(MemberAccessNode memberAccessNode)
{
var indexable = Visit(memberAccessNode.Indexable);
if (indexable.Type != DynValueType.Table)
{
throw new RuntimeException(
$"Attempt to access named member '{memberAccessNode.Identifier}' of non-indexable type {indexable.Type}",
memberAccessNode.Line
);
}
try
{
return(indexable.Table[memberAccessNode.Identifier]);
}
catch
{
throw new RuntimeException(
$"Member '{memberAccessNode.Identifier}' does not exist in this table.",
memberAccessNode.Line
);
}
}
public static bool IsLengthProperty(MemberAccessNode v)
{
return(IsLengthProperty(v.Value + ""));
}
public virtual XzaarExpression Visit(MemberAccessNode access)
{
return(null);
}
public static bool IsStringProperty(MemberAccessNode member)
{
return(IsStringProperty(member.Value + ""));
}
private static void GenerateMemberAccess(MemberAccessNode node, DataContext data)
{
GenerateExpression(node.SourceExpression, data);
Append(data, ".{0}", node.MemberName);
}
public void Visit(MemberAccessNode memberAccessNode)
{
sb.Append(string.Join(".", memberAccessNode.Identifiers.ToArray()));
}
public virtual void VisitMemberAccess(MemberAccessNode memberAccessNode) => throw new NotImplementedException();
public abstract DynValue Visit(MemberAccessNode memberAccessNode);
