Add awaits and identifiers to SyncGenerator (#872)

Author: j3parker

src/D2L.CodeStyle.Analyzers/Async/Generator/AsyncToSyncMethodTransformer.cs

@@ -1,4 +1,5 @@
-using Microsoft.CodeAnalysis;
+using D2L.CodeStyle.Analyzers.Extensions;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
@@ -53,8 +54,12 @@ private static SyntaxTokenList RemoveAsyncModifier( SyntaxTokenList modifiers )
 			static token => token.IsKind( SyntaxKind.AsyncKeyword ) ? null : token
 		);
 
-	private SyntaxToken RemoveAsyncSuffix( SyntaxToken ident ) {
-		if( !ident.ValueText.EndsWith( "Async", StringComparison.Ordinal ) || ident.ValueText == "Async" ) {
+	private SyntaxToken RemoveAsyncSuffix( SyntaxToken ident, bool optional = false ) {
+		if( !ident.ValueText.EndsWith( "Async", StringComparison.Ordinal ) || ident.ValueText == "Async") {
+			if( optional ) {
+				return ident;
+			}
+
 			ReportDiagnostic(
 				Diagnostics.ExpectedAsyncSuffix,
 				ident.GetLocation(),
@@ -122,8 +127,7 @@ private StatementSyntax Transform( StatementSyntax stmt )
 
 			EmptyStatementSyntax => stmt,
 
-			ExpressionStatementSyntax exprStmt => exprStmt
-				.WithExpression( Transform( exprStmt.Expression) ),
+			ExpressionStatementSyntax exprStmt => Transform( exprStmt ),
 
 			GotoStatementSyntax => stmt,
 
@@ -154,11 +158,14 @@ private ExpressionSyntax Transform( ExpressionSyntax expr )
 				.WithLeft( Transform( asgnExpr.Left ) )
 				.WithRight( Transform( asgnExpr.Right ) ),
 
+			AwaitExpressionSyntax awaitExpr =>
+				// Extract the inner expression, removing the "await"
+				Transform( awaitExpr.Expression ).ConcatLeadingTriviaFrom( awaitExpr ),
+
 			BinaryExpressionSyntax binExpr => binExpr
 				.WithLeft( Transform( binExpr.Left ) )
 				.WithRight( Transform( binExpr.Right ) ),
 
-
 			ConditionalExpressionSyntax condExpr => condExpr
 				.WithCondition( Transform( condExpr.Condition ) )
 				.WithWhenTrue( Transform( condExpr.WhenTrue ) )
@@ -170,6 +177,9 @@ private ExpressionSyntax Transform( ExpressionSyntax expr )
 				.WithExpression( Transform( eaExpr.Expression ) )
 				.WithArgumentList( TransformAll( eaExpr.ArgumentList, Transform ) ),
 
+			IdentifierNameSyntax identExpr => identExpr
+				.WithIdentifier( RemoveAsyncSuffix( identExpr.Identifier, optional: true ) ),
+
 			LiteralExpressionSyntax => expr,
 
 			ObjectCreationExpressionSyntax newExpr => newExpr
@@ -193,6 +203,18 @@ private ExpressionSyntax Transform( ExpressionSyntax expr )
 			_ => UnhandledSyntax( expr )
 		};
 
+	private StatementSyntax Transform( ExpressionStatementSyntax exprStmt ) {
+		var result = Transform( exprStmt.Expression );
+
+		// "await foo;" is redundant in sync land, so turn it into an
+		// EmptyStatementSyntax (just a bare ";".)
+		if( exprStmt.Expression is AwaitExpressionSyntax && result is IdentifierNameSyntax ) {
+			return SyntaxFactory.EmptyStatement().WithTriviaFrom( exprStmt );
+		}
+
+		return exprStmt.WithExpression( result );
+	}
+
 	private ElseClauseSyntax Transform( ElseClauseSyntax clause )
 		=> clause.WithStatement( Transform( clause.Statement ) );
 

src/D2L.CodeStyle.Analyzers/Extensions/Microsoft.CodeAnalysis.cs

@@ -206,5 +206,13 @@ public static ImmutableArray<INamedTypeSymbol> GetAllContainingTypes( this ISymb
 			builder.Reverse();
 			return builder.ToImmutable();
 		}
+
+		public static TSyntax ConcatLeadingTriviaFrom<TSyntax>(
+			this TSyntax syntax,
+			SyntaxNode other
+		) where TSyntax : SyntaxNode =>
+			syntax.WithLeadingTrivia(
+				other.GetLeadingTrivia().Concat( syntax.GetLeadingTrivia() )
+			);
 	}
 }

tests/D2L.CodeStyle.Analyzers.Test/Async/Generator/AsyncToSyncMethodTransformerTests.cs

@@ -39,59 +39,83 @@ public void BasicTaskArrow() {
 	}
 
 	[Test]
-	public void Silly() {
+	public void Await() {
+		var actual = Transform( @"[GenerateSync] async Task<int> HelloAsync() { return await q; }" );
+
+		Assert.IsTrue( actual.Success );
+		Assert.IsEmpty( actual.Diagnostics );
+		Assert.AreEqual( "[Blocking] int Hello() { return q; }", actual.Value.ToFullString() );
+	}
+
+	[Test]
+	public void AwaitIdentifier() {
+		var actual = Transform( @"[GenerateSync] async Task HelloAsync() { await q; }" );
+
+		Assert.IsTrue( actual.Success );
+		Assert.IsEmpty( actual.Diagnostics );
+		Assert.AreEqual( "[Blocking] void Hello() { ; }", actual.Value.ToFullString() );
+	}
+
+	[Test]
+		public void Silly() {
 		var actual = Transform( @"[GenerateSync]
-async Task<int> HelloAsync( int[] q ) {
-	if( 6 == (7 - 1)*2 ) {
-		return sizeof( ""hello"" );
-	} else if( this[0]++ == ++this[1] ) {
-		throw new NotImplementedException( ""foo"" );
-	} else return 8;
+async Task<int> HelloAsync() {
+	if( (await q) == (7 - (await q))*2 ) {
+		return sizeof( int );
+	} else if( this[0]++ == ++this[await q] ) {
+		throw new NotImplementedException( await q );
+		throw new X{ Y = await q };
+	} else return await q;
 
 	{
 		{
-			{ ;;; }
+			{ ;;; q; }
 		}
 	}
 
 	goto lol;
 
 	do {
-		while( true ) {
+		while( await q ) {
 			continue;
 			lol: break;
 		}
-	} while( false );
+	} while( await q );
+
+	this = await q;
 
-	this = this;
+	await q;
 
 	return 123;
 }" );
 
 		var expected = @"[Blocking]
-int Hello( int[] q ) {
-	if( 6 == (7 - 1)*2 ) {
-		return sizeof( ""hello"" );
-	} else if( this[0]++ == ++this[1] ) {
-		throw new NotImplementedException( ""foo"" );
-	} else return 8;
+int Hello() {
+	if( (q) == (7 - (q))*2 ) {
+		return sizeof( int );
+	} else if( this[0]++ == ++this[q] ) {
+		throw new NotImplementedException( q );
+		throw new X{ Y = q };
+	} else return q;
 
 	{
 		{
-			{ ;;; }
+			{ ;;; q; }
 		}
 	}
 
 	goto lol;
 
 	do {
-		while( true ) {
+		while( q ) {
 			continue;
 			lol: break;
 		}
-	} while( false );
+	} while( q );
+
+	this = q;
 
-	this = this;
+	;
 
 	return 123;
 }";