EditorConfig Support

README.md

@@ -190,7 +190,8 @@ Multiple source files can be added with separate `WithSource` calls.
 | `BuildAs(outputKind)` | Change the compilation output kind (defaults to `DynamicallyLinkedLibrary`). |
 | `SuppressCompilationErrors()` | Ignore compilation errors, useful when testing analyzers that run on code that does not compile. |
 | `WithInterceptorNamespace(ns)` | Add an interceptors namespace feature flag to the compilation. |
-| `WithProperty(name, value)` | Add an arbitrary MSBuild-style build property (feature flag) to the compilation. |
+| `WithProperty(name, value)` | Add an arbitrary MSBuild-style build property (feature flag) to the compilation. The property is available through global and syntax-tree analyzer config options. |
+| `WithEditorConfigOption(name, value, filename)` | Add an EditorConfig option to syntax-tree analyzer config options. Omit `filename` to apply it to all source files; specify a filename to scope it to that source file. EditorConfig options are not available through global analyzer config options. |
 | `AssertDiagnostics(expectedDiagnosticIds)` | Run the analyzer and assert that the diagnostics match the `[|…|]`-marked locations. |
 
 ## Testing code fixes
@@ -253,7 +254,8 @@ To configure all code fix tests in a project, use `CodeFixTest.ConfigureAllCodeF
 | `BuildAs(outputKind)` | Change the compilation output kind. |
 | `SuppressCompilationErrors()` | Ignore compilation errors. |
 | `WithInterceptorNamespace(ns)` | Add an interceptors namespace feature flag to the compilation. |
-| `WithProperty(name, value)` | Add an arbitrary build property to the compilation. |
+| `WithProperty(name, value)` | Add an arbitrary build property to the compilation. The property is available through global and syntax-tree analyzer config options. |
+| `WithEditorConfigOption(name, value, filename)` | Add an EditorConfig option to syntax-tree analyzer config options. Omit `filename` to apply it to all source files; specify a filename to scope it to that source file. EditorConfig options are not available through global analyzer config options. |
 | `AssertCodeFixes()` | Apply code fixes iteratively and assert that the final source matches the expected output. |
 
 ## Testing source generators
@@ -308,7 +310,8 @@ To configure all source generator tests in a project, use `SourceGeneratorTest.C
 | `SuppressCompilationErrors()` | Ignore compilation warnings and errors. |
 | `SuppressDiagnosticErrors()` | Ignore errors raised by the source generator itself. |
 | `WithInterceptorNamespace(ns)` | Add an interceptors namespace feature flag to the compilation. |
-| `WithProperty(name, value)` | Add an arbitrary build property to the compilation. |
+| `WithProperty(name, value)` | Add an arbitrary build property to the compilation. The property is available through global and syntax-tree analyzer config options. |
+| `WithEditorConfigOption(name, value, filename)` | Add an EditorConfig option to syntax-tree analyzer config options. Omit `filename` to apply it to all source files; specify a filename to scope it to that source file. EditorConfig options are not available through global analyzer config options. |
 | `Run()` | Run the source generator without running an approval test. |
 | `Approve(scrubber)` | Run the generator (if not already run) and perform an approval test on the generated output. |
 | `ShouldNotGenerateCode()` | Assert that the source generator produces no output for the given sources. |

src/FakeAnalyzers/DiagnosticDescriptors.cs

@@ -35,4 +35,12 @@ public static class DiagnosticDescriptors
         category: "Code",
         defaultSeverity: DiagnosticSeverity.Error,
         isEnabledByDefault: true);
+
+    public static readonly DiagnosticDescriptor EditorConfigOptionEnabled = new(
+        id: DiagnosticIds.EditorConfigOptionEnabled,
+        title: "EditorConfig option is enabled",
+        messageFormat: "The EditorConfig option is enabled for '{0}'",
+        category: "Code",
+        defaultSeverity: DiagnosticSeverity.Error,
+        isEnabledByDefault: true);
 }

src/FakeAnalyzers/DiagnosticIds.cs

@@ -10,4 +10,5 @@ public static class DiagnosticIds
     public const string AsyncVoid = "FAKE0002";
     public const string IdentifierContainsFoo = "FAKE0003";
     public const string TestFlagEnabled = "FAKE0004";
+    public const string EditorConfigOptionEnabled = "FAKE0005";
 }

src/FakeAnalyzers/EditorConfigOptionAnalyzer.cs

