Simplify

Author: CyrusNajmabadi

src/Workspaces/CSharp/Portable/CodeGeneration/CSharpSyntaxGenerator.cs

@@ -3234,10 +3234,10 @@ internal override bool IsRegularOrDocComment(SyntaxTrivia trivia)
     #region Statements and Expressions
 
     public override SyntaxNode AddEventHandler(SyntaxNode @event, SyntaxNode handler)
-        => SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)Parenthesize(handler));
+        => SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)ParenthesizeNonSimple(handler));
 
     public override SyntaxNode RemoveEventHandler(SyntaxNode @event, SyntaxNode handler)
-        => SyntaxFactory.AssignmentExpression(SyntaxKind.SubtractAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)Parenthesize(handler));
+        => SyntaxFactory.AssignmentExpression(SyntaxKind.SubtractAssignmentExpression, (ExpressionSyntax)@event, (ExpressionSyntax)ParenthesizeNonSimple(handler));
 
     public override SyntaxNode AwaitExpression(SyntaxNode expression)
         => SyntaxFactory.AwaitExpression((ExpressionSyntax)expression);
@@ -3363,20 +3363,20 @@ public override SyntaxNode ElementAccessExpression(SyntaxNode expression, IEnume
     internal override SyntaxToken NumericLiteralToken(string text, ulong value)
         => SyntaxFactory.Literal(text, value);
 
-    private static SyntaxNode Parenthesize(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
-        => CSharpSyntaxGeneratorInternal.Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation, parenthesizeIdentifiers);
+    private static SyntaxNode ParenthesizeNonSimple(SyntaxNode expression)
+        => expression is IdentifierNameSyntax ? expression : CSharpSyntaxGeneratorInternal.Parenthesize(expression);
 
     public override SyntaxNode IsTypeExpression(SyntaxNode expression, SyntaxNode type)
-        => SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, (ExpressionSyntax)Parenthesize(expression), (TypeSyntax)type);
+        => SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression), (TypeSyntax)type);
 
     public override SyntaxNode TypeOfExpression(SyntaxNode type)
         => SyntaxFactory.TypeOfExpression((TypeSyntax)type);
 
     public override SyntaxNode TryCastExpression(SyntaxNode expression, SyntaxNode type)
-        => SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, (ExpressionSyntax)Parenthesize(expression), (TypeSyntax)type);
+        => SyntaxFactory.BinaryExpression(SyntaxKind.AsExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression), (TypeSyntax)type);
 
     public override SyntaxNode AssignmentStatement(SyntaxNode left, SyntaxNode right)
-        => SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)left, (ExpressionSyntax)Parenthesize(right));
+        => SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)left, (ExpressionSyntax)ParenthesizeNonSimple(right));
 
     private static SyntaxNode CreateBinaryExpression(SyntaxKind syntaxKind, SyntaxNode left, SyntaxNode right)
         => CSharpSyntaxGeneratorInternal.CreateBinaryExpression(syntaxKind, left, right);
@@ -3406,7 +3406,7 @@ public override SyntaxNode GreaterThanOrEqualExpression(SyntaxNode left, SyntaxN
         => CreateBinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, left, right);
 
     public override SyntaxNode NegateExpression(SyntaxNode expression)
-        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, (ExpressionSyntax)Parenthesize(expression));
+        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.UnaryMinusExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression));
 
     public override SyntaxNode AddExpression(SyntaxNode left, SyntaxNode right)
         => CreateBinaryExpression(SyntaxKind.AddExpression, left, right);
@@ -3427,7 +3427,7 @@ public override SyntaxNode BitwiseAndExpression(SyntaxNode left, SyntaxNode righ
         => CreateBinaryExpression(SyntaxKind.BitwiseAndExpression, left, right);
 
     public override SyntaxNode BitwiseNotExpression(SyntaxNode operand)
-        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, (ExpressionSyntax)Parenthesize(operand));
+        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.BitwiseNotExpression, (ExpressionSyntax)ParenthesizeNonSimple(operand));
 
     public override SyntaxNode LogicalAndExpression(SyntaxNode left, SyntaxNode right)
         => CreateBinaryExpression(SyntaxKind.LogicalAndExpression, left, right);
