C# MethodDeclarationSyntax.WithReturnType方法代码示例

        private SyntaxNode FixMethod(
            bool keepVoid, IMethodSymbol methodSymbol, MethodDeclarationSyntax method,
            ITypeSymbol taskType, INamedTypeSymbol taskOfTType)
        {
            var newReturnType = method.ReturnType;

            if (methodSymbol.ReturnsVoid)
            {
                if (!keepVoid)
                {
                    newReturnType = taskType.GenerateTypeSyntax();
                }
            }
            else
            {
                if (!IsTaskLike(methodSymbol.ReturnType, taskType, taskOfTType))
                {
                    // If it's not already Task-like, then wrap the existing return type
                    // in Task<>.
                    newReturnType = taskOfTType.Construct(methodSymbol.ReturnType).GenerateTypeSyntax();
                }
            }

            var newModifiers = method.Modifiers.Add(s_asyncToken);
            return method.WithReturnType(newReturnType).WithModifiers(newModifiers);
        }

        private async Task<Document> Convert2Task(Document document, MethodDeclarationSyntax methodDecl, CancellationToken cancellationToken)
        {
            var newType = SyntaxFactory.ParseTypeName("System.Threading.Tasks.Task").WithAdditionalAnnotations(Simplifier.Annotation).WithTrailingTrivia(methodDecl.ReturnType.GetTrailingTrivia());
            var newMethodDecl = methodDecl.WithReturnType(newType);

            var root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
            var newRoot = root.ReplaceNode(methodDecl, newMethodDecl);
            return document.WithSyntaxRoot(newRoot);
        }

        private async Task<Document> VoidToTaskAsync(Document document, MethodDeclarationSyntax methodDeclaration, CancellationToken cancellationToken)
        {
            // The Task object must be parsed from a string using the Syntax Factory
            var newType = SyntaxFactory.ParseTypeName("System.Threading.Tasks.Task").WithAdditionalAnnotations(Simplifier.Annotation).WithTrailingTrivia(methodDeclaration.ReturnType.GetTrailingTrivia());

            var newMethodDeclaration = methodDeclaration.WithReturnType(newType);

            var oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
            var newRoot = oldRoot.ReplaceNode(methodDeclaration, newMethodDeclaration);
            var newDocument = document.WithSyntaxRoot(newRoot);

            // Return document with transformed tree.
            return newDocument;
        }

        private SyntaxNode FixMethod(IMethodSymbol methodSymbol, MethodDeclarationSyntax method, ITypeSymbol taskType, ITypeSymbol taskOfTType)
        {
            var newReturnType = method.ReturnType;

            // If the return type is Task<T>, then make the new return type "T".
            // If it is Task, then make the new return type "void".
            if (methodSymbol.ReturnType.OriginalDefinition.Equals(taskType))
            {
                newReturnType = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.VoidKeyword)).WithTriviaFrom(method.ReturnType);
            }
            else if (methodSymbol.ReturnType.OriginalDefinition.Equals(taskOfTType))
            {
                newReturnType = methodSymbol.ReturnType.GetTypeArguments()[0].GenerateTypeSyntax().WithTriviaFrom(method.ReturnType);
            }

            var asyncTokenIndex = method.Modifiers.IndexOf(SyntaxKind.AsyncKeyword);
            SyntaxTokenList newModifiers;
            if (asyncTokenIndex == 0)
            {
                // Have to move the trivia on teh async token appropriately.
                var asyncLeadingTrivia = method.Modifiers[0].LeadingTrivia;

                if (method.Modifiers.Count > 1)
                {
                    // Move the trivia to the next modifier;
                    newModifiers = method.Modifiers.Replace(
                        method.Modifiers[1],
                        method.Modifiers[1].WithPrependedLeadingTrivia(asyncLeadingTrivia));
                    newModifiers = newModifiers.RemoveAt(0);
                }
                else
                {
                    // move it to the return type.
                    newModifiers = method.Modifiers.RemoveAt(0);
                    newReturnType = newReturnType.WithPrependedLeadingTrivia(asyncLeadingTrivia);
                }
            }
            else
            {
                newModifiers = method.Modifiers.RemoveAt(asyncTokenIndex);
            }

            return method.WithReturnType(newReturnType).WithModifiers(newModifiers);
        }

        private static SyntaxNode HandleMethodDeclaration(MethodDeclarationSyntax node)
        {
            TypeSyntax type = node.ReturnType;
            if (type == null || type.IsMissing)
            {
                return null;
            }

            SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref type, SyntaxKind.PrivateKeyword);
            return node
                .WithReturnType(type)
                .WithModifiers(modifiers)
                .WithoutFormatting();
        }

		private MethodDeclarationSyntax ConvertToAsyncFunction(MethodDeclarationSyntax methodDeclaration)
		{
			return methodDeclaration.WithReturnType(
				SyntaxFactory.ParseTypeName("Task")
				.WithLeadingTrivia(methodDeclaration.ReturnType.GetLeadingTrivia())
				.WithTrailingTrivia(methodDeclaration.ReturnType.GetTrailingTrivia()));
		}

 // set method return type to returnType
 protected internal static SyntaxNode MethodReturnType(MethodDeclarationSyntax methodDeclaration, string returnType)
 {
     TypeSyntax voidType = SyntaxFactory.ParseTypeName(returnType).WithTrailingTrivia(SyntaxFactory.Whitespace(" "));
     methodDeclaration = methodDeclaration.WithReturnType(voidType);
     return methodDeclaration;
 }

        private SyntaxNode rewriteEventHandler(MethodDeclarationSyntax node)
        {
            var code = (BlockSyntax)VisitBlock(node.Body);
            var args = node.ParameterList.ReplaceNodes(node.ParameterList.Parameters, (oldParam, newParam) =>
            {
                if (oldParam.Identifier.IsMissing)
                    return newParam.WithType(Void).
                                    WithIdentifier(SyntaxFactory.Identifier(newParam.Type.ToString()));

                return newParam;
            });

            var result = node.WithReturnType(Void).
                              WithParameterList(args).
                              WithModifiers(Private).
                              WithBody(code);

            return ctx_.AddLinker(result, (ctx, linkNode, newNode, model) =>
            {
                MethodDeclarationSyntax mthd   = (MethodDeclarationSyntax)linkNode;
                MethodDeclarationSyntax output = (MethodDeclarationSyntax)newNode;

                ParameterListSyntax methdArgs = mthd.ParameterList;

                string methodName = "on_" + mthd.Identifier.ToString();

                ISymbol     self = model.GetDeclaredSymbol(mthd);
                ITypeSymbol type = (ITypeSymbol)self.ContainingSymbol;

                string evName   = mthd.Identifier.ToString();
                string typeName = type.Name;
                bool   found    = false;
                while (type != null && !found)
                {
                    foreach (var ev in type.GetMembers().OfType<IEventSymbol>())
                    {
                        if (matchEventName(ev.Name, evName))
                        {
                            //arguments
                            foreach (var syntax in ev.Type.DeclaringSyntaxReferences)
                            {
                                var refNode = (DelegateDeclarationSyntax)syntax.GetSyntax();

                                int  pCount = methdArgs.Parameters.Count;
                                int  idx    = 0;
                                bool match  = true;
                                args = refNode.ParameterList.ReplaceNodes(refNode.ParameterList.Parameters, (oldArg, newArg) =>
                                {
                                    if (match)
                                    {
                                        if (idx >= pCount && match)
                                            return newArg;

                                        ParameterSyntax arg = methdArgs.Parameters[idx++];
                                        string argName = arg.Identifier.ToString();
                                        if (argName == oldArg.Identifier.ToString())
                                        {
                                            //coincident parameters, fix missing type or return same
                                            if (arg.Identifier.IsMissing || arg.Type.ToString() == "void")
                                                return newArg.WithIdentifier(arg.Identifier);

                                            return arg;
                                        }
                                        else
                                        {
                                            match = false;
                                            if (!refNode.ParameterList.Parameters.Any(p => p.Identifier.ToString().Equals(arg.Identifier.ToString())))
                                            {
                                                //name change?
                                                if (oldArg.Identifier.IsMissing)
                                                    return newArg.WithIdentifier(SyntaxFactory.Identifier(arg.Type.ToString()));

                                                return arg;
                                            }
                                        }
                                    }

                                    return newArg;
                                });
                            }

                            //register event initialization
                            ctx.AddTypeInfo(typeName, "initializer", EventInitializer(ev.Name, methodName));
                            found = true;
                            break;
                        }
                    }

                    type = type.BaseType;
                }

                if (!found)
                {
                    //td: error, no such event
                }

                return output.WithIdentifier(SyntaxFactory.Identifier(methodName)).
                              WithParameterList(args);
            });
        }

 private MethodDeclarationSyntax ConvertToAsyncFunction(MethodDeclarationSyntax methodDeclaration)
 {
     return methodDeclaration.WithReturnType(
         SyntaxFactory.ParseTypeName("Task")
             .WithTriviaFrom(methodDeclaration));
 }