@@ -0,0 +1,35 @@
+namespace FakeAnalyzers;
+
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class EditorConfigOptionAnalyzer : DiagnosticAnalyzer
+{
+    const string OptionName = "nservicebus_enable_message_overload_migration_diagnostics";
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [DiagnosticDescriptors.EditorConfigOptionEnabled];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterSyntaxNodeAction(AnalyzeClass, SyntaxKind.ClassDeclaration);
+    }
+
+    static void AnalyzeClass(SyntaxNodeAnalysisContext context)
+    {
+        var optionsProvider = context.Options.AnalyzerConfigOptionsProvider;
+        if (!optionsProvider.GetOptions(context.Node.SyntaxTree).TryGetValue(OptionName, out var value) || value != "true" || optionsProvider.GlobalOptions.TryGetValue(OptionName, out _))
+        {
+            return;
+        }
+
+        var classDeclaration = (ClassDeclarationSyntax)context.Node;
+        var diagnostic = Diagnostic.Create(DiagnosticDescriptors.EditorConfigOptionEnabled, classDeclaration.Identifier.GetLocation(), classDeclaration.Identifier.Text);
+        context.ReportDiagnostic(diagnostic);
+    }
+}

src/FakeAnalyzers/EditorConfigOptionSourceGenerator.cs

@@ -0,0 +1,34 @@
+namespace FakeAnalyzers;
+
+using System.Text;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+[Generator(LanguageNames.CSharp)]
+public sealed class EditorConfigOptionSourceGenerator : IIncrementalGenerator
+{
+    const string AllSourceOption = "test_all_source_option";
+    const string FilenameOption = "test_filename_option";
+
+    public void Initialize(IncrementalGeneratorInitializationContext context)
+    {
+        var compilationAndOptions = context.CompilationProvider.Combine(context.AnalyzerConfigOptionsProvider);
+        context.RegisterSourceOutput(compilationAndOptions, static (productionContext, input) =>
+        {
+            var output = new StringBuilder();
+
+            foreach (var tree in input.Left.SyntaxTrees)
+            {
+                var options = input.Right.GetOptions(tree);
+                var allSourceValue = GetOptionValue(options, AllSourceOption);
+                var filenameValue = GetOptionValue(options, FilenameOption);
+                output.AppendLine($"// {tree.FilePath}: all-source={allSourceValue}; filename={filenameValue}");
+            }
+
+            productionContext.AddSource("EditorConfigOptions.g.cs", output.ToString());
+        });
+    }
+
+    static string GetOptionValue(AnalyzerConfigOptions options, string name)
+        => options.TryGetValue(name, out var value) ? value : "<not-set>";
+}

src/FakeAnalyzers/TestFlagAnalyzer.cs

@@ -29,7 +29,9 @@ public override void Initialize(AnalysisContext context)
 
     static void AnalyzeClass(SyntaxNodeAnalysisContext context)
     {
-        if (context.Node is not ClassDeclarationSyntax classDeclaration)
+        if (context.Node is not ClassDeclarationSyntax classDeclaration ||
+            !context.Options.AnalyzerConfigOptionsProvider.GetOptions(context.Node.SyntaxTree).TryGetValue("build_property.TestFlag", out var value) ||
+            value != "enabled")
         {
             return;
         }

src/Particular.AnalyzerTesting/AnalyzerConfigOptionsFactory.cs

@@ -6,17 +6,48 @@ namespace Particular.AnalyzerTesting;
 
 static class AnalyzerConfigOptionsFactory
 {
-    public static AnalyzerConfigOptionsProvider CreateOptionsProvider(IReadOnlyDictionary<string, string> properties)
-        => new OptionsProvider(new DictionaryAnalyzerConfigOptions(properties));
+    public static AnalyzerConfigOptionsProvider CreateOptionsProvider(
+        IReadOnlyDictionary<string, string> globalProperties,
+        IReadOnlyDictionary<string, string>? sourceProperties = null,
+        IReadOnlyDictionary<string, Dictionary<string, string>>? sourceFileProperties = null)
+        => new OptionsProvider(globalProperties, sourceProperties ?? new Dictionary<string, string>(), sourceFileProperties ?? new Dictionary<string, Dictionary<string, string>>());
 
-    public static AnalyzerOptions CreateAnalyzerOptions(IReadOnlyDictionary<string, string> properties)
-        => new([], CreateOptionsProvider(properties));
+    public static AnalyzerOptions CreateAnalyzerOptions(
+        IReadOnlyDictionary<string, string> globalProperties,
+        IReadOnlyDictionary<string, string>? sourceProperties = null,
+        IReadOnlyDictionary<string, Dictionary<string, string>>? sourceFileProperties = null)
+        => new([], CreateOptionsProvider(globalProperties, sourceProperties, sourceFileProperties));
 
-    sealed class OptionsProvider(AnalyzerConfigOptions options) : AnalyzerConfigOptionsProvider
+    sealed class OptionsProvider(
+        IReadOnlyDictionary<string, string> globalProperties,
+        IReadOnlyDictionary<string, string> sourceProperties,
+        IReadOnlyDictionary<string, Dictionary<string, string>> sourceFileProperties) : AnalyzerConfigOptionsProvider
     {
-        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree) => options;
-        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile) => options;
-        public override AnalyzerConfigOptions GlobalOptions => options;
+        public override AnalyzerConfigOptions GetOptions(SyntaxTree tree)
+        {
+            var properties = new Dictionary<string, string>(globalProperties);
+            AddProperties(properties, sourceProperties);
+
+            if (sourceFileProperties.TryGetValue(tree.FilePath, out var fileProperties))
+            {
+                AddProperties(properties, fileProperties);
+            }
+
+            return new DictionaryAnalyzerConfigOptions(properties);
+        }
+
+        public override AnalyzerConfigOptions GetOptions(AdditionalText textFile)
+            => new DictionaryAnalyzerConfigOptions(globalProperties);
+
+        public override AnalyzerConfigOptions GlobalOptions { get; } = new DictionaryAnalyzerConfigOptions(globalProperties);
+
+        static void AddProperties(Dictionary<string, string> destination, IReadOnlyDictionary<string, string> source)
+        {
+            foreach (var (key, value) in source)
+            {
+                destination[key] = value;
+            }
+        }
     }
 
     sealed class DictionaryAnalyzerConfigOptions(IReadOnlyDictionary<string, string> properties) : AnalyzerConfigOptions

