C# InvocationExpressionSyntax.GetLeadingTrivia方法代码示例

        private async Task<Document> ChangeToOneLiteral(InvocationExpressionSyntax ex, Document document, CancellationToken cancellationToken)
        {
            var literal1 = ex.GetLiteralExpression();
            if (literal1 == null) return document;

            var literal2 = ex.GetLiteralArgument();
            if (literal2 == null) return document;

            var x = int.Parse(literal1.Token.ValueText);
            var y = int.Parse(literal2.Token.ValueText);
            var newValue = 0;

            switch (ex.GetMemberName())
            {
                case "Add": newValue = x + y; break;
                case "Sub": newValue = x - y; break;
                case "Mul": newValue = x * y; break;
                case "Div": newValue = x / y; break;
            }

            var newLiteral = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(newValue))
                .WithLeadingTrivia(ex.GetLeadingTrivia())
                .WithTrailingTrivia(ex.GetTrailingTrivia())
                ;

            var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = oldRoot.ReplaceNode(ex, newLiteral);

            return document.WithSyntaxRoot(newRoot);
        }

        public ExpressionSyntax Replace(InvocationExpressionSyntax invocation)
        {
            var replacement = string.Format(@"Nake.TaskRegistry.Invoke(""{0}"", {1})",
                                              task.FullName, BuildArgumentString(invocation));

            return SyntaxFactory.ParseExpression(replacement)
                         .WithLeadingTrivia(invocation.GetLeadingTrivia());
        }

        private async Task<Document> ChangetoAwaitGetAwaiterAsync(Document document, InvocationExpressionSyntax invocation, CancellationToken cancellationTkn)
        {
            SyntaxNode expression = invocation;
            while (!(expression is ExpressionStatementSyntax))
            {
                expression = expression.Parent;
            }

            var oldExpression = expression as ExpressionStatementSyntax;
            var awaitedInvocation = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AwaitExpression, invocation.WithLeadingTrivia(SyntaxFactory.Space)).WithLeadingTrivia(invocation.GetLeadingTrivia());
            var newExpression = oldExpression.WithExpression(awaitedInvocation);

            var oldroot = await document.GetSyntaxRootAsync(cancellationTkn).ConfigureAwait(false);
            var newroot = oldroot.ReplaceNode(oldExpression, newExpression);
            var newDocument = document.WithSyntaxRoot(newroot);

            return newDocument;
        }

        private async Task<Document> ToDelayWhenAnyWhenAllAsync(Document document, InvocationExpressionSyntax invocation, string name, CancellationToken cancellationToken)
        {
            var simpleExpression = SyntaxFactory.ParseName("");
            if (name.Equals("WaitAny"))
            {
                simpleExpression = SyntaxFactory.ParseName("System.Threading.Tasks.Task.WhenAny").WithAdditionalAnnotations(Simplifier.Annotation);
            }
            else if (name.Equals("WaitAll"))
            {
                simpleExpression = SyntaxFactory.ParseName("System.Threading.Tasks.Task.WhenAll").WithAdditionalAnnotations(Simplifier.Annotation);
            }
            else if (name.Equals("Sleep"))
            {
                simpleExpression = SyntaxFactory.ParseName("System.Threading.Tasks.Task.Delay").WithAdditionalAnnotations(Simplifier.Annotation);
            }

            SyntaxNode oldExpression = invocation;
            var expression = invocation.WithExpression(simpleExpression).WithLeadingTrivia(invocation.GetLeadingTrivia()).WithTrailingTrivia(invocation.GetTrailingTrivia());

            var newExpression = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.AwaitExpression, expression.WithLeadingTrivia(SyntaxFactory.Space)).WithTrailingTrivia(invocation.GetTrailingTrivia()).WithLeadingTrivia(invocation.GetLeadingTrivia());

            var oldroot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var newroot = oldroot.ReplaceNode(oldExpression, newExpression);

            var newDocument = document.WithSyntaxRoot(newroot);

            return newDocument;
        }

        private static InvocationExpressionSyntax TryReduceExtensionMethod(InvocationExpressionSyntax node, SemanticModel semanticModel, InvocationExpressionSyntax rewrittenNode, SimpleNameSyntax expressionName)
        {
            var targetSymbol = semanticModel.GetSymbolInfo(expressionName);

            if (targetSymbol.Symbol != null && targetSymbol.Symbol.Kind == SymbolKind.Method)
            {
                var targetMethodSymbol = (IMethodSymbol)targetSymbol.Symbol;
                if (!targetMethodSymbol.IsReducedExtension())
                {
                    var argumentList = node.ArgumentList;
                    var noOfArguments = argumentList.Arguments.Count;

                    if (noOfArguments > 0)
                    {
                        MemberAccessExpressionSyntax newMemberAccess = null;
                        var invocationExpressionNodeExpression = node.Expression;

                        if (node.Expression.CSharpKind() == SyntaxKind.SimpleMemberAccessExpression)
                        {
                            newMemberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, argumentList.Arguments.ElementAt(0).Expression, ((MemberAccessExpressionSyntax)invocationExpressionNodeExpression).OperatorToken, ((MemberAccessExpressionSyntax)invocationExpressionNodeExpression).Name);
                        }
                        else if (node.Expression.CSharpKind() == SyntaxKind.IdentifierName)
                        {
                            newMemberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, argumentList.Arguments.ElementAt(0).Expression, (IdentifierNameSyntax)invocationExpressionNodeExpression.WithLeadingTrivia());
                        }
                        else if (node.Expression.CSharpKind() == SyntaxKind.GenericName)
                        {
                            newMemberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, argumentList.Arguments.ElementAt(0).Expression, (GenericNameSyntax)invocationExpressionNodeExpression.WithLeadingTrivia());
                        }
                        else
                        {
                            Debug.Assert(false, "The expression kind is not MemberAccessExpression or IdentifierName or GenericName to be converted to Member Access Expression for Ext Method Reduction");
                        }

                        if (newMemberAccess == null)
                        {
                            return node;
                        }

                        // Preserve Trivia
                        newMemberAccess = newMemberAccess.WithLeadingTrivia(node.GetLeadingTrivia());

                        // Below removes the first argument
                        // we need to reuse the separators to maintain existing formatting & comments in the arguments itself
                        var newArguments = SyntaxFactory.SeparatedList<ArgumentSyntax>(argumentList.Arguments.GetWithSeparators().AsEnumerable().Skip(2));

                        var rewrittenArgumentList = argumentList.WithArguments(newArguments);
                        var candidateRewrittenNode = SyntaxFactory.InvocationExpression(newMemberAccess, rewrittenArgumentList);

                        var oldSymbol = semanticModel.GetSymbolInfo(node).Symbol;
                        var newSymbol = semanticModel.GetSpeculativeSymbolInfo(
                            node.SpanStart,
                            candidateRewrittenNode,
                            SpeculativeBindingOption.BindAsExpression).Symbol;

                        if (oldSymbol != null && newSymbol != null)
                        {
                            if (newSymbol.Kind == SymbolKind.Method && oldSymbol.Equals(((IMethodSymbol)newSymbol).GetConstructedReducedFrom()))
                            {
                                rewrittenNode = candidateRewrittenNode;
                            }
                        }
                    }
                }
            }

            return rewrittenNode;
        }

 private static CompilationUnitSyntax ReplaceStaticCallWithExtionMethodCall(CompilationUnitSyntax root, InvocationExpressionSyntax staticInvocationExpression, ExpressionSyntax sourceExpression, SimpleNameSyntax methodName, ArgumentListSyntax argumentList)
 {
     var extensionInvocationExpression = CallExtensionMethodAsExtensionAnalyzer.CreateInvocationExpression(sourceExpression, methodName, argumentList)
         .WithLeadingTrivia(staticInvocationExpression.GetLeadingTrivia());
     return root.ReplaceNode(staticInvocationExpression, extensionInvocationExpression);
 }

 public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
 {
     if (invocation != null)
     {
         methodInvocationAnalyzer.SetMethodInvocation(node);
         if (methodInvocationAnalyzer.HasSameMethodName(invocation))
         {
             if (NeedAssignment(invocation))
             {
                 // Return an expression with the assignment to the missed return value.
                 return Syntax.ParseExpression(returnSymbolName + " = " + node.GetText()).
                     WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(
                         node.GetTrailingTrivia());
             }
         }
     }
     return null;
 }

        private Method TraverseInvocationExpression(InvocationExpressionSyntax ies)
        {
            //TODO
            //get method name and accessed variables
            //and attributes and qualifiers
            Method retIm = new Method();

            if (ies.HasLeadingTrivia)
            {
                SetOuterComments(retIm, ies.GetLeadingTrivia().ToFullString());
            }

            if (ies.HasTrailingTrivia)
            {
                SetInnerComments(retIm, ies.GetTrailingTrivia().ToFullString());
            }
            //havent tested this with extra stuff like setting the variable equal to the method call
            //or with variables in the method call
            var methods = from aMethod in ies.ChildNodes().OfType<IdentifierNameSyntax>() select aMethod;
            foreach (IdentifierNameSyntax ins in methods)
            {
                InvokedMethod tempMethod = new InvokedMethod();
                tempMethod.Name = ins.Identifier.ValueText;
                retIm.InvokedMethods.Add(tempMethod);
            }
            //var args = from aArg in ies.ArgumentList.Arguments.OfType<ArgumentSyntax>() select aArg;
            //foreach (ArgumentSyntax asyn in args)
            //{
            //    Variables tempVar = new Variables();

            //}
            var args = from aArg in ies.Expression.ChildNodes().OfType<IdentifierNameSyntax>() select aArg;
            foreach (IdentifierNameSyntax ins in args)
            {
                Variables tempVar = new Variables();
                tempVar.Name = ins.Identifier.ValueText;
                retIm.AccessedVariables.Add(tempVar);
            }
            retIm.Name = ies.Expression.ToString();
            return retIm;
        }