/// <summary> /// Resolves a lambda return type when its argument types have been inferred from usage. /// </summary> public Type ResolveLambda(LambdaNode lambda, Type[] argTypes) { lambda.SetInferredArgumentTypes(argTypes); var delegateType = lambda.Resolve(this); return(ReflectionHelper.WrapDelegate(delegateType).ReturnType); }
/// <summary> /// Binds a LambdaToken to metadata. /// </summary> /// <param name="lambdaToken">Token to bind.</param> /// <param name="state">Object to hold the state of binding.</param> /// <returns>A metadata bound any or all node.</returns> internal LambdaNode BindLambdaToken(LambdaToken lambdaToken, BindingState state) { ExceptionUtils.CheckArgumentNotNull(lambdaToken, "LambdaToken"); ExceptionUtils.CheckArgumentNotNull(state, "state"); // Start by binding the parent token CollectionNode parent = this.BindParentToken(lambdaToken.Parent); RangeVariable rangeVariable = null; // Add the lambda variable to the stack if (lambdaToken.Parameter != null) { rangeVariable = NodeFactory.CreateParameterNode(lambdaToken.Parameter, parent); state.RangeVariables.Push(rangeVariable); } // Bind the expression SingleValueNode expression = this.BindExpressionToken(lambdaToken.Expression); // Create the node LambdaNode lambdaNode = NodeFactory.CreateLambdaNode(state, parent, expression, rangeVariable, lambdaToken.Kind); // Remove the lambda variable as it is now out of scope if (rangeVariable != null) { state.RangeVariables.Pop(); } return(lambdaNode); }
static VBParameter ExtractLambdaParameter(NameNode name) { if (name == null) { return(null); } if (!(name.Parent is DeclaratorNode) || !(name.Parent.Parent is ParameterNode)) { return(null); } LambdaNode lambdaNode = name.Parent.Parent.Parent as LambdaNode; if (lambdaNode == null) { return(null); } LambdaExpression lambdaExpression = name.Tree.SourceFile.Binder.CompileExpression(lambdaNode) as LambdaExpression; if (lambdaExpression == null) { return(null); } return(lambdaExpression.Parameters .FirstOrDefault(p => p.Name.EqualsNoCase(((IdentifierNode)name).Name))); }
public void LambdaExpressionBodyIsExpected() { IExpressionNode actual = TestObject.Build(TestLambdaExpression); LambdaNode actualNode = actual.VerifyIsActually <LambdaNode>(); ConstantNode bodyNode = actualNode.Body.VerifyIsActually <ConstantNode>(); Assert.AreSame(TestConstantZero, bodyNode.SourceExpression); }
public void LambdaExpressionIsExpected() { Expression testExpression = TestLambdaExpression; IExpressionNode actual = TestObject.Build(testExpression); LambdaNode actualNode = actual.VerifyIsActually <LambdaNode>(); Assert.AreSame(testExpression, actualNode.SourceExpression); }
public void Init() { _testExpression = Expression.Lambda(TestBodyExpression, TestParameterExpression); MockNodeFactory .Setup(factory => factory.Build(TestBodyExpression)) .Returns(MockBodyNode.Object); TestObject = new LambdaNode( MockNodeFactory.Object, TestExpression); }
private IEnumerable <string> VisitLambda(LambdaNode nodeIn) { var oldBase = BaseString; BaseString = Combine(nodeIn.Source); var returnVar = nodeIn.Body.Accept(this); if (!returnVar.Any() && BaseString != oldBase) { returnVar = new[] { BaseString }; } BaseString = oldBase; return(returnVar); }
public override void VisitLambda(LambdaNode lambdaNode) { if (SelectedProperty != null) { throw new InvalidOperationException("Cannot visit twice with the same visitor"); } LambdaParameter = lambdaNode .SourceExpression .Parameters .Single(); lambdaNode .Body .AcceptVisitor(this); }
public void VisitLambda(LambdaNode node) { UpdateLine(node); NewProcedure(node.Name, false, node.Varargs, node.Position.Line, false); UpdateLine(node); node.Parameters.ForEach(p => p.Accept(this)); node.Statements.ForEach(s => s.Accept(this)); if (node.Statements.Count == 0 || !(node.Statements.Last() is ReturnNode)) { asm.Return(); } Closure(FinishProcedure()); }
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); }
private QueryNode VisitLambda(LambdaNode nodeIn) { var sourceNode = (CollectionNavigationNode)nodeIn.Source; IsFilterable &= Filterable(sourceNode.NavigationProperty); if (IsFilterable) { bool isPushed = PushPropertySettings(sourceNode.NavigationProperty); nodeIn.Body.Accept(this); if (isPushed) { _settings.Pop(); } } return(nodeIn); }
public AstNode VisitLambda(LambdaNode n) { Append("(("); if (n.Parameters.Count > 0) { Visit(n.Parameters[0]); foreach (var p in n.Parameters.Skip(1)) { Append(", "); Visit(p); } } Append(") => "); if (n.Statements == null || n.Statements.Count == 0) { Append("{}"); } else if (n.Statements.Count == 1) { Visit(n.Statements[0]); } else { Append("{"); IncreaseIndent(); foreach (var statement in n.Statements) { AppendLineAndIndent(); Visit(statement); Append(";"); } DecreaseIndent(); AppendLineAndIndent(); Append("}"); } Append(")"); return(n); }
public void Visit(LambdaNode lambdaNode) { _table.Enter(lambdaNode.Scope); _environment = new Environment(_environment); foreach (var arg in lambdaNode.Arguments) { _environment.Define(arg.Name); } var inLambda = _inLambda; _inLambda = true; var enclosing = _currentMethod; _currentMethod = MethodType.Lambda; lambdaNode.Body.Parent = lambdaNode; lambdaNode.Body.Accept(this); _inLambda = inLambda; _currentMethod = enclosing; _environment = _environment.Enclosing; _table.Exit(); }
public void Accept(LambdaNode node) { var lambda = new HassiumMethod(module); methodStack.Push(lambda); lambda.Parent = classStack.Peek(); table.EnterScope(); foreach (var param in node.Parameters.Arguments) { string name = ((IdentifierNode)param).Identifier; lambda.Parameters.Add(new FunctionParameter(FunctionParameterType.Normal, name), table.HandleSymbol(name)); } node.Body.VisitChildren(this); table.LeaveScope(); methodStack.Pop(); emit(node.SourceLocation, InstructionType.PushObject, lambda); emit(node.SourceLocation, InstructionType.BuildClosure); }
/// <summary> /// lambda_line_expr = [ fun_args ] "->" line_expr /// </summary> private LambdaNode parseLambdaLineExpr() { var node = new LambdaNode(); node.Arguments = attempt(() => parseFunArgs()) ?? new List<FunctionArgument>(); if (!check(LexemType.Arrow)) return null; node.Body.Add(ensure(parseLineStmt, ParserMessages.FunctionBodyExpected)); return node; }
public LambdaNodeTests() { subject = new LambdaNode(SourcePosition.NIL); }
private LambdaNode ParseLambda() { Expect(TokenType.PROC); Next(); Expect(TokenType.LPAREN); Next(); var lambda = new LambdaNode(Position(-2)); while (More() && !Accept(TokenType.RPAREN)) { Expect(TokenType.FROZEN, TokenType.IDENT, TokenType.VARARGS); if (Accept(TokenType.FROZEN, TokenType.IDENT)) { bool frozen = false; while (Accept(TokenType.FROZEN)) { frozen = true; Next(); } lambda.Parameters.Add(new ParameterNode(Position(), ParseIdent(), frozen)); } else if (Accept(TokenType.VARARGS)) { lambda.Varargs = true; Next(); break; } else { Unexpected(); } if (Accept(TokenType.COMMA)) { ExpectNot(TokenType.RPAREN); Next(); } else { Expect(TokenType.RPAREN); } } Expect(TokenType.RPAREN); Next(); Expect(TokenType.FAT_ARROW, TokenType.LBRACE); if (Accept(TokenType.FAT_ARROW)) { Next(); lambda.Statements.Add(new ReturnNode(Position(), ParseExpression())); } else if (Accept(TokenType.LBRACE)) { Next(); while (More() && !Accept(TokenType.RBRACE)) { lambda.Statements.Add(ParseStatement()); } Expect(TokenType.RBRACE); Next(); } else { Unexpected(); } return(lambda); }
public virtual AstNode VisitLambda(LambdaNode n) { Visit(n.Parameters); Visit(n.Statements); return(n); }
/// <summary> /// Resolves a lambda return type when its argument types have been inferred from usage. /// </summary> public Type ResolveLambda(LambdaNode lambda, Type[] argTypes) { lambda.SetInferredArgumentTypes(argTypes); var delegateType = lambda.Resolve(this); return ReflectionHelper.WrapDelegate(delegateType).ReturnType; }
public virtual void VisitLambda(LambdaNode lambdaNode) => throw new NotImplementedException();
internal Closure(Scope parentScope, LambdaNode targetNode) { ParentScope = parentScope; Lambda = targetNode; }
public void VisitLambda(LambdaNode node) { VisitLambdaHandler(node); }
public XzaarExpression Visit(LambdaNode lambda) { return(null); }
private string ResolveLamdaNode(LambdaNode node) { BinaryOperatorNode expression = node.Body as BinaryOperatorNode; string alias = ""; string propertyName = ""; string parentPropertyName = ""; string rootPropertyName = ""; //Property at root if (expression.Left is NonentityRangeVariableReferenceNode) { var leftNode = expression.Left as NonentityRangeVariableReferenceNode; alias = leftNode.Name; if (node.Source is CollectionPropertyAccessNode) { propertyName = (node.Source as CollectionPropertyAccessNode).Property.Name; } } else if (expression.Left is SingleValuePropertyAccessNode) { var leftNode = expression.Left as SingleValuePropertyAccessNode; if (leftNode.Source is NonentityRangeVariableReferenceNode) { alias = (leftNode.Source as NonentityRangeVariableReferenceNode).Name; } else if (leftNode.Source is EntityRangeVariableReferenceNode) { alias = (leftNode.Source as EntityRangeVariableReferenceNode).Name; } propertyName = leftNode.Property.Name; if (node.Source is CollectionPropertyAccessNode) { parentPropertyName = (node.Source as CollectionPropertyAccessNode).Property.Name; var sourceNode = node.Source as CollectionPropertyAccessNode; if (sourceNode.Source is SingleValuePropertyAccessNode) { var rootNode = sourceNode.Source as SingleValuePropertyAccessNode; rootPropertyName = rootNode.Property.Name; } } else if (node.Source is CollectionNavigationNode) { var sourceNode = node.Source as CollectionNavigationNode; parentPropertyName = sourceNode.NavigationProperty.Name; if (sourceNode.Source is SingleNavigationNode) { var rootNode = sourceNode.Source as SingleNavigationNode; rootPropertyName = rootNode.NavigationProperty.Name; } } } var rightExpression = (expression.Right as ConstantNode).LiteralText; var mappedPropertyName = _fieldMapper.Map(propertyName, parentPropertyName, rootPropertyName); var lamdaProperty = node.Kind == QueryNodeKind.Any ? "any" : "all"; var expressionFormat = $"{mappedPropertyName}/{lamdaProperty}({alias}: {alias} eq {rightExpression})"; return(expressionFormat); }