Disable usage analyzers by default, enable via editorconfig (#214)

* Initial plan

* Add config helper and update all usage analyzers to respect enable flag

Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com>

* Update all usage analyzer tests with config support and add disabled tests

Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com>

* Fix analyzer config key format and update tests

Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com>

* Add analyzer config to all test helper methods

Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com>

* Make tweaks including tags

* Add base type for tests to make it easier

* Fix invalid test

* Fix AnalyzerTests

* Update tests/NetEscapades.EnumGenerators.Tests/AnalyzerTestsBase.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fix compilation

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: andrewlock <18755388+andrewlock@users.noreply.github.com>
Co-authored-by: Andrew Lock <andrewlock.net@gmail.com>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 3 people

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/GetNamesAnalyzer.cs

@@ -21,14 +21,19 @@ public class GetNamesAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/GetValuesAnalyzer.cs

@@ -21,14 +21,19 @@ public class GetValuesAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/GetValuesAsUnderlyingTypeAnalyzer.cs

@@ -21,14 +21,19 @@ public class GetValuesAsUnderlyingTypeAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/HasFlagAnalyzer.cs

@@ -21,14 +21,19 @@ public class HasFlagAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/IsDefinedAnalyzer.cs

@@ -21,14 +21,19 @@ public class IsDefinedAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/ParseAnalyzer.cs

@@ -21,14 +21,19 @@ public class ParseAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/ToStringAnalyzer.cs

@@ -21,14 +21,19 @@ public class ToStringAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/TryParseAnalyzer.cs

@@ -21,14 +21,19 @@ public class TryParseAnalyzer : DiagnosticAnalyzer
         isEnabledByDefault: true);
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
-        => ImmutableArray.Create(Rule);
+        => ImmutableArray.Create(Rule, UsageAnalyzerConfig.ConfigDescriptor);
 
     public override void Initialize(AnalysisContext context)
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
         context.EnableConcurrentExecution();
         context.RegisterCompilationStartAction(ctx =>
         {
+            if (!UsageAnalyzerConfig.IsEnabled(ctx.Options))
+            {
+                return;
+            }
+
             var (enumExtensionsAttr, externalEnumTypes) = AnalyzerHelpers.GetEnumExtensionAttributes(ctx.Compilation);
             if (enumExtensionsAttr is null || externalEnumTypes is null)
             {

src/NetEscapades.EnumGenerators/Diagnostics/UsageAnalyzers/UsageAnalyzerConfig.cs

@@ -0,0 +1,34 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace NetEscapades.EnumGenerators.Diagnostics.UsageAnalyzers;
+
+public static class UsageAnalyzerConfig
+{
+    public const string EnableKey = "netescapades.enumgenerators.usage_analyzers.enable";
+
+    internal static readonly DiagnosticDescriptor ConfigDescriptor = new(
+#pragma warning disable RS2008 // Enable Analyzer Release Tracking
+        id: "NEEGCONFIG001",
+#pragma warning restore RS2008
+        title: "Enable callsite analyzers for generated enum extensions",
+        messageFormat:
+        "Enable analyzers to encourage use of generated extension methods instead of System.Enum methods",
+        category: "Configuration",
+        defaultSeverity: DiagnosticSeverity.Hidden,
+        isEnabledByDefault: true,
+        customTags:
+        [
+            "EditorConfigOption",
+            "EditorConfigOptionKey=netescapades.enumgenerators.usage_analyzers.enable",
+            "EditorConfigOptionDescription=Enable callsite analyzers for generated enum extensions",
+            "EditorConfigOptionAllowedValues=true,false",
+            "EditorConfigOptionDefault=false",
+            WellKnownDiagnosticTags.NotConfigurable
+        ]);
+
+    internal static bool IsEnabled(AnalyzerOptions context)
+        => context.AnalyzerConfigOptionsProvider.GlobalOptions.TryGetValue(EnableKey, out var value) &&
+           bool.TryParse(value, out var isEnabled)
+           && isEnabled;
+}

tests/NetEscapades.EnumGenerators.IntegrationTests/.globalconfig

@@ -0,0 +1,2 @@
+is_global = true
+netescapades.enumgenerators.usage_analyzers.enable = true