Merge pull request #14 from delegateas/copilot/add-enforce-control-flow-brackets-rule

Add CT0004 analyzer for enforcing braceless control flow statements

Author: magesoe

src/DataverseAnalyzer/NoBracesForControlFlowAnalyzer.cs

@@ -0,0 +1,88 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace DataverseAnalyzer;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class NoBracesForControlFlowAnalyzer : DiagnosticAnalyzer
+{
+    private static readonly Lazy<DiagnosticDescriptor> LazyRule = new(() => new DiagnosticDescriptor(
+        "CT0004",
+        Resources.CT0004_Title,
+        Resources.CT0004_MessageFormat,
+        "Style",
+        DiagnosticSeverity.Error,
+        isEnabledByDefault: true,
+        description: Resources.CT0004_Description));
+
+    public static DiagnosticDescriptor Rule => LazyRule.Value;
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        if (context is null)
+        {
+            throw new ArgumentNullException(nameof(context));
+        }
+
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeIfStatement, SyntaxKind.IfStatement);
+        context.RegisterSyntaxNodeAction(AnalyzeElseClause, SyntaxKind.ElseClause);
+    }
+
+    private static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
+    {
+        var ifStatement = (IfStatementSyntax)context.Node;
+        AnalyzeEmbeddedStatement(context, ifStatement.Statement);
+    }
+
+    private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context)
+    {
+        var elseClause = (ElseClauseSyntax)context.Node;
+        if (elseClause.Statement is not IfStatementSyntax)
+        {
+            AnalyzeEmbeddedStatement(context, elseClause.Statement);
+        }
+    }
+
+    private static void AnalyzeEmbeddedStatement(SyntaxNodeAnalysisContext context, StatementSyntax statement)
+    {
+        if (statement is not BlockSyntax block)
+        {
+            return;
+        }
+
+        if (block.Statements.Count != 1)
+        {
+            return;
+        }
+
+        var singleStatement = block.Statements[0];
+        if (!IsControlFlowStatement(singleStatement))
+        {
+            return;
+        }
+
+        var diagnostic = Diagnostic.Create(Rule, block.GetLocation());
+        context.ReportDiagnostic(diagnostic);
+    }
+
+    private static bool IsControlFlowStatement(StatementSyntax statement)
+    {
+        return statement.Kind() switch
+        {
+            SyntaxKind.ReturnStatement => true,
+            SyntaxKind.ThrowStatement => true,
+            SyntaxKind.ContinueStatement => true,
+            SyntaxKind.BreakStatement => true,
+            SyntaxKind.YieldReturnStatement => false,
+            SyntaxKind.YieldBreakStatement => true,
+            _ => false,
+        };
+    }
+}

src/DataverseAnalyzer/NoBracesForControlFlowCodeFixProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace DataverseAnalyzer;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(NoBracesForControlFlowCodeFixProvider))]
+public sealed class NoBracesForControlFlowCodeFixProvider : CodeFixProvider
+{
+    public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(NoBracesForControlFlowAnalyzer.Rule.Id);
+
+    public sealed override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+    public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+        if (root is null)
+        {
+            return;
+        }
+
+        var diagnostic = context.Diagnostics.FirstOrDefault(d => FixableDiagnosticIds.Contains(d.Id, StringComparer.Ordinal));
+        if (diagnostic is null)
+        {
+            return;
+        }
+
+        var diagnosticSpan = diagnostic.Location.SourceSpan;
+        var block = root.FindNode(diagnosticSpan) as BlockSyntax;
+        if (block is null || block.Statements.Count != 1)
+        {
+            return;
+        }
+
+        var action = CodeAction.Create(
+            title: Resources.CT0004_CodeFix_Title,
+            createChangedDocument: c => RemoveBraces(context.Document, root, block, c),
+            equivalenceKey: "RemoveBraces");
+
+        context.RegisterCodeFix(action, diagnostic);
+    }
+
+    private static Task<Document> RemoveBraces(Document document, SyntaxNode root, BlockSyntax block, CancellationToken cancellationToken)
+    {
+        var statement = block.Statements[0];
+        var newStatement = statement.WithTriviaFrom(block);
+
+        var newRoot = root.ReplaceNode(block, newStatement);
+        var newDocument = document.WithSyntaxRoot(newRoot);
+
+        return Task.FromResult(newDocument);
+    }
+}

src/DataverseAnalyzer/Resources.Designer.cs

@@ -88,4 +88,16 @@
   <data name="CT0003_Description" xml:space="preserve">
     <value>Object initialization with empty parentheses followed by an initializer is unnecessary and should be avoided for cleaner code.</value>
   </data>
+  <data name="CT0004_Title" xml:space="preserve">
+    <value>Control flow statement with braces containing only control flow should not have braces</value>
+  </data>
+  <data name="CT0004_MessageFormat" xml:space="preserve">
+    <value>Block containing only a control flow statement (return, throw, continue, break, or yield break) should not have braces</value>
+  </data>
+  <data name="CT0004_Description" xml:space="preserve">
+    <value>When a block contains only a single control flow statement, braces should be omitted to improve code readability and consistency.</value>
+  </data>
+  <data name="CT0004_CodeFix_Title" xml:space="preserve">
+    <value>Remove braces</value>
+  </data>
 </root>