src/Particular.AnalyzerTesting/BaseAnalyzerTest.cs

@@ -86,7 +86,7 @@ private protected static async Task<Diagnostic[]> GetCompilerDiagnostics(Project
     private protected async Task<Diagnostic[]> GetAnalyzerDiagnostics(Compilation compilation, string[] ignoreDiagnosticIds, CancellationToken cancellationToken = default)
     {
         var analyzerTasks = analyzers
-            .Select(analyzer => compilation.GetAnalyzerDiagnostics(analyzer, features, cancellationToken))
+            .Select(analyzer => compilation.GetAnalyzerDiagnostics(analyzer, features, editorConfigOptions, editorConfigOptionsByFilename, cancellationToken))
             .ToArray();
 
         await Task.WhenAll(analyzerTasks);

src/Particular.AnalyzerTesting/BaseCompilationTest.cs

@@ -20,6 +20,8 @@ public abstract class BaseCompilationTest<TSelf> where TSelf : BaseCompilationTe
     private protected OutputKind buildOutputType = OutputKind.DynamicallyLinkedLibrary;
     private protected bool suppressCompilationErrors;
     private protected readonly Dictionary<string, string> features = [];
+    private protected readonly Dictionary<string, string> editorConfigOptions = [];
+    private protected readonly Dictionary<string, Dictionary<string, string>> editorConfigOptionsByFilename = [];
 
     private protected BaseCompilationTest(string? outputAssemblyName = null)
     {
@@ -128,11 +130,34 @@ public TSelf WithInterceptorNamespace(string interceptorNamespace)
     }
 
     /// <summary>
-    /// Add a build property to the compilation.
+    /// Add a build property to the compilation. The property is available through both the global and syntax-tree analyzer config options.
     /// </summary>
     public TSelf WithProperty(string name, string value)
     {
         features.Add(name, value);
         return Self;
     }
+
+    /// <summary>
+    /// Add an EditorConfig option that is available through syntax-tree analyzer config options.
+    /// Omit <paramref name="filename" /> to apply the option to every source file.
+    /// The option is not added to global analyzer config options.
+    /// </summary>
+    public TSelf WithEditorConfigOption(string name, string value, string? filename = null)
+    {
+        if (filename is null)
+        {
+            editorConfigOptions.Add(name, value);
+            return Self;
+        }
+
+        if (!editorConfigOptionsByFilename.TryGetValue(filename, out var fileOptions))
+        {
+            fileOptions = [];
+            editorConfigOptionsByFilename.Add(filename, fileOptions);
+        }
+
+        fileOptions.Add(name, value);
+        return Self;
+    }
 }

src/Particular.AnalyzerTesting/CompilationExtensions.cs

@@ -32,12 +32,17 @@ public void Compile(bool throwOnFailure = true)
             Debug.WriteLine("Compilation failed.");
         }
 
