How do you replace one syntax token with multiple ones? - roslyn

Question

I've written an analyzer to force a library to use GetAwaiter().GetResult() instead of blocking a thread with .Result / .Wait()
After several hours and attempts to find a way to generate a syntaxtree which covers all my test cases i attempted to use the ReplaceToken method.
SyntaxNodeExtensions.cs
public static TRoot ReplaceToken<TRoot>(this TRoot root, SyntaxToken tokenInList, IEnumerable<SyntaxToken> newTokens) where TRoot : SyntaxNode
{
return (TRoot) root.ReplaceTokenInListCore(tokenInList, newTokens);
}
seemed like the perfect method - however i never got it working using this method.
I ended up doing it this way (which to me, seems rather lazy):
My working codefix
private async Task<Document> ReplaceWithGetAwaiterGetResultAsync(Document document, IdentifierNameSyntax declaration, CancellationToken cancellationToken)
{
var source = await document.GetTextAsync(cancellationToken).ConfigureAwait(false);
if(declaration.Identifier.ValueText == "Result")
return document.WithText(source.Replace(declaration.Span, "GetAwaiter().GetResult()"));
if(declaration.Identifier.ValueText == "Wait")
return document.WithText(source.Replace(new TextSpan(declaration.SpanStart, 6), "GetAwaiter().GetResult()"));
return document;
}
Does anyone know a better way of how i could have turned something like
Task.Run(() => 42).Result
into
Task.Run(() => 42).GetAwaiter.GetResult()
?
E.g. a version of this:
var tokens = SyntaxFactory.ParseTokens("GetAwaiter().GetResult()");
var root = await document.GetSyntaxRootAsync(cancellationToken);
var replaced = root.ReplaceToken(declaration.Identifier, tokens);
return document.WithSyntaxRoot(replaced.WithAdditionalAnnotations());
which does not crash.

Answer 1

The problem you faced when implementing your solution was that you tried to replace tokens. The access of the Result Property is however not a Token but a SyntaxNode.
The structure of your code consists of a MemberAccessExpression (Task.Run().Result) containing a MethodInvocationExpression (Task.Run()).
What you're trying to achieve is to remove the MemberAccessExpression, create a new MethodInvocationExpression (invocating GetAwaiter()) and insert the original InvocationExpression into your new Expression in order to call GetAwaiter() on the original expression.
Then you need to create another Incovation Expression to call GetResult().
To do this you need to create a new node like this and replace the old node using the SyntaxRoot:
private async Task<Document> ReplaceWithAwaiter(Document document,
IdentifierNameSyntax nameSyntax, CancellationToken cancellationToken)
{
var memberAccess = nameSyntax.Ancestors().OfType<MemberAccessExpressionSyntax>()
.First();
// Create .GetAwaiter()
var invocationOfAwaiter = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
memberAccess.Expression, SyntaxFactory.IdentifierName("GetAwaiter")));
// Create .GetResult()
var invocationOfGetResult = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
invocationOfAwaiter, SyntaxFactory.IdentifierName("GetResult")));
// Replace .Result by .GetAwaiter().GetResult()
var syntaxRoot = await document.GetSyntaxRootAsync();
syntaxRoot = syntaxRoot.ReplaceNode(memberAccess, invocationOfGetResult);
return document.WithSyntaxRoot(syntaxRoot);
}
For .Wait() the code is a bit different, but the same principle applies. In this case you want to replace an InvocationExpression instead of a MemberAccessExpression however.
private async Task<Document> ReplaceWithAwaiterForWait(Document document,
IdentifierNameSyntax nameSyntax, CancellationToken cancellationToken)
{
// Get the Invocation Task.Run().Wait()
var invocationOfWait = nameSyntax.Ancestors().OfType<InvocationExpressionSyntax>()
.First();
// Get the Access for Task.Run().Wait
var memberAccessOfWait = (MemberAccessExpressionSyntax)invocationOfWait.Expression;
// Get the Invocation Task.Run()
var invocationOfTaskRun = memberAccessOfWait.Expression;
// Create new Expressions
var invocationOfAwaiter = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
invocationOfTaskRun, SyntaxFactory.IdentifierName("GetAwaiter")));
var invocationOfGetResult = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
invocationOfAwaiter, SyntaxFactory.IdentifierName("GetResult")));
var syntaxRoot = await document.GetSyntaxRootAsync();
// Replace the old expression
syntaxRoot = syntaxRoot.ReplaceNode(invocationOfWait, invocationOfGetResult);
return document.WithSyntaxRoot(syntaxRoot);
}
If you don't wont to work with the generation of individual nodes you could also just use SyntaxFactory.ParseExpression() to generate a new expression and replace the old one:
private async Task<Document> ReplaceWithAwaiterWithParse(Document document,
IdentifierNameSyntax nameSyntax, CancellationToken cancellationToken)
{
var invocationOfWait = nameSyntax.Ancestors().OfType<InvocationExpressionSyntax>()
.First();
var memberAccessOfWait = (MemberAccessExpressionSyntax)invocationOfWait.Expression;
var invocationOfBoth = SyntaxFactory.ParseExpression(
memberAccessOfWait.Expression.ToFullString()
+ ".GetAwaiter().GetResult()");
var syntaxRoot = await document.GetSyntaxRootAsync();
syntaxRoot = syntaxRoot.ReplaceNode(invocationOfWait, invocationOfBoth);
return document.WithSyntaxRoot(syntaxRoot);
}
While this solution is a little shorter and more concise you would not be working on a string instead of the SyntaxTree which could create all kinds of issues. Furthermore the performance is a bit worse than using the SyntaxFactory to create individual objects. However you do not have to create every part of the invocation yourself.