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