Beispiel #1
0
        private static async Task <Document> RefactorAsync(
            Document document,
            ForEachStatementSyntax forEachStatement,
            IEnumerable <ISymbol> deconstructSymbols,
            ISymbol identifierSymbol,
            SemanticModel semanticModel,
            CancellationToken cancellationToken)
        {
            int         position              = forEachStatement.SpanStart;
            ITypeSymbol elementType           = semanticModel.GetForEachStatementInfo(forEachStatement).ElementType;
            SyntaxNode  enclosingSymbolSyntax = semanticModel.GetEnclosingSymbolSyntax(position, cancellationToken);

            ImmutableArray <ISymbol> declaredSymbols = semanticModel.GetDeclaredSymbols(enclosingSymbolSyntax, excludeAnonymousTypeProperty: true, cancellationToken);

            ImmutableArray <ISymbol> symbols = declaredSymbols
                                               .Concat(semanticModel.LookupSymbols(position))
                                               .Distinct()
                                               .Except(deconstructSymbols)
                                               .ToImmutableArray();

            Dictionary <string, string> newNames = deconstructSymbols
                                                   .Select(parameter =>
            {
                string name    = StringUtility.FirstCharToLower(parameter.Name);
                string newName = NameGenerator.Default.EnsureUniqueName(name, symbols);

                return(name: parameter.Name, newName);
            })
                                                   .ToDictionary(f => f.name, f => f.newName);

            var rewriter = new DeconstructForeachVariableRewriter(identifierSymbol, newNames, semanticModel, cancellationToken);

            var newStatement = (StatementSyntax)rewriter.Visit(forEachStatement.Statement);

            DeclarationExpressionSyntax variableExpression = DeclarationExpression(
                CSharpFactory.VarType().WithTriviaFrom(forEachStatement.Type),
                ParenthesizedVariableDesignation(
                    deconstructSymbols.Select(parameter =>
            {
                return(SingleVariableDesignation(
                           Identifier(SyntaxTriviaList.Empty, newNames[parameter.Name], SyntaxTriviaList.Empty)));
            })
                    .ToSeparatedSyntaxList <VariableDesignationSyntax>())
                .WithTriviaFrom(forEachStatement.Identifier))
                                                             .WithFormatterAnnotation();

            ForEachVariableStatementSyntax forEachVariableStatement = ForEachVariableStatement(
                forEachStatement.AttributeLists,
                forEachStatement.AwaitKeyword,
                forEachStatement.ForEachKeyword,
                forEachStatement.OpenParenToken,
                variableExpression,
                forEachStatement.InKeyword,
                forEachStatement.Expression,
                forEachStatement.CloseParenToken,
                newStatement);

            return(await document.ReplaceNodeAsync(forEachStatement, forEachVariableStatement, cancellationToken).ConfigureAwait(false));
        }
Beispiel #2
0
        public override Evaluation VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
        {
            node.Statement?.Accept <Evaluation>(this);
            node.Variable?.Accept <Evaluation>(this);
            node.Expression?.Accept <Evaluation>(this);

            return(base.VisitForEachVariableStatement(node));
        }
Beispiel #3
0
        public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
        {
            node.Statement?.Accept(this);
            node.Variable?.Accept(this);
            node.Expression?.Accept(this);

            base.VisitForEachVariableStatement(node);
        }
Beispiel #4
0
                public override SyntaxNode VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
                {
                    if (node != this.ContainerOfStatementsOrFieldToReplace)
                    {
                        return(base.VisitForEachVariableStatement(node));
                    }

                    return(node.WithExpression(VisitNode(node.Expression))
                           .WithStatement(ReplaceStatementIfNeeded(node.Statement)));
                }
Beispiel #5
0
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     Visit(node.Expression);
     HandleParallelBlocks(new Action[]
     {
         () =>
         {
             Visit(node.Variable);
             Visit(node.Statement);
             Visit(node.Expression);
             Visit(node.Statement);
         }
     }, true);
 }
