public static LambdaExpressionNode CreateLambdaFunction(LambdaExpressionNode lambda, ListNode <IDeclareNode> args, ITypeNode?ret, bool isimplicit)
{
lambda.Arguments.AddRange(args.List);
lambda.Return = ret;
lambda.IsImplicit = isimplicit;
return(lambda);
}
public void Parse_LambdaNoParameters()
{
ASTNode root = ExpressionParser.Parse("() => value");
LambdaExpressionNode node = AssertInstanceOfAndReturn <LambdaExpressionNode>(root);
Assert.AreEqual(0, node.signature.Count);
}
public void Parse_LambdaUnTypedParameters_1()
{
ASTNode root = ExpressionParser.Parse("(value) => value");
LambdaExpressionNode node = AssertInstanceOfAndReturn <LambdaExpressionNode>(root);
Assert.AreEqual(1, node.signature.Count);
Assert.AreEqual(null, node.signature[0].type);
Assert.AreEqual("value", node.signature[0].identifier);
}
private static PythonNode Wrap(LambdaExpression exp, PythonNode parent)
{
var result = new LambdaExpressionNode(exp)
{
Parent = parent
};
result.AddChild(Wrap(exp.Function, result));
return(result);
}
public void Parse_LambdaTypedParameter_2()
{
ASTNode root = ExpressionParser.Parse("(string value, System.Collections.Generic.List<int> listValue) => value");
LambdaExpressionNode node = AssertInstanceOfAndReturn <LambdaExpressionNode>(root);
Assert.AreEqual(2, node.signature.Count);
Assert.AreEqual("string", node.signature[0].type.Value.typeName);
Assert.AreEqual("value", node.signature[0].identifier);
Assert.AreEqual(typeof(List <int>), TypeProcessor.ResolveType(node.signature[1].type.Value));
Assert.AreEqual("listValue", node.signature[1].identifier);
}
public override void Visit(LambdaExpressionNode node)
{
var scope = PushFunctionScope();
foreach (var param in node.ParameterList.Parameters.Nodes)
{
var name = param.NameToken;
if (name.IsMissing)
{
continue;
}
_scope.Define(SyntaxSymbolKind.Immutable, null, param, name.Text);
var duplicate = false;
foreach (var param2 in node.ParameterList.Parameters.Nodes)
{
if (param2 != param && param2.NameToken.Text == name.Text)
{
duplicate = true;
break;
}
}
if (!duplicate)
{
continue;
}
Error(param, SyntaxDiagnosticKind.DuplicateParameter, name.Location,
$"Lambda parameter '{name}' declared multiple times");
}
base.Visit(node);
node.SetAnnotation("Freezes", scope.GetFreezes());
var upvalues = ImmutableArray <SyntaxUpvalueSymbol> .Empty;
// Avoid LINQ allocations if there are no upvalues.
if (scope.Upvalues.Count != 0)
{
foreach (var upvalue in scope.Upvalues.Values.OrderBy(x => x.Slot))
{
upvalues = upvalues.Add(upvalue);
}
}
node.SetAnnotation("Upvalues", upvalues);
PopScope();
}
protected override Void handleLambda(LambdaExpressionNode lambda, Set <TypeInfo> dependencies, bool nested)
{
var m = lambda.getUserData(typeof(MethodInfo));
foreach (var p in m.Parameters)
{
addDependencies(p.Type, dependencies);
}
statementHandler.handleStatement(lambda.Body, dependencies);
return(null);
}
public void Parse_LambdaWithBody()
{
ASTNode root = ExpressionParser.Parse("(value) => 1 + 1");
LambdaExpressionNode node = AssertInstanceOfAndReturn <LambdaExpressionNode>(root);
Assert.AreEqual(1, node.signature.Count);
Assert.AreEqual(null, node.signature[0].type);
Assert.AreEqual("value", node.signature[0].identifier);
OperatorNode operatorNode = AssertInstanceOfAndReturn <OperatorNode>(node.body);
Assert.AreEqual(OperatorType.Plus, operatorNode.operatorType);
Assert.IsInstanceOf <LiteralNode>(operatorNode.left);
Assert.IsInstanceOf <LiteralNode>(operatorNode.right);
}
public LambdaComparer(LambdaExpressionNode lambdaExpression)
{
FunctionNode functionNode = new FunctionNode();
functionNode.Text = "compare";
VariableNode x = new VariableNode();
x.Text = "x";
VariableNode y = new VariableNode();
y.Text = "y";
functionNode.addChild(x);
functionNode.addChild(y);
_fn = functionNode;
_variables = new Hashtable();
_variables.Add( "compare", lambdaExpression );
}
/// <summary>
/// Sorts the source collection using custom sort criteria.
/// </summary>
/// <remarks>
/// Please note that your compare function needs to take care about
/// proper conversion of types to be comparable!
/// </remarks>
/// <param name="source">
/// The source collection to sort.
/// </param>
/// <param name="args">
/// Sort criteria to use.
/// </param>
/// <returns>
/// A sorted array containing collection elements.
/// </returns>
public object Process(ICollection source, object[] args)
{
if (source == null || source.Count == 0)
{
return(source);
}
if (args == null || args.Length != 1)
{
throw new ArgumentException("compare expression is a required argument for orderBy");
}
object arg = args[0];
IComparer comparer = null;
if (arg is string)
{
IExpression expCompare = Expression.Parse((string)arg);
comparer = new SimpleExpressionComparer(expCompare);
}
else if (arg is IComparer)
{
comparer = (IComparer)arg;
}
else if (arg is LambdaExpressionNode)
{
LambdaExpressionNode fnCompare = (LambdaExpressionNode)arg;
if (fnCompare.ArgumentNames.Length != 2)
{
throw new ArgumentException("compare function must accept 2 arguments");
}
comparer = new LambdaComparer(fnCompare);
}
else if (arg is Delegate)
{
comparer = new DelegateComparer((Delegate)arg);
}
AssertUtils.ArgumentNotNull(comparer, "comparer", "orderBy(comparer) argument 'comparer' does not evaluate to a supported type");
ArrayList list = new ArrayList(source);
list.Sort(comparer);
return(list);
}
private void Write(LambdaExpressionNode exp)
{
_code.Append("lambda ");
var function = exp.Children[0];
var numberOfParameters = function.Children.Count - 1;
for (var i = 0; i < numberOfParameters; i++)
{
var arg = function.Children[i];
Write(arg);
if (i < numberOfParameters - 1)
{
_code.Append(", ");
}
}
_code.Append(": ");
Write(function.Children.Last(), false);
}
public LambdaComparer(LambdaExpressionNode lambdaExpression)
{
FunctionNode functionNode = new FunctionNode();
functionNode.Text = "compare";
VariableNode x = new VariableNode();
x.Text = "x";
VariableNode y = new VariableNode();
y.Text = "y";
functionNode.addChild(x);
functionNode.addChild(y);
_fn = functionNode;
_variables = new Dictionary <string, object>();
_variables.Add("compare", lambdaExpression);
}
public LambdaComparer(LambdaExpressionNode lambdaExpression)
{
var functionNode = new FunctionNode {
Text = "compare"
};
var x = new VariableNode {
Text = "x"
};
var y = new VariableNode {
Text = "y"
};
functionNode.addChild(x);
functionNode.addChild(y);
_fn = functionNode;
_variables = new Dictionary <string, object>
{
{ "compare", lambdaExpression }
};
}
public void enterLambda(LambdaExpressionNode declaration)
{
methodInfos.add(declaration.getUserData(typeof(MethodInfo)));
}
public override Node CloneForFunctionCall(int clonedId, Node[] functionInputs)
{
if (clonedId != _clonedId)
{
_clonedId = clonedId;
// Do not use object initialization syntax for the return values because the recursive call needs to return this instance
var cloned = new LambdaExpressionNode(_thisFunction) { Parameter = Parameter };
_cloned = cloned;
cloned.ReturnValue1 = ReturnValue1.CloneForFunctionCall(clonedId, functionInputs);
cloned.ReturnValue2 = ReturnValue2.CloneForFunctionCall(clonedId, functionInputs);
}
return _cloned;
}
public override Node CloneForLambdaInvoke(int clonedId, LambdaExpressionParameterNode lambdaParameter, Node lambdaArgument)
{
if (_evaluated || lambdaParameter == Parameter || (OuterParameters != null && OuterParameters.Contains(lambdaParameter)))
return this;
if (clonedId != _clonedId)
{
_clonedId = clonedId;
var cloned = new LambdaExpressionNode(_thisFunction) { Parameter = Parameter };
_cloned = cloned;
cloned.ReturnValue1 = ReturnValue1.CloneForLambdaInvoke(clonedId, lambdaParameter, lambdaArgument);
cloned.ReturnValue2 = ReturnValue2.CloneForLambdaInvoke(clonedId, lambdaParameter, lambdaArgument);
cloned.OuterParameters = OuterParameters.ArrayUnion(lambdaParameter);
}
return _cloned;
}
public IExpressionNode Visit(IExpressionNode node)
{
var member = node as IMemberExpressionNode;
var resourceExpressionNode = member?.Target as ResourceExpressionNode;
if (resourceExpressionNode != null)
{
//$self, $this --> $BindingServiceProvider.ResourceResolver.SelfResourceName
if (member.Member == "self" || member.Member == "this")
{
if (resourceExpressionNode.Dynamic)
{
return(new MemberExpressionNode(member.Target, BindingServiceProvider.ResourceResolver.SelfResourceName));
}
return(new MethodCallExpressionNode(member.Target, DefaultBindingParserHandler.GetSelfMethod, null, null));
}
//$context --> $BindingServiceProvider.ResourceResolver.DataContextResourceName
if (member.Member == "context")
{
return(new MemberExpressionNode(member.Target, BindingServiceProvider.ResourceResolver.DataContextResourceName));
}
//$args, $arg --> $GetEventArgs()
if (member.Member == "args" || member.Member == "arg")
{
return(new MethodCallExpressionNode(member.Target, DefaultBindingParserHandler.GetEventArgsMethod, null, null));
}
//$binding --> $GetBinding()
if (member.Member == "binding")
{
return(new MethodCallExpressionNode(member.Target, DefaultBindingParserHandler.GetBindingMethod, null, null));
}
}
var methodCallExp = node as IMethodCallExpressionNode;
if (methodCallExp != null && methodCallExp.Target is ResourceExpressionNode)
{
//$OneTime(Expression) --> oneTimeImpl.GetValue(GetBinding(), () => Expression)
if (methodCallExp.Method == "OneTime" && methodCallExp.Arguments.Count == 1)
{
DataConstant <object> constant = Guid.NewGuid().ToString("n");
var idEx = new ConstantExpressionNode(constant);
var getBindEx = new MethodCallExpressionNode(ResourceExpressionNode.DynamicInstance, DefaultBindingParserHandler.GetBindingMethod, null, null);
IExpressionNode getValueEx = new LambdaExpressionNode(methodCallExp.Arguments[0], null);
return(new MethodCallExpressionNode(new ConstantExpressionNode(typeof(BindingExtensions)), "GetOrAddValue", new[]
{
getBindEx, idEx, getValueEx
}, null).Accept(this));
}
//Alias ($Format(), $MethodName, etc) --> type.Format()
Type type;
string method;
if (BindingServiceProvider.ResourceResolver.TryGetMethodAlias(methodCallExp.Method, out type, out method))
{
return(new MethodCallExpressionNode(new ConstantExpressionNode(type), method, methodCallExp.Arguments, methodCallExp.TypeArgs).Accept(this));
}
}
var nodes = new List <IExpressionNode>();
var members = new List <string>();
string memberName = node.TryGetMemberName(true, true, nodes, members);
if (memberName == null)
{
var relativeExp = nodes[0] as IRelativeSourceExpressionNode;
if (relativeExp != null)
{
relativeExp.MergePath(BindingExtensions.MergePath(members));
return(relativeExp);
}
var methodCall = nodes[0] as IMethodCallExpressionNode;
if (methodCall != null && methodCall.Target is ResourceExpressionNode)
{
if (RelativeSourceAliases.Contains(methodCall.Method))
{
if ((methodCall.Arguments.Count == 1 || methodCall.Arguments.Count == 2) &&
methodCall.Arguments[0] is IMemberExpressionNode)
{
int level = 1;
var relativeType = (IMemberExpressionNode)methodCall.Arguments[0];
if (methodCall.Arguments.Count == 2)
{
level = (int)((IConstantExpressionNode)methodCall.Arguments[1]).Value;
}
return(RelativeSourceExpressionNode.CreateRelativeSource(relativeType.Member, (uint)level,
BindingExtensions.MergePath(members)));
}
}
if (ElementSourceAliases.Contains(methodCall.Method))
{
if (methodCall.Arguments.Count == 1 && methodCall.Arguments[0] is IMemberExpressionNode)
{
var elementSource = (IMemberExpressionNode)methodCall.Arguments[0];
return(RelativeSourceExpressionNode.CreateElementSource(elementSource.Member,
BindingExtensions.MergePath(members)));
}
}
}
}
return(node);
}
public static AnonymousFunctionBody LambdaExpressionDefinition(ILexicalScope scope, LambdaExpressionNode lambda)
{
var root = Lookup.GetRootNamespace(scope.Namespace);
var fbody = MakeAnonymousFunction(root);
fbody.IsImplicit = lambda.IsImplicit;
if (lambda.Return is { } ret)
{
fbody.Return = CreateType(scope, ret);
}
lambda.Arguments.Each(x => fbody.Arguments.Add((new VariableValue(x.Name.Name), x is DeclareNode decla ? CreateType(scope, decla.Type) : new TypeImplicit())));
FunctionBodyDefinition(fbody, lambda.Statements);
return(fbody);
}
public LambdaComparer(LambdaExpressionNode lambdaExpression)
{
var functionNode = new FunctionNode {Text = "compare"};
var x = new VariableNode {Text = "x"};
var y = new VariableNode {Text = "y"};
functionNode.addChild(x);
functionNode.addChild(y);
_fn = functionNode;
_variables = new Dictionary<string, object>
{
{"compare", lambdaExpression}
};
}
protected override AssignmentState handleLambda(LambdaExpressionNode lambda, HashSet <StatementNode> visited, bool nested)
{
assignmentChecker.visitStatement(lambda.Body, visited);
return(AssignmentState.NotAssigned);
}
public SpecificationFromNode(LambdaExpressionNode node)
{
IsSatisfied = node.ToExpression <Func <T, bool> >();
}
public IExpressionNode Visit(IExpressionNode node)
{
var member = node as IMemberExpressionNode;
if (member != null && member.Target is ResourceExpressionNode)
{
//$self, $this --> $BindingServiceProvider.ResourceResolver.SelfResourceName
if (member.Member == "self" || member.Member == "this")
{
return(new MemberExpressionNode(member.Target, BindingServiceProvider.ResourceResolver.SelfResourceName));
}
//$context --> $BindingServiceProvider.ResourceResolver.DataContextResourceName
if (member.Member == "context")
{
return(new MemberExpressionNode(member.Target, BindingServiceProvider.ResourceResolver.DataContextResourceName));
}
//$args, $arg --> $GetEventArgs()
if (member.Member == "args" || member.Member == "arg")
{
return(new MethodCallExpressionNode(member.Target, DefaultBindingParserHandler.GetEventArgsMethod, Empty.Array <IExpressionNode>(), Empty.Array <string>()));
}
}
var methodCallExp = node as IMethodCallExpressionNode;
if (methodCallExp != null && methodCallExp.Target is ResourceExpressionNode)
{
//$Format() --> string.Format()
if (methodCallExp.Method == "Format")
{
return(new MethodCallExpressionNode(new ConstantExpressionNode(typeof(string)), methodCallExp.Method, methodCallExp.Arguments, methodCallExp.TypeArgs));
}
//$OneTime(Expression) --> oneTimeImpl.GetValue(() => Expression)
if (methodCallExp.Method == "OneTime" && methodCallExp.Arguments.Count == 1)
{
var item = new ConstantExpressionNode(new OneTimeImpl());
IExpressionNode parameter = new LambdaExpressionNode(methodCallExp.Arguments[0], null);
return(new MethodCallExpressionNode(item, OneTimeImpl.GetValueMethodName, new[] { parameter }, null));
}
}
var nodes = new List <IExpressionNode>();
var members = new List <string>();
string memberName = node.TryGetMemberName(true, true, nodes, members);
if (memberName == null)
{
var relativeExp = nodes[0] as IRelativeSourceExpressionNode;
if (relativeExp != null)
{
relativeExp.MergePath(BindingExtensions.MergePath(members));
return(relativeExp);
}
var methodCall = nodes[0] as IMethodCallExpressionNode;
if (methodCall != null && methodCall.Target is ResourceExpressionNode)
{
if (RelativeSourceAliases.Contains(methodCall.Method))
{
if ((methodCall.Arguments.Count == 1 || methodCall.Arguments.Count == 2) &&
methodCall.Arguments[0] is IMemberExpressionNode)
{
int level = 1;
var relativeType = (IMemberExpressionNode)methodCall.Arguments[0];
if (methodCall.Arguments.Count == 2)
{
level = (int)((IConstantExpressionNode)methodCall.Arguments[1]).Value;
}
return(RelativeSourceExpressionNode.CreateRelativeSource(relativeType.Member, (uint)level,
BindingExtensions.MergePath(members)));
}
}
if (ElementSourceAliases.Contains(methodCall.Method))
{
if (methodCall.Arguments.Count == 1 && methodCall.Arguments[0] is IMemberExpressionNode)
{
var elementSource = (IMemberExpressionNode)methodCall.Arguments[0];
return(RelativeSourceExpressionNode.CreateElementSource(elementSource.Member,
BindingExtensions.MergePath(members)));
}
}
}
}
return(node);
}
