private async Task <Solution> AddConfigureAwaitAsync(Document document, AwaitExpressionSyntax awaitSyntax, CancellationToken cancellationToken)
{
// Add .ConfigureAwait(false) to the operand of await
var originalAwaitedExpression = awaitSyntax.Expression;
var replacementAwaitedExpression =
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
originalAwaitedExpression,
SyntaxFactory.IdentifierName("ConfigureAwait")))
.WithArgumentList(
SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)))));
// Replace the original operand with the new one
var replacementAwaitSyntax = awaitSyntax.WithExpression(replacementAwaitedExpression);
// Replace the await in the syntax tree
var root = await document.GetSyntaxRootAsync(cancellationToken);
var updatedRoot = root.ReplaceNode(awaitSyntax, replacementAwaitSyntax);
// Replace the syntax tree in the document
var originalSolution = document.Project.Solution;
var newSolution = originalSolution.WithDocumentSyntaxRoot(document.Id, updatedRoot);
return(newSolution);
}
private Task <Document> AddConfigureAwaitFalse(
CodeFixContext context,
SyntaxNode root,
AwaitExpressionSyntax awaitExpression)
{
var invocation = (InvocationExpressionSyntax)awaitExpression.Expression;
var syntaxGenerator = SyntaxGenerator.GetGenerator(context.Document);
var memberAccessExpression = syntaxGenerator.MemberAccessExpression(invocation.WithTrailingTrivia(), syntaxGenerator.IdentifierName("ConfigureAwait"));
var argument = syntaxGenerator.Argument(syntaxGenerator.FalseLiteralExpression());
var newInvocation = syntaxGenerator.InvocationExpression(memberAccessExpression, argument) as InvocationExpressionSyntax;
var newAwaitExpression = awaitExpression.WithExpression(newInvocation);
return(context.GetDocumentWithReplacedNode(awaitExpression, newAwaitExpression, root));
}
private Solution AddConfigureAwaitFalse(Document document, SyntaxNode root, AwaitExpressionSyntax awaitExpression, CancellationToken c)
{
var configureAwait = SyntaxFactory.IdentifierName(nameof(Task.ConfigureAwait));
var dotToken = SyntaxFactory.Token(SyntaxKind.DotToken);
var simpleMemberAccessExpr = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, awaitExpression.Expression, dotToken, configureAwait);
var argument = SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression));
var argumentList = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(new[] { argument }));
var invocationExpr = SyntaxFactory.InvocationExpression(simpleMemberAccessExpr, argumentList);
var newAwaitExpr = awaitExpression.WithExpression(invocationExpr);
return(document
.WithSyntaxRoot(root.ReplaceNode(awaitExpression, newAwaitExpr))
.Project
.Solution);
}
private async Task <Document> InsertConfigureAwaitAsync(Document document, AwaitExpressionSyntax oldAwaitExpr,
bool arg, CancellationToken token)
{
var configureAwait = IdentifierName(nameof(Task.ConfigureAwait));
var oldOperand = oldAwaitExpr.Expression;
var newOperand =
InvocationExpression(MemberAccessExpression(SimpleMemberAccessExpression, oldOperand, configureAwait),
ArgumentList(Token(OpenParenToken),
SeparatedList(new[]
{ Argument(LiteralExpression(arg ? TrueLiteralExpression : FalseLiteralExpression)) }),
Token(CloseParenToken)));
var newAwaitExpr = oldAwaitExpr.WithExpression(newOperand) /*.WithOperand(newOperand)*/;
var oldRoot = await document.GetSyntaxRootAsync(token).ConfigureAwait(false);
var newRoot = oldRoot.ReplaceNode(oldAwaitExpr, newAwaitExpr);
return(document.WithSyntaxRoot(newRoot));
}
private async Task <Document> AddConfigureAwait(Document document, AwaitExpressionSyntax awaitExpression, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken);
var newExpr = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
awaitExpression.Expression,
IdentifierName("ConfigureAwait")),
ArgumentList(
SingletonSeparatedList(
Argument(LiteralExpression(SyntaxKind.FalseLiteralExpression))))
);
var newAwaitExpression = awaitExpression.WithExpression(newExpr);
var newRoot = root.ReplaceNode(awaitExpression, newAwaitExpression);
return(document.WithSyntaxRoot(newRoot));
}