Beispiel #6
0
 public static Doc Print(ForEachVariableStatementSyntax node)
 {
     return(Doc.Concat(
                ExtraNewLines.Print(node),
                Token.Print(node.AwaitKeyword, " "),
                Token.Print(node.ForEachKeyword, " "),
                Token.Print(node.OpenParenToken),
                Node.Print(node.Variable),
                " ",
                Token.Print(node.InKeyword, " "),
                Node.Print(node.Expression),
                Token.Print(node.CloseParenToken),
                Node.Print(node.Statement)
                ));
 }
Beispiel #7
0
        public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
        {
            if (!PreVisit(node))
            {
                return;
            }

            node.Statement?.Accept(this);
            node.Variable?.Accept(this);
            node.Expression?.Accept(this);

            base.VisitForEachVariableStatement(node);

            PostVisit(node);
        }
Beispiel #8
0
 private Doc PrintForEachVariableStatementSyntax(
     ForEachVariableStatementSyntax node)
 {
     return(Concat(
                this.PrintExtraNewLines(node),
                this.PrintSyntaxToken(node.AwaitKeyword, " "),
                this.PrintSyntaxToken(node.ForEachKeyword, " "),
                this.PrintSyntaxToken(node.OpenParenToken),
                this.Print(node.Variable),
                " ",
                this.PrintSyntaxToken(node.InKeyword, " "),
                this.Print(node.Expression),
                this.PrintSyntaxToken(node.CloseParenToken),
                this.Print(node.Statement)
                ));
 }
Beispiel #9
0
        public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
        {
            Visit(node.Expression);

            _breakingFromCx.Push(new HashSet <int>(_currentPathParents));
            _continuingFromCx.Push(new HashSet <int>());

            Visit(node.Statement);

            var continuedFrom = _continuingFromCx.Pop();

            _currentPathParents.UnionWith(continuedFrom);

            Visit(node.Variable);

            var breakedFrom = _breakingFromCx.Pop();

            _currentPathParents.UnionWith(breakedFrom);
        }
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     AddVariableExpressions(node.Variable, _expressions);
     AddExpressionTerms(node.Expression, _expressions);
 }
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
 }
Beispiel #12
0
 public TameForEachVariableStatementSyntax(ForEachVariableStatementSyntax node)
 {
     Node = node;
     AddChildren();
 }
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     LogicalLineCount++;
     base.VisitForEachVariableStatement(node);
 }
Beispiel #14
0
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     VisitStatementIfNotNull(node.Statement);
 }
        /// <inheritdoc/>
        public override SyntaxNode?VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
        {
            Context.ReportDiagnostic(ForEachStatement, node);

            return(base.VisitForEachVariableStatement(node));
        }
Beispiel #16
0
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     Visit(node.Expression);
     HandleConditionalBlock(new SyntaxNode[] { node.Variable, node.Statement }, validatedGuard: node.Expression);
 }
Beispiel #17
0
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     throw new NotImplementedException();
 }
Beispiel #18
0
 public override SyntaxNode VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     return(node);
 }
 //
 // Summary:
 //     Called when the visitor visits a ForEachVariableStatementSyntax node.
 public virtual void VisitForEachVariableStatement(ForEachVariableStatementSyntax node);
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     Visit(node.Expression);
     Visit(node.Statement);
     //base.VisitForEachVariableStatement(node);
 }
 public override StatementSyntax VisitForEachVariableStatement([NotNull] ForEachVariableStatementSyntax node)
 {
     return(node.Statement);
 }
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     AddVariableExpressions(node.Variable, _expressions);
     AddExpressionTerms(node.Expression, _expressions);
 }
Beispiel #23
0
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     VisitCommonForEachStatement(node);
 }
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     Log(node, "Unsupported Syntax !");
 }
 override public void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     Complexity++;
     base.VisitForEachVariableStatement(node);
 }
 public override void VisitForEachVariableStatement([NotNull] ForEachVariableStatementSyntax node)
 {
     LoopStatementLocation = node.ForEachKeyword.GetLocation();
 }
Beispiel #27
0
 public override void VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
 {
     VisitCommonForEachStatement(node);
 }
    /// <inheritdoc/>
    public override SyntaxNode?VisitForEachVariableStatement(ForEachVariableStatementSyntax node)
    {
        Diagnostics.Add(ForEachStatement, node);

        return(base.VisitForEachVariableStatement(node));
    }