Fixup

Author: CyrusNajmabadi

src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs

@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.LanguageService;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Shared.Extensions;
+using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
 
@@ -183,7 +184,25 @@ private async Task<Document> InvertIfDirectiveAsync(
             new TextChange(trueSpan, text.ToString(falseSpan)),
             new TextChange(falseSpan, text.ToString(trueSpan)));
 
-        return document.WithText(newText);
+        var updatedDocument = document.WithText(newText);
+        return updatedDocument;
+        //var updatedRoot = await updatedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+
+        //// SyntaxGenerator.Negate often adds parentheses around the expression.  However, because we are making text
+        //// changes, we lose the annotations to go and clean that up later.
+        //var updatedIfDirective = updatedRoot.FindNode(ifDirective.FullSpan, findInsideTrivia: true);
+        //if (updatedIfDirective != null)
+        //{
+        //    var syntaxFacts = generator.SyntaxFacts;
+        //    var updatedIfDirectiveWithAnnotations = updatedIfDirective.ReplaceNodes(
+        //        updatedIfDirective.DescendantNodes().Where(n => n.RawKind == syntaxFacts.SyntaxKinds.ParenthesizedExpression),
+        //        (_, current) => current.WithAdditionalAnnotations(Simplifier.Annotation));
+        //    updatedRoot = updatedRoot.ReplaceNode(
+        //        updatedIfDirective,
+        //        updatedIfDirectiveWithAnnotations);
+        //}
+
+        //return updatedDocument.WithSyntaxRoot(updatedRoot);
     }
 
     private static bool HasErrorDiagnostics(SyntaxNode node)

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

@@ -3363,8 +3363,8 @@ 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)
-        => CSharpSyntaxGeneratorInternal.Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation);
+    private static SyntaxNode Parenthesize(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
+        => CSharpSyntaxGeneratorInternal.Parenthesize(expression, includeElasticTrivia, addSimplifierAnnotation, parenthesizeIdentifiers);
 
     public override SyntaxNode IsTypeExpression(SyntaxNode expression, SyntaxNode type)
         => SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, (ExpressionSyntax)Parenthesize(expression), (TypeSyntax)type);
@@ -3436,7 +3436,7 @@ 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));
+        => SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, (ExpressionSyntax)Parenthesize(expression, parenthesizeIdentifiers: false));
 
     public override SyntaxNode ConditionalExpression(SyntaxNode condition, SyntaxNode whenTrue, SyntaxNode whenFalse)
         => SyntaxFactory.ConditionalExpression((ExpressionSyntax)Parenthesize(condition), (ExpressionSyntax)Parenthesize(whenTrue), (ExpressionSyntax)Parenthesize(whenFalse));

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)
+        this ExpressionSyntax expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = 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
@@ -28,9 +28,7 @@ public static ExpressionSyntax Parenthesize(
         // on a ref-expression node.  But this node isn't a true expression that be operated
         // on like with everything else.
         if (expression.IsKind(SyntaxKind.RefExpression))
-        {
             return expression;
-        }
 
         // Throw expressions are not permitted to be parenthesized:
         //
@@ -42,17 +40,18 @@ public static ExpressionSyntax Parenthesize(
         //
         // is not.
         if (expression.IsKind(SyntaxKind.ThrowExpression))
-        {
             return expression;
-        }
+
+        if (!parenthesizeIdentifiers && expression is IdentifierNameSyntax)
+            return expression;
 
         var result = ParenthesizeWorker(expression, includeElasticTrivia);
         return addSimplifierAnnotation
             ? result.WithAdditionalAnnotations(Simplifier.Annotation)
             : result;
     }
 
-    private static ExpressionSyntax ParenthesizeWorker(
+    private static ParenthesizedExpressionSyntax ParenthesizeWorker(
         this ExpressionSyntax expression, bool includeElasticTrivia)
     {
         var withoutTrivia = expression.WithoutTrivia();

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)
-        => Parenthesize(expressionOrPattern, includeElasticTrivia, addSimplifierAnnotation);
+    public override SyntaxNode AddParentheses(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
+        => Parenthesize(expressionOrPattern, includeElasticTrivia, addSimplifierAnnotation, parenthesizeIdentifiers);
 
-    internal static SyntaxNode Parenthesize(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true)
+    internal static SyntaxNode Parenthesize(SyntaxNode expressionOrPattern, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true)
         => expressionOrPattern switch
         {
-            ExpressionSyntax expression => expression.Parenthesize(includeElasticTrivia, addSimplifierAnnotation),
+            ExpressionSyntax expression => expression.Parenthesize(includeElasticTrivia, addSimplifierAnnotation, parenthesizeIdentifiers),
             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);
+    public abstract SyntaxNode AddParentheses(SyntaxNode expression, bool includeElasticTrivia = true, bool addSimplifierAnnotation = true, bool parenthesizeIdentifiers = true);
 
     /// <summary>
     /// Creates a statement that can be used to yield a value from an iterator method.

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/VisualBasic/LanguageServices/VisualBasicSyntaxGeneratorInternal.vb

@@ -97,7 +97,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeGeneration
             Return expression
         End Function
 
-        Public Overrides Function AddParentheses(expression As SyntaxNode, Optional includeElasticTrivia As Boolean = True, Optional addSimplifierAnnotation As Boolean = True) As SyntaxNode
+        Public Overrides Function AddParentheses(expression As SyntaxNode, Optional includeElasticTrivia As Boolean = True, Optional addSimplifierAnnotation As Boolean = True, Optional parenthesizeIdentifiers As Boolean = True) As SyntaxNode
             Return Parenthesize(expression, addSimplifierAnnotation)
         End Function