private static Task <Document> RefactorAsync(Document document, AnonymousMethodExpressionSyntax anonymousMethod, SemanticModel semanticModel, CancellationToken cancellationToken)
{
AnonymousMethodExpressionSyntax newNode = AwaitRemover.Visit(anonymousMethod, semanticModel, cancellationToken);
newNode = newNode.WithAsyncKeyword(GetMissingAsyncKeyword(anonymousMethod.AsyncKeyword));
return(document.ReplaceNodeAsync(anonymousMethod, newNode, cancellationToken));
}
private static Task <Document> RefactorAsync(Document document, ParenthesizedLambdaExpressionSyntax lambda, SemanticModel semanticModel, CancellationToken cancellationToken)
{
ParenthesizedLambdaExpressionSyntax newNode = AwaitRemover.Visit(lambda, semanticModel, cancellationToken);
newNode = newNode.WithAsyncKeyword(GetMissingAsyncKeyword(lambda.AsyncKeyword));
return(document.ReplaceNodeAsync(lambda, newNode, cancellationToken));
}
private static Task <Document> RefactorAsync(Document document, LocalFunctionStatementSyntax localFunction, SemanticModel semanticModel, CancellationToken cancellationToken)
{
LocalFunctionStatementSyntax newNode = AwaitRemover.Visit(localFunction, semanticModel, cancellationToken);
newNode = newNode.RemoveModifier(SyntaxKind.AsyncKeyword);
return(document.ReplaceNodeAsync(localFunction, newNode, cancellationToken));
}
private static Task <Document> RefactorAsync(Document document, MethodDeclarationSyntax methodDeclaration, SemanticModel semanticModel, CancellationToken cancellationToken)
{
MethodDeclarationSyntax newNode = AwaitRemover.Visit(methodDeclaration, semanticModel, cancellationToken);
newNode = newNode.RemoveModifier(SyntaxKind.AsyncKeyword);
return(document.ReplaceNodeAsync(methodDeclaration, newNode, cancellationToken));
}
public static TNode Visit <TNode>(TNode node, SemanticModel semanticModel, CancellationToken cancellationToken) where TNode : SyntaxNode
{
var remover = new AwaitRemover(semanticModel, cancellationToken);
return((TNode)remover.Visit(node));
}
public static async Task <Document> RefactorAsync(
Document document,
SyntaxToken asyncKeyword,
CancellationToken cancellationToken = default)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxNode node = asyncKeyword.Parent;
var remover = new AwaitRemover(semanticModel, cancellationToken);
SyntaxNode newNode = GetNewNode();
return(await document.ReplaceNodeAsync(node, newNode, cancellationToken).ConfigureAwait(false));
SyntaxNode GetNewNode()
{
switch (node)
{
case MethodDeclarationSyntax methodDeclaration:
{
return(remover
.VisitMethodDeclaration(methodDeclaration)
.RemoveModifier(SyntaxKind.AsyncKeyword));
}
case LocalFunctionStatementSyntax localFunction:
{
BlockSyntax body = localFunction.Body;
if (body != null)
{
localFunction = localFunction.WithBody((BlockSyntax)remover.VisitBlock(body));
}
else
{
ArrowExpressionClauseSyntax expressionBody = localFunction.ExpressionBody;
if (expressionBody != null)
{
localFunction = localFunction.WithExpressionBody((ArrowExpressionClauseSyntax)remover.VisitArrowExpressionClause(expressionBody));
}
}
return(localFunction.RemoveModifier(SyntaxKind.AsyncKeyword));
}
case SimpleLambdaExpressionSyntax lambda:
{
return(lambda
.WithBody((CSharpSyntaxNode)remover.Visit(lambda.Body))
.WithAsyncKeyword(GetMissingAsyncKeyword(lambda.AsyncKeyword)));
}
case ParenthesizedLambdaExpressionSyntax lambda:
{
return(lambda
.WithBody((CSharpSyntaxNode)remover.Visit(lambda.Body))
.WithAsyncKeyword(GetMissingAsyncKeyword(lambda.AsyncKeyword)));
}
case AnonymousMethodExpressionSyntax anonymousMethod:
{
return(anonymousMethod
.WithBody((CSharpSyntaxNode)remover.Visit(anonymousMethod.Body))
.WithAsyncKeyword(GetMissingAsyncKeyword(anonymousMethod.AsyncKeyword)));
}
default:
{
throw new InvalidOperationException();
}
}
}
}
