C# InvocationExpressionSyntax.GetTrailingTrivia方法代码示例

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

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

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