Improve SyntaxLogicalInverter to Handling Additional Cases and reduce Unnecessary Parentheses (#1086)

Co-authored-by: Josef Pihrt <josef@pihrt.net>

Author: jamesHargreaves12

ChangeLog.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Fixed
+
+- Improve inversion of logical expressions to handling additional cases ([#1086](https://github.com/josefpihrt/roslynator/pull/1086)).
+
 ## [4.3.0] - 2023-04-24
 
 ### Changed

src/CSharp.Workspaces/CSharp/SyntaxLogicalInverter.cs

@@ -67,15 +67,16 @@ public ExpressionSyntax LogicallyInvert(
         return newExpression.WithTriviaFrom(expression);
     }
 
-    private ParenthesizedExpressionSyntax LogicallyInvertAndParenthesize(
+    private ExpressionSyntax LogicallyInvertAndParenthesize(
         ExpressionSyntax expression,
         SemanticModel semanticModel,
         CancellationToken cancellationToken)
     {
         if (expression is null)
             return null;
 
-        return LogicallyInvertImpl(expression, semanticModel, cancellationToken).Parenthesize();
+        var inverted = LogicallyInvertImpl(expression, semanticModel, cancellationToken);
+        return inverted.IsKind(SyntaxKind.LogicalNotExpression, SyntaxKind.ParenthesizedExpression) ? inverted : inverted.Parenthesize();
     }
 
     private ExpressionSyntax LogicallyInvertImpl(
@@ -88,18 +89,22 @@ private ExpressionSyntax LogicallyInvertImpl(
 
         switch (expression.Kind())
         {
+            case SyntaxKind.IdentifierName:
             case SyntaxKind.SimpleMemberAccessExpression:
             case SyntaxKind.InvocationExpression:
             case SyntaxKind.ElementAccessExpression:
+            case SyntaxKind.CheckedExpression:
+            case SyntaxKind.UncheckedExpression:
+            case SyntaxKind.DefaultExpression:
+            case SyntaxKind.ConditionalAccessExpression:
+                {
+                    return DefaultInvert(expression, false);
+                }
             case SyntaxKind.PostIncrementExpression:
             case SyntaxKind.PostDecrementExpression:
             case SyntaxKind.ObjectCreationExpression:
             case SyntaxKind.AnonymousObjectCreationExpression:
             case SyntaxKind.TypeOfExpression:
-            case SyntaxKind.DefaultExpression:
-            case SyntaxKind.CheckedExpression:
-            case SyntaxKind.UncheckedExpression:
-            case SyntaxKind.IdentifierName:
                 {
                     return DefaultInvert(expression);
                 }
@@ -500,7 +505,7 @@ private ExpressionSyntax InvertIsPattern(IsPatternExpressionSyntax isPattern)
 
                 return isPattern.WithPattern(newConstantPattern);
             }
-            else if (constantExpression.IsKind(SyntaxKind.NullLiteralExpression))
+            else if (constantExpression.IsKind(SyntaxKind.NullLiteralExpression, SyntaxKind.NumericLiteralExpression, SyntaxKind.StringLiteralExpression))
             {
                 UnaryPatternSyntax notPattern = NotPattern(constantPattern.WithoutTrivia()).WithTriviaFrom(constantPattern);
 
@@ -515,14 +520,17 @@ private ExpressionSyntax InvertIsPattern(IsPatternExpressionSyntax isPattern)
         return DefaultInvert(isPattern);
     }
 
-    private static PrefixUnaryExpressionSyntax DefaultInvert(ExpressionSyntax expression)
+    private static PrefixUnaryExpressionSyntax DefaultInvert(ExpressionSyntax expression, bool needsParenthesize = true)
     {
         SyntaxDebug.Assert(expression.Kind() != SyntaxKind.ParenthesizedExpression, expression);
 
         SyntaxTriviaList leadingTrivia = expression.GetLeadingTrivia();
+        expression = expression.WithoutLeadingTrivia();
+        if (needsParenthesize)
+            expression = expression.Parenthesize();
 
         return LogicalNotExpression(
-            expression.WithoutLeadingTrivia().Parenthesize(),
+            expression,
             Token(leadingTrivia, SyntaxKind.ExclamationToken, SyntaxTriviaList.Empty));
     }
 }

src/Tests/CSharp.Workspaces.Tests/SyntaxLogicalInverterTests.cs

@@ -0,0 +1,70 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
+using Xunit;
+
+namespace Roslynator.CSharp.Workspaces.Tests;
+
+public class SyntaxLogicallyInvertTests
+{
+    private SyntaxLogicalInverter _inverter;
+
+    public SyntaxLogicallyInvertTests()
+    {
+        _inverter = SyntaxLogicalInverter.Default;
+    }
+
+    [Theory]
+    [InlineData(@"x", @"!x")]
+    [InlineData(@"!x", @"x")]
+    [InlineData(@"x is ""abc""", @"x is not ""abc""")]
+    [InlineData(@"x is 1", @"x is not 1")]
+    [InlineData(@"x is null", @"x is not null")]
+    [InlineData(@"x is true", @"x is false")]
+    [InlineData(@"true", @"false")]
+    [InlineData(@"false", @"true")]
+    [InlineData(@"x >= 3", @"x < 3")]
+    [InlineData(@"x > 3", @"x <= 3")]
+    [InlineData(@"x <= 3", @"x > 3")]
+    [InlineData(@"x < 3", @"x >= 3")]
+    [InlineData(@"x == y", @"x != y")]
+    [InlineData(@"x != y", @"x == y")]
+    [InlineData(@"(bool)x || (bool)y", @"!((bool)x) && !((bool)y)")]
+    [InlineData(@"(bool)x && (bool)y", @"!((bool)x) || !((bool)y)")]
+    [InlineData(@"x ?? true", @"x == false")]
+    [InlineData(@"x ?? false", @"x != true")]
+    [InlineData(@"(bool)x ? y : z", @"(bool)x ? !y : !z")]
+    [InlineData(@"x[0]", @"!x[0]")]
+    [InlineData(@"default(bool)", @"!default(bool)")]
+    [InlineData(@"checked(x + y)", @"!checked(x + y)")]
+    [InlineData(@"unchecked(x + y)", @"!unchecked(x + y)")]
+    [InlineData(@"(bool)x", @"!((bool)x)")]
+    [InlineData(@"x & y", @"!x | !y")]
+    [InlineData(@"x ^ y", @"!(x ^ y)")]
+    [InlineData(@"x | y", @"!x & !y")]
+    [InlineData(@"x = y", @"!(x = y)")]
+    [InlineData(@"await x", @"!(await x)")]
+    [InlineData(@"x ?? y", @"!(x ?? y)")]
+    [InlineData(@"x.a", @"!x.a")]
+    [InlineData(@"x.a()", @"!x.a()")]
+    [InlineData(@"x?.a", @"!x?.a")]
+    public async Task LogicallyInvert(string source, string expected)
+    {
+        var sourceCode = $"class C {{ void M(dynamic x, dynamic y, dynamic z){{ if({source})return;}} }}";
+        var workspace = new AdhocWorkspace();
+        var newProject = workspace.AddProject("TestProject", LanguageNames.CSharp);
+        var newDocument = workspace.AddDocument(newProject.Id, "TestDocument.cs", SourceText.From(sourceCode));
+        var syntaxTree = await newDocument.GetSyntaxTreeAsync();
+        var compilation = await newDocument.Project.GetCompilationAsync();
+        var semanticModel = compilation.GetSemanticModel(syntaxTree);
+
+        var expression = syntaxTree.GetRoot().DescendantNodes().OfType<IfStatementSyntax>().Single().Condition;
+
+        var result = _inverter.LogicallyInvert(expression, semanticModel, CancellationToken.None);
+        Assert.Equal(expected, result.NormalizeWhitespace().ToFullString());
+    }
+
+}