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));
}
