add codefix

Author: Bazeloth

src/ProgressOnderwijsUtils.Analyzers/IfNotFalseAnalyzer.cs

@@ -21,7 +21,7 @@ public sealed class IfNotFalseAnalyzer : DiagnosticAnalyzer
     );
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => [Rule,];
 
     public override void Initialize(AnalysisContext context)
     {

src/ProgressOnderwijsUtils.Analyzers/IfNotFalseCodeFix.cs

@@ -0,0 +1,65 @@
+using System.Collections.Immutable;
+using System.Composition;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace ProgressOnderwijsUtils.Analyzers;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(RedundantAssertNotNullCodeFix))]
+[Shared]
+public sealed class IfNotFalseCodeFix : CodeFixProvider
+{
+    public override ImmutableArray<string> FixableDiagnosticIds
+        => [IfNotFalseAnalyzer.Rule.Id,];
+
+    public override FixAllProvider GetFixAllProvider()
+        => WellKnownFixAllProviders.BatchFixer;
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        const string title = "Remove redundant if statement";
+        var diagnostic = context.Diagnostics.First();
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+        if (root is null) {
+            return;
+        }
+
+        var ifStatement = root.FindNode(diagnostic.Location.SourceSpan).FirstAncestorOrSelf<IfStatementSyntax>();
+        if (ifStatement is null) {
+            return;
+        }
+
+        var newRoot = ifStatement.Statement is BlockSyntax { Statements.Count: > 0, } block
+            ? ReplaceWithBlockStatements(root, ifStatement, block)
+            : root.RemoveNode(ifStatement, SyntaxRemoveOptions.KeepNoTrivia);
+
+        if (newRoot is null) {
+            return;
+        }
+
+        context.RegisterCodeFix(
+            CodeAction.Create(
+                title,
+                _ => Task.FromResult(context.Document.WithSyntaxRoot(newRoot)),
+                title
+            ),
+            diagnostic
+        );
+    }
+
+    private static SyntaxNode ReplaceWithBlockStatements(SyntaxNode root, IfStatementSyntax ifStatement, BlockSyntax block)
+    {
+        var statements = block.Statements;
+        var firstStatement = statements[0]
+            .WithLeadingTrivia(ifStatement.GetLeadingTrivia())
+            .WithTrailingTrivia(block.GetTrailingTrivia());
+
+        var newStatements = statements.Replace(statements[0], firstStatement);
+
+        return root.ReplaceNode(ifStatement, newStatements);
+    }
+}

test/ProgressOnderwijsUtils.Analyzers.Tests/IfNotFalseAnalyzerTest.cs

@@ -1,4 +1,5 @@
 using System.Linq;
+using System.Threading.Tasks;
 using ExpressionToCodeLib;
 using Xunit;
 
@@ -38,4 +39,38 @@ void M()
         var diagnostics = DiagnosticHelper.GetDiagnostics(new IfNotFalseAnalyzer(), source);
         PAssert.That(() => diagnostics.None());
     }
+
+    [Fact]
+    public async Task CodeFix_RemovesIfNotFalse()
+    {
+        var source = """
+            class C
+            {
+                void M()
+                {
+                    if (!false) { System.Console.WriteLine("Hello"); }
+                }
+            }
+            """;
+        var expected = """
+            class C
+            {
+                void M()
+                {
+                    System.Console.WriteLine("Hello");
+                }
+            }
+            """;
+
+        var workspace = DiagnosticHelper.CreateProjectWithTestFile(source);
+        var diagnostic = DiagnosticHelper.GetDiagnostics(new IfNotFalseAnalyzer(), workspace).Single();
+
+        var fixesMade = await DiagnosticHelper.ApplyAllCodeFixes(workspace, diagnostic, new IfNotFalseCodeFix());
+        PAssert.That(() => fixesMade == 1);
+        var result = await workspace.CurrentSolution.Projects.Single().Documents.Single().GetTextAsync();
+        Assert.Equal(
+            expected,
+            result.ToString()
+        );
+    }
 }