public override void VisitSwitchSection(SwitchSectionSyntax node)
{
var patternBinder = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, patternBinder);
foreach (SwitchLabelSyntax label in node.Labels)
{
switch (label.Kind())
{
case SyntaxKind.CasePatternSwitchLabel:
{
var switchLabel = (CasePatternSwitchLabelSyntax)label;
Visit(switchLabel.Pattern, patternBinder);
if (switchLabel.WhenClause != null)
{
Visit(switchLabel.WhenClause.Condition, patternBinder);
}
break;
}
case SyntaxKind.CaseSwitchLabel:
{
var switchLabel = (CaseSwitchLabelSyntax)label;
Visit(switchLabel.Value, patternBinder);
break;
}
}
}
foreach (StatementSyntax statement in node.Statements)
{
Visit(statement, patternBinder);
}
}
public override void VisitEqualsValueClause(EqualsValueClauseSyntax node)
{
var valueBinder = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, valueBinder);
Visit(node.Value, valueBinder);
}
public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node)
{
var arrowBinder = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, arrowBinder);
Visit(node.Expression, arrowBinder);
}
// methodsWithYields will contain all function-declaration-like CSharpSyntaxNodes with yield statements contained within them.
// Currently the types of these are restricted to only be whatever the syntax parameter is, plus any LocalFunctionStatementSyntax contained within it.
// This may change if the language is extended to allow iterator lambdas, in which case the lambda would also be returned.
// (lambdas currently throw a diagnostic in WithLambdaParametersBinder.GetIteratorElementType when a yield is used within them)
public static SmallDictionary <SyntaxNode, Binder> BuildMap(
Symbol containingMemberOrLambda,
SyntaxNode syntax,
Binder enclosing,
ArrayBuilder <SyntaxNode> methodsWithYields,
Action <Binder, SyntaxNode> binderUpdatedHandler = null)
{
var builder = new LocalBinderFactory(containingMemberOrLambda, syntax, enclosing, methodsWithYields);
StatementSyntax statement;
var expressionSyntax = syntax as ExpressionSyntax;
if (expressionSyntax != null)
{
enclosing = new ExpressionVariableBinder(syntax, enclosing);
if ((object)binderUpdatedHandler != null)
{
binderUpdatedHandler(enclosing, syntax);
}
builder.AddToMap(syntax, enclosing);
builder.Visit(expressionSyntax, enclosing);
}
else if (syntax.Kind() != SyntaxKind.Block && (statement = syntax as StatementSyntax) != null)
{
CSharpSyntaxNode embeddedScopeDesignator;
enclosing = builder.GetBinderForPossibleEmbeddedStatement(statement, enclosing, out embeddedScopeDesignator);
if ((object)binderUpdatedHandler != null)
{
binderUpdatedHandler(enclosing, embeddedScopeDesignator);
}
if (embeddedScopeDesignator != null)
{
builder.AddToMap(embeddedScopeDesignator, enclosing);
}
builder.Visit(statement, enclosing);
}
else
{
if ((object)binderUpdatedHandler != null)
{
binderUpdatedHandler(enclosing, null);
}
builder.Visit((CSharpSyntaxNode)syntax, enclosing);
}
// the other place this is possible is in a local function
if (builder._sawYield)
{
methodsWithYields.Add(syntax);
}
return(builder._map);
}
public override void VisitConstructorDeclaration(ConstructorDeclarationSyntax node)
{
Binder enclosing = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, enclosing);
Visit(node.Initializer, enclosing);
Visit(node.Body, enclosing);
Visit(node.ExpressionBody, enclosing);
}
public override void VisitForStatement(ForStatementSyntax node)
{
Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda);
var patternBinder = new ExpressionVariableBinder(node.Expression, _enclosing);
AddToMap(node.Expression, patternBinder);
Visit(node.Expression, patternBinder);
var binder = new ForEachLoopBinder(patternBinder, node);
AddToMap(node, binder);
VisitPossibleEmbeddedStatement(node.Statement, binder);
}
public override void VisitAttribute(AttributeSyntax node)
{
var attrBinder = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, attrBinder);
if (node.ArgumentList?.Arguments.Count > 0)
{
foreach (AttributeArgumentSyntax argument in node.ArgumentList.Arguments)
{
Visit(argument.Expression, attrBinder);
}
}
}
public override void VisitConstructorInitializer(ConstructorInitializerSyntax node)
{
var binder = _enclosing.WithAdditionalFlags(BinderFlags.ConstructorInitializer);
AddToMap(node, binder);
if (node.ArgumentList != null)
{
if (_root == node)
{
binder = new ExpressionVariableBinder(node.ArgumentList, binder);
AddToMap(node.ArgumentList, binder);
}
Visit(node.ArgumentList, binder);
}
}
public override void VisitSwitchExpression(SwitchExpressionSyntax node)
{
var switchExpressionBinder = new SwitchExpressionBinder(node, _enclosing);
AddToMap(node, switchExpressionBinder);
Visit(node.GoverningExpression, switchExpressionBinder);
foreach (SwitchExpressionArmSyntax arm in node.Arms)
{
var armScopeBinder = new ExpressionVariableBinder(arm, switchExpressionBinder);
var armBinder = new SwitchExpressionArmBinder(arm, armScopeBinder, switchExpressionBinder);
AddToMap(arm, armBinder);
Visit(arm.Pattern, armBinder);
if (arm.WhenClause != null)
{
Visit(arm.WhenClause, armBinder);
}
Visit(arm.Expression, armBinder);
}
}
private void VisitLambdaExpression(LambdaExpressionSyntax node)
{
// Do not descend into a lambda unless it is a root node
if (_root != node)
{
return;
}
CSharpSyntaxNode body = node.Body;
if (body.Kind() == SyntaxKind.Block)
{
VisitBlock((BlockSyntax)body);
}
else
{
var binder = new ExpressionVariableBinder(body, _enclosing);
AddToMap(body, binder);
Visit(body, binder);
}
}
public SwitchExpressionArmBinder(SwitchExpressionArmSyntax arm, ExpressionVariableBinder armScopeBinder, SwitchExpressionBinder switchExpressionBinder) : base(armScopeBinder)
{
this._arm = arm;
this._armScopeBinder = armScopeBinder;
this._switchExpressionBinder = switchExpressionBinder;
}