-        public async Task<IEnumerable<Diagnostic>> GetAnalyzerDiagnostics(DiagnosticAnalyzer analyzer, IReadOnlyDictionary<string, string> properties, CancellationToken cancellationToken = default)
+        public async Task<IEnumerable<Diagnostic>> GetAnalyzerDiagnostics(
+            DiagnosticAnalyzer analyzer,
+            IReadOnlyDictionary<string, string> globalProperties,
+            IReadOnlyDictionary<string, string> sourceProperties,
+            IReadOnlyDictionary<string, Dictionary<string, string>> sourceFileProperties,
+            CancellationToken cancellationToken = default)
         {
             var exceptions = new List<Exception>();
 
             var analysisOptions = new CompilationWithAnalyzersOptions(
-                AnalyzerConfigOptionsFactory.CreateAnalyzerOptions(properties),
+                AnalyzerConfigOptionsFactory.CreateAnalyzerOptions(globalProperties, sourceProperties, sourceFileProperties),
                 (exception, _, __) => exceptions.Add(exception),
                 concurrentAnalysis: false,
                 logAnalyzerExecutionTime: false);

src/Particular.AnalyzerTesting/SourceGeneratorTest.cs

@@ -170,7 +170,7 @@ public SourceGeneratorTestResult Run()
             disabledOutputs: IncrementalGeneratorOutputKind.None,
             trackIncrementalGeneratorSteps: true);
 
-        var optsProvider = AnalyzerConfigOptionsFactory.CreateOptionsProvider(features);
+        var optsProvider = AnalyzerConfigOptionsFactory.CreateOptionsProvider(features, editorConfigOptions, editorConfigOptionsByFilename);
 
         var driver = CSharpGeneratorDriver.Create(generators,
             driverOptions: driverOpts,

src/Tests/Analyzers/TestFlagAnalyzerTests.cs

@@ -19,4 +19,20 @@ public Task ReportsDiagnosticWhenPropertyIsEnabled() =>
             .WithProperty("build_property.TestFlag", "enabled")
             .WithSource(Code)
             .AssertDiagnostics(DiagnosticIds.TestFlagEnabled);
+
+    [Test]
+    public Task ReportsDiagnosticWhenEditorConfigOptionIsEnabledForAllSources() =>
+        AnalyzerTest.ForAnalyzer<EditorConfigOptionAnalyzer>()
+            .WithEditorConfigOption("nservicebus_enable_message_overload_migration_diagnostics", "true")
+            .WithSource("public class [|First|] { }", "First.cs")
+            .WithSource("public class [|Second|] { }", "Second.cs")
+            .AssertDiagnostics(DiagnosticIds.EditorConfigOptionEnabled);
+
+    [Test]
+    public Task ReportsDiagnosticOnlyForEditorConfigOptionSourceFile() =>
+        AnalyzerTest.ForAnalyzer<EditorConfigOptionAnalyzer>()
+            .WithEditorConfigOption("nservicebus_enable_message_overload_migration_diagnostics", "true", "Selected.cs")
+            .WithSource("public class [|Selected|] { }", "Selected.cs")
+            .WithSource("public class Other { }", "Other.cs")
+            .AssertDiagnostics(DiagnosticIds.EditorConfigOptionEnabled);
 }

src/Tests/ApprovalFiles/ApiApproval.ApproveApi.approved.txt

@@ -37,6 +37,7 @@ namespace Particular.AnalyzerTesting
         public TSelf SuppressCompilationErrors() { }
         public TSelf WithAnalyzer<TAnalyzer>()
             where TAnalyzer : Microsoft.CodeAnalysis.Diagnostics.DiagnosticAnalyzer, new () { }
+        public TSelf WithEditorConfigOption(string name, string value, string? filename = null) { }
         public TSelf WithInterceptorNamespace(string interceptorNamespace) { }
         public TSelf WithLangVersion(Microsoft.CodeAnalysis.CSharp.LanguageVersion langVersion) { }
         public TSelf WithProperty(string name, string value) { }

src/Tests/SourceGenerators/BasicSourceGeneratorTest.cs

@@ -64,4 +64,19 @@ public void AnalyzerSeesPropertyDuringSourceGeneratorRun()
 
         Assert.That(result.AnalyzerDiagnostics.Select(diagnostic => diagnostic.Id), Contains.Item(DiagnosticIds.TestFlagEnabled));
     }
+
+    [Test]
+    public void SourceGeneratorSeesEditorConfigOptionsForEachSourceFile()
+    {
+        var result = SourceGeneratorTest.ForIncrementalGenerator<EditorConfigOptionSourceGenerator>(["CompilationAndOptions"])
+            .WithEditorConfigOption("test_all_source_option", "all-sources")
+            .WithEditorConfigOption("test_filename_option", "selected-only", "Selected.cs")
+            .WithSource("public class Selected { }", "Selected.cs")
+            .WithSource("public class Other { }", "Other.cs")
+            .Run();
+
+        var output = result.GetCompilationOutput();
+        Assert.That(output, Does.Contain("// Selected.cs: all-source=all-sources; filename=selected-only"));
+        Assert.That(output, Does.Contain("// Other.cs: all-source=all-sources; filename=<not-set>"));
+    }
 }