public override void VisitArrowExpressionClause(ArrowExpressionClauseSyntax node) { var arrowBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, arrowBinder); Visit(node.Expression, arrowBinder); }
public override void VisitDeconstructionDeclarationStatement(DeconstructionDeclarationStatementSyntax node) { var patternBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, patternBinder); Visit(node.Assignment.Value, patternBinder); }
public override void VisitEqualsValueClause(EqualsValueClauseSyntax node) { var valueBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, valueBinder); Visit(node.Value, valueBinder); }
public override void VisitSwitchSection(SwitchSectionSyntax node) { var patternBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, patternBinder); foreach (var 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 static SmallDictionary <SyntaxNode, Binder> BuildMap( Symbol containingMemberOrLambda, SyntaxNode syntax, Binder enclosing, Action <Binder, SyntaxNode> binderUpdatedHandler = null ) { var builder = new LocalBinderFactory(containingMemberOrLambda, syntax, enclosing); 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); } return(builder._map); }
// 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, Func <Binder, SyntaxNode, Binder> rootBinderAdjusterOpt = 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)rootBinderAdjusterOpt != null) { enclosing = rootBinderAdjusterOpt(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)rootBinderAdjusterOpt != null) { enclosing = rootBinderAdjusterOpt(enclosing, embeddedScopeDesignator); } if (embeddedScopeDesignator != null) { builder.AddToMap(embeddedScopeDesignator, enclosing); } builder.Visit(statement, enclosing); } else { if ((object)rootBinderAdjusterOpt != null) { enclosing = rootBinderAdjusterOpt(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 VisitRecordDeclaration(RecordDeclarationSyntax node) { Debug.Assert(node.ParameterList is object); Binder enclosing = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, enclosing); Visit(node.PrimaryConstructorBaseType, enclosing); }
public SwitchExpressionArmBinder( SwitchExpressionArmSyntax arm, ExpressionVariableBinder armScopeBinder, SwitchExpressionBinder switchExpressionBinder ) : base(armScopeBinder) { this._arm = arm; this._armScopeBinder = armScopeBinder; this._switchExpressionBinder = switchExpressionBinder; }
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); }
// 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, Func<Binder, SyntaxNode, Binder> rootBinderAdjusterOpt = 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)rootBinderAdjusterOpt != null) { enclosing = rootBinderAdjusterOpt(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)rootBinderAdjusterOpt != null) { enclosing = rootBinderAdjusterOpt(enclosing, embeddedScopeDesignator); } if (embeddedScopeDesignator != null) { builder.AddToMap(embeddedScopeDesignator, enclosing); } builder.Visit(statement, enclosing); } else { if ((object)rootBinderAdjusterOpt != null) { enclosing = rootBinderAdjusterOpt(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; }
private void VisitConstructorInitializerArgumentList(CSharpSyntaxNode node, ArgumentListSyntax argumentList, Binder binder) { if (argumentList != null) { if (_root == node) { binder = new ExpressionVariableBinder(argumentList, binder); AddToMap(argumentList, binder); } Visit(argumentList, binder); } }
public override void VisitAttribute(AttributeSyntax node) { var attrBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, attrBinder); if (node.ArgumentList?.Arguments.Count > 0) { foreach (var argument in node.ArgumentList.Arguments) { Visit(argument.Expression, attrBinder); } } }
private void VisitCommonForEachStatement(CommonForEachStatementSyntax 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 VisitForStatement(ForStatementSyntax node) { Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda); Binder binder = new ForLoopBinder(_enclosing, node); AddToMap(node, binder); VariableDeclarationSyntax declaration = node.Declaration; if (declaration != null) { VisitRankSpecifiers(declaration.Type, binder); foreach (VariableDeclaratorSyntax variable in declaration.Variables) { Visit(variable, binder); } } else { foreach (ExpressionSyntax initializer in node.Initializers) { Visit(initializer, binder); } } ExpressionSyntax condition = node.Condition; if (condition != null) { binder = new ExpressionVariableBinder(condition, binder); AddToMap(condition, binder); Visit(condition, binder); } SeparatedSyntaxList <ExpressionSyntax> incrementors = node.Incrementors; if (incrementors.Count > 0) { var incrementorsBinder = new ExpressionListVariableBinder(incrementors, binder); AddToMap(incrementors.First(), incrementorsBinder); foreach (ExpressionSyntax incrementor in incrementors) { Visit(incrementor, incrementorsBinder); } } VisitPossibleEmbeddedStatement(node.Statement, binder); }
public override void VisitRecordDeclaration(RecordDeclarationSyntax node) { Debug.Assert(node.ParameterList is object); Binder enclosing = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, enclosing); if (node.BaseWithArguments is SimpleBaseTypeSyntax baseWithArguments) { enclosing = enclosing.WithAdditionalFlags(BinderFlags.ConstructorInitializer); AddToMap(baseWithArguments, enclosing); Visit(baseWithArguments.ArgumentList, enclosing); } }
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 VisitArgumentList(ArgumentListSyntax node) { if (_root == node) { // We are supposed to get here only for constructor initializers Debug.Assert(node.Parent is ConstructorInitializerSyntax); var argBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, argBinder); foreach (var arg in node.Arguments) { Visit(arg.Expression, argBinder); } } else { base.VisitArgumentList(node); } }
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); } }
// 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<CSharpSyntaxNode, Binder> BuildMap(Symbol containingMemberOrLambda, CSharpSyntaxNode syntax, Binder enclosing, ArrayBuilder<CSharpSyntaxNode> methodsWithYields) { var builder = new LocalBinderFactory(containingMemberOrLambda, syntax, enclosing, methodsWithYields); if (syntax is ExpressionSyntax) { var binder = new ExpressionVariableBinder(syntax, enclosing); builder.AddToMap(syntax, binder); builder.Visit(syntax, binder); } else { builder.Visit(syntax); } // the other place this is possible is in a local function if (builder._sawYield) methodsWithYields.Add(syntax); return builder._map; }
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 override void VisitSwitchSection(SwitchSectionSyntax node) { var patternBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, patternBinder); foreach (var label in node.Labels) { var match = label as CasePatternSwitchLabelSyntax; if (match != null) { Visit(match.Pattern, patternBinder); if (match.WhenClause != null) { Visit(match.WhenClause.Condition, patternBinder); } } } foreach (StatementSyntax statement in node.Statements) { Visit(statement, patternBinder); } }
public override void VisitIfStatement(IfStatementSyntax node) { var ifBinder = new ExpressionVariableBinder(node.Condition, _enclosing); AddToMap(node.Condition, ifBinder); Visit(node.Condition, ifBinder); VisitPossibleEmbeddedStatement(node.Statement, ifBinder); // pattern variables from the condition are not in scope within the else clause if (node.Else != null) AddToMap(node.Else.Statement, _enclosing); Visit(node.Else, _enclosing); }
public override void VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node) { var patternBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, patternBinder); foreach (var decl in node.Declaration.Variables) { var value = decl.Initializer?.Value; if (value != null) { Visit(value, patternBinder); } } }
public override void VisitLockStatement(LockStatementSyntax node) { var patternBinder = new ExpressionVariableBinder(node, _enclosing); var lockBinder = new LockBinder(patternBinder, node); AddToMap(node, lockBinder); Visit(node.Expression, lockBinder); StatementSyntax statement = node.Statement; var statementBinder = lockBinder.WithAdditionalFlags(BinderFlags.InLockBody); if (statementBinder != lockBinder) { AddToMap(statement, statementBinder); } VisitPossibleEmbeddedStatement(statement, statementBinder); }
public override void VisitForStatement(ForStatementSyntax node) { Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda); Binder binder = new ForLoopBinder(_enclosing, node); AddToMap(node, binder); var declaration = node.Declaration; if (declaration != null) { foreach (var variable in declaration.Variables) { Visit(variable, binder); } } else { foreach (var initializer in node.Initializers) { Visit(initializer, binder); } } ExpressionSyntax condition = node.Condition; if (condition != null) { binder = new ExpressionVariableBinder(condition, binder); AddToMap(condition, binder); Visit(condition, binder); } SeparatedSyntaxList<ExpressionSyntax> incrementors = node.Incrementors; if (incrementors.Count > 0) { var incrementorsBinder = new ExpressionListVariableBinder(incrementors, binder); AddToMap(incrementors.First(), incrementorsBinder); foreach (var incrementor in incrementors) { Visit(incrementor, incrementorsBinder); } } VisitPossibleEmbeddedStatement(node.Statement, binder); }
public override void VisitThrowStatement(ThrowStatementSyntax node) { if (node.Expression != null) { var patternBinder = new ExpressionVariableBinder(node, _enclosing); AddToMap(node, patternBinder); Visit(node.Expression, patternBinder); } }
public override void VisitSwitchStatement(SwitchStatementSyntax node) { Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda); var patternBinder = new ExpressionVariableBinder(node.Expression, _enclosing); AddToMap(node.Expression, patternBinder); Visit(node.Expression, patternBinder); var switchBinder = SwitchBinder.Create(patternBinder, node); AddToMap(node, switchBinder); foreach (SwitchSectionSyntax section in node.Sections) { Visit(section, switchBinder); } }
public override void VisitDoStatement(DoStatementSyntax node) { Debug.Assert((object)_containingMemberOrLambda == _enclosing.ContainingMemberOrLambda); var patternBinder = new ExpressionVariableBinder(node, _enclosing); var whileBinder = new WhileBinder(patternBinder, node); AddToMap(node, whileBinder); Visit(node.Condition, whileBinder); VisitPossibleEmbeddedStatement(node.Statement, whileBinder); }