Add a bunch of basic syntax to SyncTransformer (#871)

All of this stuff is straight-forward and doesn't need special handling,
just recursion.

Co-authored-by: Owen Smith <[email protected]>

Author: j3parker

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

@@ -110,22 +110,101 @@ private BlockSyntax Transform( BlockSyntax block )
 
 	private StatementSyntax Transform( StatementSyntax stmt )
 		=> stmt switch {
+			BlockSyntax blockStmt => Transform( blockStmt ),
+
+			BreakStatementSyntax => stmt,
+
+			ContinueStatementSyntax => stmt,
+
+			DoStatementSyntax doStmt => doStmt
+				.WithStatement( Transform( doStmt.Statement ) )
+				.WithCondition( Transform( doStmt.Condition ) ),
+
+			EmptyStatementSyntax => stmt,
+
 			ExpressionStatementSyntax exprStmt => exprStmt
 				.WithExpression( Transform( exprStmt.Expression) ),
 
+			GotoStatementSyntax => stmt,
+
+			IfStatementSyntax ifStmt => ifStmt
+				.WithCondition( Transform( ifStmt.Condition ) )
+				.WithStatement( Transform( ifStmt.Statement ) )
+				.WithElse( MaybeTransform( ifStmt.Else, Transform ) ),
+
+			LabeledStatementSyntax labeledStmt => labeledStmt
+				.WithStatement( Transform( labeledStmt.Statement ) ),
+
+			ThrowStatementSyntax throwStmt => throwStmt
+				.WithExpression( MaybeTransform( throwStmt.Expression, Transform ) ),
+
 			ReturnStatementSyntax returnStmt => returnStmt
 				.WithExpression( MaybeTransform( returnStmt.Expression, Transform ) ),
 
+			WhileStatementSyntax whileStmt => whileStmt
+				.WithCondition( Transform( whileStmt.Condition ) )
+				.WithStatement( Transform( whileStmt.Statement ) ),
+
 			_ => UnhandledSyntax( stmt )
 		};
 
 	private ExpressionSyntax Transform( ExpressionSyntax expr )
 		=> expr switch {
+			AssignmentExpressionSyntax asgnExpr => asgnExpr
+				.WithLeft( Transform( asgnExpr.Left ) )
+				.WithRight( Transform( asgnExpr.Right ) ),
+
+			BinaryExpressionSyntax binExpr => binExpr
+				.WithLeft( Transform( binExpr.Left ) )
+				.WithRight( Transform( binExpr.Right ) ),
+
+
+			ConditionalExpressionSyntax condExpr => condExpr
+				.WithCondition( Transform( condExpr.Condition ) )
+				.WithWhenTrue( Transform( condExpr.WhenTrue ) )
+				.WithWhenFalse( Transform( condExpr.WhenFalse ) ),
+
+			DefaultExpressionSyntax => expr,
+
+			ElementAccessExpressionSyntax eaExpr => eaExpr
+				.WithExpression( Transform( eaExpr.Expression ) )
+				.WithArgumentList( TransformAll( eaExpr.ArgumentList, Transform ) ),
+
 			LiteralExpressionSyntax => expr,
 
+			ObjectCreationExpressionSyntax newExpr => newExpr
+				.WithArgumentList( MaybeTransform( newExpr.ArgumentList, Transform ) )
+				.WithInitializer( MaybeTransform( newExpr.Initializer, Transform ) ),
+
+			ParenthesizedExpressionSyntax pExpr => pExpr
+				.WithExpression( Transform( pExpr.Expression ) ),
+
+			PostfixUnaryExpressionSyntax postfixExpr => postfixExpr
+				.WithOperand( Transform( postfixExpr.Operand ) ),
+
+			PrefixUnaryExpressionSyntax prefixExpr => prefixExpr
+				.WithOperand( Transform( prefixExpr.Operand ) ),
+
+			SizeOfExpressionSyntax => expr,
+
+			ThisExpressionSyntax => expr,
+
+
 			_ => UnhandledSyntax( expr )
 		};
 
+	private ElseClauseSyntax Transform( ElseClauseSyntax clause )
+		=> clause.WithStatement( Transform( clause.Statement ) );
+
+	private ArgumentListSyntax Transform( ArgumentListSyntax argList )
+		=> TransformAll( argList, Transform );
+
+	private ArgumentSyntax Transform( ArgumentSyntax argument )
+		=> argument.WithExpression( Transform( argument.Expression ) );
+
+	private InitializerExpressionSyntax Transform( InitializerExpressionSyntax initializer )
+		=> initializer.WithExpressions( TransformAll( initializer.Expressions, Transform ) );
+
 	private bool IsGenerateSyncAttribute( AttributeSyntax attribute ) {
 		var attributeConstructorSymbol = Model.GetSymbolInfo( attribute, Token ).Symbol as IMethodSymbol;
 

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

@@ -97,6 +97,12 @@ protected static SeparatedSyntaxList<TItemOut> TransformAll<TItemIn, TItemOut>(
 	  where TItemOut : SyntaxNode
 		=> SyntaxFactory.SeparatedList( TransformAllCore( input, transformer ) );
 
+	protected static TArgList TransformAll<TArgList>(
+		TArgList input,
+		Func<ArgumentSyntax, ArgumentSyntax?> transformer
+	) where TArgList : BaseArgumentListSyntax
+		=> (TArgList)input.WithArguments( TransformAll( input.Arguments, transformer ) );
+
 	/// <summary>
 	/// Transform every element of a SyntaxTokenList and filter out default tokens.
 	/// </summary>

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

@@ -38,6 +38,70 @@ public void BasicTaskArrow() {
 		Assert.AreEqual( "[Blocking] int Hello() => 4;", 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;
+
+	{
+		{
+			{ ;;; }
+		}
+	}
+
+	goto lol;
+
+	do {
+		while( true ) {
+			continue;
+			lol: break;
+		}
+	} while( false );
+
+	this = this;
+
+	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;
+
+	{
+		{
+			{ ;;; }
+		}
+	}
+
+	goto lol;
+
+	do {
+		while( true ) {
+			continue;
+			lol: break;
+		}
+	} while( false );
+
+	this = this;
+
+	return 123;
+}";
+
+		Assert.IsTrue( actual.Success );
+		Assert.IsEmpty( actual.Diagnostics );
+		Assert.AreEqual( expected, actual.Value.ToFullString() );
+	}
+
+
 	[Test]
 	public void GenerateSyncOnNonAsyncThingFails() {
 		var actual = Transform( @"[GenerateSync] void Hello() {}" );