@@ -3436,10 +3436,10 @@ public override SyntaxNode LogicalOrExpression(SyntaxNode left, SyntaxNode right
         => CreateBinaryExpression(SyntaxKind.LogicalOrExpression, left, right);
 
     public override SyntaxNode LogicalNotExpression(SyntaxNode expression)
-        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, (ExpressionSyntax)Parenthesize(expression, parenthesizeIdentifiers: false));
+        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, (ExpressionSyntax)ParenthesizeNonSimple(expression));
 
     public override SyntaxNode ConditionalExpression(SyntaxNode condition, SyntaxNode whenTrue, SyntaxNode whenFalse)
-        => SyntaxFactory.ConditionalExpression((ExpressionSyntax)Parenthesize(condition), (ExpressionSyntax)Parenthesize(whenTrue), (ExpressionSyntax)Parenthesize(whenFalse));
+        => SyntaxFactory.ConditionalExpression((ExpressionSyntax)ParenthesizeNonSimple(condition), (ExpressionSyntax)ParenthesizeNonSimple(whenTrue), (ExpressionSyntax)ParenthesizeNonSimple(whenFalse));
 
     public override SyntaxNode CoalesceExpression(SyntaxNode left, SyntaxNode right)
         => CreateBinaryExpression(SyntaxKind.CoalesceExpression, left, right);

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ExpressionSyntaxExtensions.cs

@@ -16,7 +16,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Extensions;
 internal static partial class ExpressionSyntaxExtensions
 {
     public static ExpressionSyntax Parenthesize(
-        this ExpressionSyntax expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
+        this ExpressionSyntax expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true)
     {
         // a 'ref' expression should never be parenthesized.  It fundamentally breaks the code.
         // This is because, from the language's perspective there is no such thing as a ref
@@ -42,7 +42,7 @@ public static ExpressionSyntax Parenthesize(
         if (expression.IsKind(SyntaxKind.ThrowExpression))
             return expression;
 
-        if (!parenthesizeIdentifiers && expression is IdentifierNameSyntax)
+        if (expression is IdentifierNameSyntax)
             return expression;
 
         var result = ParenthesizeWorker(expression, includeElasticTrivia);

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/LanguageServices/CSharpSyntaxGeneratorInternal.cs

@@ -83,13 +83,13 @@ public override SyntaxNode MemberBindingExpression(SyntaxNode name)
     public override SyntaxNode RefExpression(SyntaxNode expression)
         => SyntaxFactory.RefExpression((ExpressionSyntax)expression);
 
-    public override SyntaxNode AddParentheses(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
-        => Parenthesize(expressionOrPattern, includeElasticTrivia, addSimplifierAnnotation, parenthesizeIdentifiers);
+    public override SyntaxNode AddParentheses(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true)
+        => Parenthesize(expressionOrPattern, includeElasticTrivia, addSimplifierAnnotation);
 
-    internal static SyntaxNode Parenthesize(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
+    internal static SyntaxNode Parenthesize(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true)
         => expressionOrPattern switch
         {
-            ExpressionSyntax expression => expression.Parenthesize(includeElasticTrivia, addSimplifierAnnotation, parenthesizeIdentifiers),
+            ExpressionSyntax expression => expression.Parenthesize(includeElasticTrivia, addSimplifierAnnotation),
             PatternSyntax pattern => pattern.Parenthesize(includeElasticTrivia, addSimplifierAnnotation),
             var other => other,
         };

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/LanguageServices/SyntaxGeneratorInternalExtensions/SyntaxGeneratorInternal.cs

@@ -58,7 +58,7 @@ public SyntaxNode LocalDeclarationStatement(SyntaxToken name, SyntaxNode initial
     /// <summary>
     /// Wraps with parens.
     /// </summary>
-    public abstract SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true);
+    public abstract SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true);
 
     /// <summary>
     /// Creates a statement that can be used to yield a value from an iterator method.