private ReturnStatementSyntax CreateInvokeExecuteAsyncMethodBlockLocalResponseBuilderReturnBuildResponse() => SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("responseBuilder"), SyntaxFactory.IdentifierName(nameof(IMessageResponseBuilder.BuildResponseAsync)))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument( SyntaxFactory.SimpleLambdaExpression( SyntaxFactory.Parameter( SyntaxFactory.Identifier("x"))) .WithExpressionBody( SyntaxFactory.ObjectCreationExpression( SyntaxFactory.IdentifierName(EndpointResultTypeName)) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.Argument( SyntaxFactory.IdentifierName("x"))))))), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument( SyntaxFactory.IdentifierName(nameof(CancellationToken).EnsureFirstCharacterToLower())), })))));
private LocalDeclarationStatementSyntax CreateInvokeExecuteAsyncMethodBlockLocalResponse() { return(SyntaxFactory.LocalDeclarationStatement( SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("var")) .WithVariables( SyntaxFactory.SingletonSeparatedList( SyntaxFactory.VariableDeclarator( SyntaxFactory.Identifier("response")) .WithInitializer( SyntaxFactory.EqualsValueClause( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("client"), SyntaxFactory.IdentifierName(nameof(HttpClient.SendAsync)))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( new SyntaxNodeOrToken[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName("requestMessage")), SyntaxFactory.Token(SyntaxKind.CommaToken), SyntaxFactory.Argument(SyntaxFactory.IdentifierName("cancellationToken")), }))))))))) .WithUsingKeyword( SyntaxFactory.Token(SyntaxKind.UsingKeyword))); }
private static Task <Document> ChangeTypeAndAddAwait( Document document, SyntaxNode declaration, VariableDeclarationSyntax variableDeclaration, TypeSyntax type, ExpressionSyntax expression, ITypeSymbol newTypeSymbol, SemanticModel semanticModel, CancellationToken cancellationToken) { AwaitExpressionSyntax newExpression = SyntaxFactory.AwaitExpression(expression).WithTriviaFrom(expression); VariableDeclarationSyntax newVariableDeclaration = variableDeclaration.ReplaceNode(expression, newExpression); TypeSyntax newType = newTypeSymbol.ToMinimalTypeSyntax(semanticModel, type.SpanStart).WithTriviaFrom(type); newVariableDeclaration = newVariableDeclaration.WithType(newType); if (!SyntaxInfo.ModifierListInfo(declaration).IsAsync) { SyntaxNode newDeclaration = declaration .ReplaceNode(variableDeclaration, newVariableDeclaration) .InsertModifier(SyntaxKind.AsyncKeyword); return(document.ReplaceNodeAsync(declaration, newDeclaration, cancellationToken)); } return(document.ReplaceNodeAsync(variableDeclaration, newVariableDeclaration, cancellationToken)); }
private static BlockSyntax UpdateStatementsForAsyncMethod(BlockSyntax body, SemanticModel semanticModel, bool hasResultValue, bool returnTypeChanged, CancellationToken cancellationToken) { var fixedUpBlock = body.ReplaceNodes( body.DescendantNodes().OfType <ReturnStatementSyntax>(), (f, n) => { if (hasResultValue) { return(returnTypeChanged ? n : n.WithExpression(SyntaxFactory.AwaitExpression(n.Expression).TrySimplify(f.Expression, semanticModel, cancellationToken))); } if (body.Statements.Last() == f) { // If it is the last statement in the method, we can remove it since a return is implied. return(null); } return(n .WithExpression(null) // don't return any value .WithReturnKeyword(n.ReturnKeyword.WithTrailingTrivia(SyntaxFactory.TriviaList()))); // remove the trailing space after the keyword }); return(fixedUpBlock); }
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.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 ReturnStatementSyntax CreateCodeBlockReturnStatementForHelper(bool hasParameters) { var arguments = hasParameters ? new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("parameters"), SyntaxTokenFactory.Comma(), SyntaxArgumentFactory.Create("cancellationToken") } : new SyntaxNodeOrToken[] { SyntaxArgumentFactory.Create("cancellationToken") }; return(SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("handler"), SyntaxFactory.IdentifierName("ExecuteAsync"))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>(arguments)))))); }
public ExpressionSyntax Invoke(ClassModel owner, bool suppressAwait, IFrameworkSet frameworkSet, params CSharpSyntaxNode[] arguments) { if (owner == null) { throw new ArgumentNullException(nameof(owner)); } if (frameworkSet == null) { throw new ArgumentNullException(nameof(frameworkSet)); } if (arguments == null) { throw new ArgumentNullException(nameof(arguments)); } var ownerTargetInstance = Node.Modifiers.Any(x => x.IsKind(SyntaxKind.StaticKeyword)) ? owner.TypeSyntax : owner.TargetInstance; if (Node.ExplicitInterfaceSpecifier != null) { ownerTargetInstance = SyntaxFactory.ParenthesizedExpression(SyntaxFactory.CastExpression(Node.ExplicitInterfaceSpecifier.Name, ownerTargetInstance)); var typeSymbol = owner.SemanticModel.GetTypeInfo(Node.ExplicitInterfaceSpecifier.Name).Type; frameworkSet.Context.AddEmittedType(typeSymbol); } var expressionSyntax = Generate.MethodCall(ownerTargetInstance, Node, Name, frameworkSet, arguments); if (IsAsync && !suppressAwait) { return(SyntaxFactory.AwaitExpression(expressionSyntax)); } return(expressionSyntax); }
private Task <Document> UseAsyncOverload(Document document, InvocationExpressionSyntax invocation, SyntaxNode root, CancellationToken cancellationToken) { ExpressionSyntax newExpression; if (invocation.Expression is MemberAccessExpressionSyntax memberAccess) { newExpression = memberAccess.WithName(GetIdentifier(memberAccess.Name)); } else if (invocation.Expression is IdentifierNameSyntax identifierName) { newExpression = GetIdentifier(identifierName); } else if (invocation.Expression is GenericNameSyntax genericName) { newExpression = genericName.WithIdentifier(GetIdentifier(genericName).Identifier); } else { return(Task.FromResult(document)); } var newInvocation = invocation.WithExpression(newExpression); var awaitExpression = SyntaxFactory.AwaitExpression(newInvocation).WithAdditionalAnnotations(Formatter.Annotation); var newRoot = root.ReplaceNode(invocation, awaitExpression); var newDocument = document.WithSyntaxRoot(newRoot); return(Task.FromResult(newDocument)); }
private static async Task <Document> ChangeTypeAndAddAwaitAsync( Document document, VariableDeclarationSyntax variableDeclaration, ITypeSymbol typeSymbol, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); ExpressionSyntax initializerValue = variableDeclaration.Variables[0].Initializer.Value; AwaitExpressionSyntax newInitializerValue = SyntaxFactory.AwaitExpression(initializerValue) .WithTriviaFrom(initializerValue); VariableDeclarationSyntax newNode = variableDeclaration.ReplaceNode(initializerValue, newInitializerValue); newNode = newNode .WithType( CSharpFactory.Type(typeSymbol) .WithTriviaFrom(variableDeclaration.Type) .WithSimplifierAnnotation()); SyntaxNode newRoot = oldRoot.ReplaceNode(variableDeclaration, newNode); return(document.WithSyntaxRoot(newRoot)); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { Diagnostic?diagnostic = context.Diagnostics.First(); SyntaxNode?root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); if (TryFindNodeAtSource(diagnostic, root, out _, out _)) { context.RegisterCodeFix( CodeAction.Create( Strings.VSTHRD002_CodeFix_Await_Title, async ct => { Document?document = context.Document; if (TryFindNodeAtSource(diagnostic, root, out ExpressionSyntax? node, out Func <ExpressionSyntax, CancellationToken, ExpressionSyntax>?transform)) { (document, node, _) = await FixUtils.UpdateDocumentAsync( document, node, n => SyntaxFactory.AwaitExpression(transform(n, ct)), ct).ConfigureAwait(false); MethodDeclarationSyntax?method = node.FirstAncestorOrSelf <MethodDeclarationSyntax>(); if (method is object) { (document, method) = await FixUtils.MakeMethodAsync(method, document, ct).ConfigureAwait(false); } } return(document.Project.Solution); }, "only action"), diagnostic); } }
private ReturnStatementSyntax GetPaginatedReturnStatement(List <SyntaxNodeOrToken> paramArgList) { return(SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("Client"), SyntaxFactory.GenericName( SyntaxFactory.Identifier("CallApi")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.GenericName( SyntaxFactory.Identifier("ResponsePage")) .WithTypeArgumentList( SyntaxFactory.TypeArgumentList( SyntaxFactory.SingletonSeparatedList <TypeSyntax>( SyntaxFactory.IdentifierName(Returns))))))))) .WithArgumentList( SyntaxFactory.ArgumentList( SyntaxFactory.SeparatedList <ArgumentSyntax>( paramArgList.ToArray() )))))); }
public override SyntaxNode MakeSyntaxNode() { var res = SyntaxFactory.AwaitExpression(AwaitKeyword, Expression); IsChanged = false; return(res); }
protected override ExpressionSyntax CreateCallSignature() { var methodName = CreateMethodNameForInvocation().WithAdditionalAnnotations(Simplifier.Annotation); var arguments = new List <ArgumentSyntax>(); foreach (var argument in this.AnalyzerResult.MethodParameters) { var modifier = GetParameterRefSyntaxKind(argument.ParameterModifier); var refOrOut = modifier == SyntaxKind.None ? default(SyntaxToken) : SyntaxFactory.Token(modifier); arguments.Add(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(argument.Name)).WithRefOrOutKeyword(refOrOut)); } var invocation = SyntaxFactory.InvocationExpression(methodName, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))); var shouldPutAsyncModifier = this.CSharpSelectionResult.ShouldPutAsyncModifier(); if (!shouldPutAsyncModifier) { return(invocation); } return(SyntaxFactory.AwaitExpression(invocation)); }
public override async Task RegisterCodeFixesAsync(CodeFixContext context) { var diagnostic = context.Diagnostics.First(); var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); if (TryFindNodeAtSource(diagnostic, root, out _, out _)) { context.RegisterCodeFix( CodeAction.Create( Strings.VSTHRD002_CodeFix_Await_Title, async ct => { var document = context.Document; if (TryFindNodeAtSource(diagnostic, root, out var node, out var transform)) { (document, node, _) = await Utils.UpdateDocumentAsync( document, node, n => SyntaxFactory.AwaitExpression(transform(n, ct)), ct).ConfigureAwait(false); var method = node.FirstAncestorOrSelf <MethodDeclarationSyntax>(); if (method != null) { (document, method) = await Utils.MakeMethodAsync(method, document, ct).ConfigureAwait(false); } } return(document.Project.Solution); }, VSTHRD002UseJtfRunAnalyzer.Id), diagnostic); } }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { try { var diagnostic = context.Diagnostics.First(); context.RegisterCodeFix(CodeAction.Create("'await' before async method ", async token => { var document = context.Document; var root = await document.GetSyntaxRootAsync(token); var fullInvocationExpression = root.FindNode(diagnostic.Location.SourceSpan, false).Parent as InvocationExpressionSyntax; var awaitExpression = SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxKind.AwaitKeyword), fullInvocationExpression); var node = root.FindNode(diagnostic.Location.SourceSpan, false); var updatedParameterNode = node.ReplaceNode(node, awaitExpression); var newDoc = document.WithSyntaxRoot(root.ReplaceNode(fullInvocationExpression, updatedParameterNode)); return(newDoc); }, "KEY"), diagnostic); } catch (System.Exception ex) { throw; } }
private static void ChangeTypeAndAddAwait( CodeFixContext context, Diagnostic diagnostic, ExpressionSyntax expression, VariableDeclarationSyntax variableDeclaration, TypeSyntax type, ITypeSymbol newTypeSymbol, SemanticModel semanticModel) { AwaitExpressionSyntax newExpression = SyntaxFactory.AwaitExpression(expression).WithTriviaFrom(expression); VariableDeclarationSyntax newNode = variableDeclaration.ReplaceNode(expression, newExpression); TypeSyntax newType = newTypeSymbol.ToMinimalTypeSyntax(semanticModel, type.SpanStart).WithTriviaFrom(type); newNode = newNode.WithType(newType); string typeName = SymbolDisplay.ToMinimalDisplayString(newTypeSymbol, semanticModel, type.SpanStart, SymbolDisplayFormats.Default); CodeAction codeAction = CodeAction.Create( $"Change type to '{typeName}' and add await", cancellationToken => context.Document.ReplaceNodeAsync(variableDeclaration, newNode, cancellationToken), EquivalenceKey.Create(diagnostic, CodeFixIdentifiers.ChangeTypeAccordingToInitializer, "AddAwait")); context.RegisterCodeFix(codeAction, diagnostic); }
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node) { var visitedNode = (MethodDeclarationSyntax)base.VisitMethodDeclaration(node); if (ReferenceEquals(visitedNode, node) && _methodsWithOptionOverloads.Contains(node.Identifier.ValueText)) { // Don't generate methods where the body would call an overload. // The logic is a bit more complicated and there are only // two methods anyway. They can be written out by hand in the // partial class. return(SyntaxFactory.IncompleteMember()); } var returnTypeSymbol = _semanticModel.GetTypeInfo(node.ReturnType).Type as INamedTypeSymbol; bool isAsync = returnTypeSymbol != null && (returnTypeSymbol.Equals(_taskTypeSymbol) || returnTypeSymbol.ConstructedFrom.Equals(_taskOfTTypeSymbol)); if (isAsync) { visitedNode = visitedNode.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); var invocation = visitedNode.DescendantNodes().OfType <InvocationExpressionSyntax>().First(); visitedNode = visitedNode.ReplaceNode(invocation, SyntaxFactory.AwaitExpression(invocation)); } // wrap with try/catch visitedNode = visitedNode.WithBody(SyntaxFactory.Block(SyntaxFactory.TryStatement( block: visitedNode.Body, catches: SyntaxFactory.SingletonList( SyntaxFactory.CatchClause() .WithDeclaration( SyntaxFactory.CatchDeclaration( SyntaxFactory.IdentifierName("System.Exception")) .WithIdentifier( SyntaxFactory.Identifier("ex"))) .WithBlock( SyntaxFactory.Block( SyntaxFactory.SeparatedList( new StatementSyntax[] { SyntaxFactory.ExpressionStatement(SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("ProcessException")).AddArgumentListArguments(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("ex")))), SyntaxFactory.ThrowStatement(), })))), @finally: null))); if (isAsync && returnTypeSymbol.TypeArguments.FirstOrDefault() is INamedTypeSymbol argumentType && argumentType.IsGenericType && _responseTypeSymbols.Contains(argumentType.ConstructedFrom)) { var awaitSyntax = visitedNode.DescendantNodes().OfType <AwaitExpressionSyntax>().First(); visitedNode = visitedNode.ReplaceNode(awaitSyntax, SyntaxFactory.InvocationExpression(SyntaxFactory.IdentifierName("ProcessResponse")).AddArgumentListArguments(SyntaxFactory.Argument(awaitSyntax))); } return(visitedNode); }
ExpressionSyntax RewriteExpression(InvocationExpressionSyntax node, int cancellationTokenPos) { InvocationExpressionSyntax rewrittenInvocation = null; if (node.Expression is IdentifierNameSyntax) { var identifierName = (IdentifierNameSyntax)node.Expression; rewrittenInvocation = node.WithExpression(identifierName.WithIdentifier( SyntaxFactory.Identifier(identifierName.Identifier.Text + "Async") )); } else if (node.Expression is MemberAccessExpressionSyntax) { var memberAccessExp = (MemberAccessExpressionSyntax)node.Expression; var nestedInvocation = memberAccessExp.Expression as InvocationExpressionSyntax; if (nestedInvocation != null) { memberAccessExp = memberAccessExp.WithExpression((ExpressionSyntax)VisitInvocationExpression(nestedInvocation)); } rewrittenInvocation = node.WithExpression(memberAccessExp.WithName( memberAccessExp.Name.WithIdentifier( SyntaxFactory.Identifier(memberAccessExp.Name.Identifier.Text + "Async") ) )); } else if (node.Expression is GenericNameSyntax) { var genericNameExp = (GenericNameSyntax)node.Expression; rewrittenInvocation = node.WithExpression( genericNameExp.WithIdentifier(SyntaxFactory.Identifier(genericNameExp.Identifier.Text + "Async")) ); } else { throw new NotSupportedException($"It seems there's an expression type ({node.Expression.GetType().Name}) not yet supported by the AsyncRewriter"); } if (cancellationTokenPos != -1) { var cancellationTokenArg = SyntaxFactory.Argument(SyntaxFactory.IdentifierName("cancellationToken")); if (cancellationTokenPos == rewrittenInvocation.ArgumentList.Arguments.Count) { rewrittenInvocation = rewrittenInvocation.WithArgumentList( rewrittenInvocation.ArgumentList.AddArguments(cancellationTokenArg) ); } else { rewrittenInvocation = rewrittenInvocation.WithArgumentList(SyntaxFactory.ArgumentList( rewrittenInvocation.ArgumentList.Arguments.Insert(cancellationTokenPos, cancellationTokenArg) )); } } return(SyntaxFactory.AwaitExpression(rewrittenInvocation)); }
private async Task <Document> ReplaceWithAwait(Document document, MemberAccessExpressionSyntax resultExpression, CancellationToken cancellationToken) { SyntaxNode rootNode = await document.GetSyntaxRootAsync(cancellationToken); var newExpression = SyntaxFactory.AwaitExpression(resultExpression.Expression); rootNode = rootNode.ReplaceNode(resultExpression, newExpression.WithLeadingTrivia(newExpression.GetLeadingTrivia())).WithAdditionalAnnotations(Formatter.Annotation); return(document.WithSyntaxRoot(rootNode)); }
public static AwaitExpressionSyntax AsAwait(this ExpressionSyntax expression, bool addConfigureAwait = true) { if (addConfigureAwait) { expression = Invocations.Invoke(expression, "ConfigureAwait", Arguments.False); } return(SyntaxFactory.AwaitExpression(expression) .WithAwaitKeyword(SyntaxFactory.Token(SyntaxKind.AwaitKeyword))); }
public override StatementSyntax GetSyntax() { return(SyntaxFactory.ReturnStatement( SyntaxFactory.AwaitExpression( SyntaxFactory.InvocationExpression( SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName(DeferedEntity), SyntaxFactory.IdentifierName(MethodName)))))); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { if (node.HasAnnotation(this.callAnnotation)) { return(SyntaxFactory.ParenthesizedExpression( SyntaxFactory.AwaitExpression(node)) .WithAdditionalAnnotations(Simplifier.Annotation)); } return(base.VisitInvocationExpression(node)); }
/// <summary> /// This Method adds an await operator to the invocation expression. For example, Math.Round(5.5) invocation expression would return await Math.Abs(5.5). /// </summary> /// <returns></returns> public Func <SyntaxGenerator, SyntaxNode, SyntaxNode> GetAddAwaitOperatorAction(string _) { SyntaxNode AddAwaitOperator(SyntaxGenerator syntaxGenerator, SyntaxNode node) { AwaitExpressionSyntax newNode = SyntaxFactory.AwaitExpression(SyntaxFactory.ParseExpression(node.WithoutTrivia().NormalizeWhitespace().ToFullString())); // SyntaxFactory.AwaitExpression().NormalizeWhitespace(); newNode = newNode.WithTriviaFrom(node).NormalizeWhitespace(); return(SyntaxFactory.ExpressionStatement(newNode)); } return(AddAwaitOperator); }
/// <summary> /// Generate the statements for sending a HttpRequestMessage. /// </summary> /// <returns><see cref="LocalDeclarationStatementSyntax"/> statement.</returns> /// <remarks> /// var response = await httpClient.SendAsync(request); /// </remarks> private LocalDeclarationStatementSyntax CreateSendStatement() { var invocationExpressionSyntax = RoslynExtensions.CreateInvocationExpression( HttpClientVariableName, "SendAsync", SyntaxFactory.Argument(SyntaxFactory.IdentifierName(RequestVariableName))); var awaitExpression = SyntaxFactory.AwaitExpression(invocationExpressionSyntax); var declarationSyntax = RoslynExtensions.CreateVariableInitializationExpression("response", awaitExpression); return(SyntaxFactory.LocalDeclarationStatement(declarationSyntax)); }
protected async Task <Document> ReplaceWithAwaitExpressionAsync(Document document, SyntaxNode expression, CancellationToken cancellationToken, string expressionString) { var newAwaitExpression = SyntaxFactory.AwaitExpression( SyntaxFactory.Token(SyntaxKind.AwaitKeyword), SyntaxFactory.ParseExpression(expressionString)) .WithLeadingTrivia(expression.GetLeadingTrivia()) .WithTrailingTrivia(expression.GetTrailingTrivia()); var root = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = root.ReplaceNode(expression, newAwaitExpression); return(document.WithSyntaxRoot(newRoot)); }
private static ExpressionSyntax GetAsyncThrowsInvocation(InvocationExpressionSyntax invocation, string replacementMethod, MemberAccessExpressionSyntax memberAccess) { ExpressionSyntax asyncThrowsInvocation = invocation .WithExpression(memberAccess.WithName(GetName(replacementMethod, memberAccess))) .WithArgumentList(GetArguments(invocation)); if (invocation.Parent.IsKind(SyntaxKind.AwaitExpression)) { return(asyncThrowsInvocation); } return(SyntaxFactory.AwaitExpression(asyncThrowsInvocation.WithoutLeadingTrivia()) .WithLeadingTrivia(invocation.GetLeadingTrivia())); }
private static CSharpSyntaxNode UpdateStatementsForAsyncMethod(CSharpSyntaxNode body, SemanticModel semanticModel, bool hasResultValue) { var blockBody = body as BlockSyntax; if (blockBody != null) { return UpdateStatementsForAsyncMethod(blockBody, semanticModel, hasResultValue, returnTypeChanged: false/*probably not right, but we don't have a failing test yet.*/); } var expressionBody = body as ExpressionSyntax; if (expressionBody != null) { return SyntaxFactory.AwaitExpression(expressionBody).TrySimplify(expressionBody, semanticModel); } throw new NotSupportedException(); }
public SyntaxNode ChangeTree(Document doc, SemanticModel model, MemberAccessExpressionSyntax memberAccess, char?commitKey) { if (commitKey == '.' && memberAccess.Parent is MemberAccessExpressionSyntax) { memberAccess = (MemberAccessExpressionSyntax)memberAccess.Parent; } ExpressionSyntax newNode = SyntaxFactory.AwaitExpression(SyntaxFactory.Token(SyntaxFactory.TriviaList(), SyntaxKind.AwaitKeyword, SyntaxFactory.ParseTrailingTrivia(" ")), memberAccess.Expression.WithoutTrivia()); // insert parenthesis when commited with dot // and copy trivia (whitespaces) from the original node if (commitKey == '.') { newNode = SyntaxFactory.ParenthesizedExpression(newNode); } return(model.SyntaxTree.GetRoot().ReplaceNode(memberAccess, newNode)); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { int cancellationTokenPos; if (!IsInvocationExpressionRewritable(node, out cancellationTokenPos)) { return(node); } var rewritten = RewriteInvocationExpression(node, cancellationTokenPos); if (!(node.Parent is StatementSyntax)) { rewritten = SyntaxFactory.ParenthesizedExpression(rewritten); } return(SyntaxFactory.AwaitExpression(rewritten)); }
private static CSharpSyntaxNode UpdateStatementsForAsyncMethod(CSharpSyntaxNode body, SemanticModel semanticModel, bool hasResultValue) { var blockBody = body as BlockSyntax; if (blockBody != null) { return(UpdateStatementsForAsyncMethod(blockBody, semanticModel, hasResultValue)); } var expressionBody = body as ExpressionSyntax; if (expressionBody != null) { return(SyntaxFactory.AwaitExpression(expressionBody).TrySimplify(expressionBody, semanticModel)); } throw new NotSupportedException(); }