public override BoundNode VisitLambda(BoundLambda node) { _sawLambdas = true; CheckRefReadOnlySymbols(node.Symbol); var oldContainingSymbol = _factory.CurrentFunction; try { _factory.CurrentFunction = node.Symbol; return(base.VisitLambda(node)); } finally { _factory.CurrentFunction = oldContainingSymbol; } }
internal static BoundNode RewriteLambda(BoundLambda node, TypeCompilationState compilationState, TypeMap typeMap, int recursionDepth, DiagnosticBag diagnostics) { try { var r = new ExpressionLambdaRewriter(compilationState, typeMap, node.Syntax, recursionDepth, diagnostics); var result = r.VisitLambdaInternal(node); if (!node.Type.Equals(result.Type, TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)) { diagnostics.Add(ErrorCode.ERR_MissingPredefinedMember, node.Syntax.Location, r.ExpressionType, "Lambda"); } return(result); } catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex) { diagnostics.Add(ex.Diagnostic); return(node); } }
private BoundExpression VisitLambdaInternal(BoundLambda node) { // prepare parameters so that they can be seen later var locals = ArrayBuilder <LocalSymbol> .GetInstance(); var initializers = ArrayBuilder <BoundExpression> .GetInstance(); var parameters = ArrayBuilder <BoundExpression> .GetInstance(); foreach (var p in node.Symbol.Parameters) { var param = _bound.SynthesizedLocal(ParameterExpressionType); locals.Add(param); var parameterReference = _bound.Local(param); parameters.Add(parameterReference); var parameter = ExprFactory( "Parameter", _bound.Typeof(_typeMap.SubstituteType(p.Type.TypeSymbol).TypeSymbol), _bound.Literal(p.Name)); initializers.Add(_bound.AssignmentExpression(parameterReference, parameter)); _parameterMap[p] = parameterReference; } var underlyingDelegateType = node.Type.GetDelegateType(); var result = _bound.Sequence(locals.ToImmutableAndFree(), initializers.ToImmutableAndFree(), ExprFactory( "Lambda", ImmutableArray.Create <TypeSymbol>(underlyingDelegateType), TranslateLambdaBody(node.Body), _bound.ArrayOrEmpty(ParameterExpressionType, parameters.ToImmutableAndFree()))); foreach (var p in node.Symbol.Parameters) { _parameterMap.Remove(p); } return(result); }
public override BoundNode VisitLambda(BoundLambda node) { if (_inExpressionLambda) { var lambda = node.Symbol; foreach (var p in lambda.Parameters) { if (p.RefKind != RefKind.None && p.Locations.Length != 0) { _diagnostics.Add(ErrorCode.ERR_ByRefParameterInExpressionTree, p.Locations[0]); } if (p.Type.IsRestrictedType()) { _diagnostics.Add(ErrorCode.ERR_ExpressionTreeCantContainRefStruct, p.Locations[0], p.Type.Name); } } switch (node.Syntax.Kind()) { case SyntaxKind.ParenthesizedLambdaExpression: { var lambdaSyntax = (ParenthesizedLambdaExpressionSyntax)node.Syntax; if (lambdaSyntax.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword) { Error(ErrorCode.ERR_BadAsyncExpressionTree, node); } else if (lambdaSyntax.Body.Kind() == SyntaxKind.Block) { Error(ErrorCode.ERR_StatementLambdaToExpressionTree, node); } else if (lambdaSyntax.Body.Kind() == SyntaxKind.RefExpression) { Error(ErrorCode.ERR_BadRefReturnExpressionTree, node); } } break; case SyntaxKind.SimpleLambdaExpression: { var lambdaSyntax = (SimpleLambdaExpressionSyntax)node.Syntax; if (lambdaSyntax.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword) { Error(ErrorCode.ERR_BadAsyncExpressionTree, node); } else if (lambdaSyntax.Body.Kind() == SyntaxKind.Block) { Error(ErrorCode.ERR_StatementLambdaToExpressionTree, node); } else if (lambdaSyntax.Body.Kind() == SyntaxKind.RefExpression) { Error(ErrorCode.ERR_BadRefReturnExpressionTree, node); } } break; case SyntaxKind.AnonymousMethodExpression: Error(ErrorCode.ERR_ExpressionTreeContainsAnonymousMethod, node); break; default: // other syntax forms arise from query expressions, and always result from implied expression-lambda-like forms break; } } return(base.VisitLambda(node)); }
private BoundExpression VisitLambda(BoundLambda node) { var result = VisitLambdaInternal(node); return(node.Type.IsExpressionTree() ? ExprFactory("Quote", result) : result); }
// Control flow analysis does not normally scan the body of a lambda, but region analysis does. public override BoundNode VisitLambda(BoundLambda node) { return(VisitLocalFunctionOrLambda(node.Body)); }
public override BoundNode VisitLambda(BoundLambda node) { MakeSlots(node.Symbol.Parameters); return(base.VisitLambda(node)); }