WIP: No compilation pair2

src/Analyzers/CSharp/Analyzers/AddBraces/CSharpAddBracesDiagnosticAnalyzer.cs

@@ -47,7 +47,7 @@ public void AnalyzeNode(SyntaxNodeAnalysisContext context)
     {
         var statement = context.Node;
 
-        var option = context.GetCSharpAnalyzerOptions().PreferBraces;
+        var option = context.GetCSharpAnalyzerOptions(this).PreferBraces;
         if (option.Value == PreferBracesPreference.None ||
             ShouldSkipAnalysis(context, option.Notification))
         {
@@ -107,6 +107,7 @@ public void AnalyzeNode(SyntaxNodeAnalysisContext context)
 
         var firstToken = statement.GetFirstToken();
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             Descriptor,
             firstToken.GetLocation(),
             option.Notification,

src/Analyzers/CSharp/Analyzers/CodeStyle/CSharpAnalyzerOptionsProvider.cs

@@ -96,24 +96,27 @@ public static implicit operator AnalyzerOptionsProvider(CSharpAnalyzerOptionsPro
 
 internal static class CSharpAnalyzerOptionsProviders
 {
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this AnalyzerOptions options, SyntaxTree syntaxTree)
-        => new(options.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree).GetOptionsReader());
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this AnalyzerOptions options, SyntaxTree syntaxTree, DiagnosticAnalyzer diagnosticAnalyzer)
+    {
+        options = AnalyzerOptionsUtilities.GetSpecificOptions(options, diagnosticAnalyzer);
+        return new(options.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree).GetOptionsReader());
+    }
 
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SemanticModelAnalysisContext context)
-        => GetCSharpAnalyzerOptions(context.Options, context.SemanticModel.SyntaxTree);
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SemanticModelAnalysisContext context, DiagnosticAnalyzer diagnosticAnalyzer)
+        => GetCSharpAnalyzerOptions(context.Options, context.SemanticModel.SyntaxTree, diagnosticAnalyzer);
 
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SyntaxNodeAnalysisContext context)
-        => GetCSharpAnalyzerOptions(context.Options, context.Node.SyntaxTree);
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SyntaxNodeAnalysisContext context, DiagnosticAnalyzer diagnosticAnalyzer)
+        => GetCSharpAnalyzerOptions(context.Options, context.Node.SyntaxTree, diagnosticAnalyzer);
 
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SyntaxTreeAnalysisContext context)
-        => GetCSharpAnalyzerOptions(context.Options, context.Tree);
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SyntaxTreeAnalysisContext context, DiagnosticAnalyzer diagnosticAnalyzer)
+        => GetCSharpAnalyzerOptions(context.Options, context.Tree, diagnosticAnalyzer);
 
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this CodeBlockAnalysisContext context)
-        => GetCSharpAnalyzerOptions(context.Options, context.SemanticModel.SyntaxTree);
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this CodeBlockAnalysisContext context, DiagnosticAnalyzer diagnosticAnalyzer)
+        => GetCSharpAnalyzerOptions(context.Options, context.SemanticModel.SyntaxTree, diagnosticAnalyzer);
 
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this OperationAnalysisContext context)
-        => GetCSharpAnalyzerOptions(context.Options, context.Operation.Syntax.SyntaxTree);
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this OperationAnalysisContext context, DiagnosticAnalyzer diagnosticAnalyzer)
+        => GetCSharpAnalyzerOptions(context.Options, context.Operation.Syntax.SyntaxTree, diagnosticAnalyzer);
 
-    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SymbolStartAnalysisContext context, SyntaxTree syntaxTree)
-        => GetCSharpAnalyzerOptions(context.Options, syntaxTree);
+    public static CSharpAnalyzerOptionsProvider GetCSharpAnalyzerOptions(this SymbolStartAnalysisContext context, SyntaxTree syntaxTree, DiagnosticAnalyzer diagnosticAnalyzer)
+        => GetCSharpAnalyzerOptions(context.Options, syntaxTree, diagnosticAnalyzer);
 }

src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertToBlockScopedNamespaceDiagnosticAnalyzer.cs

@@ -39,7 +39,7 @@ private void AnalyzeNamespace(SyntaxNodeAnalysisContext context)
 
     private Diagnostic? AnalyzeNamespace(SyntaxNodeAnalysisContext context, FileScopedNamespaceDeclarationSyntax declaration)
     {
-        var option = context.GetCSharpAnalyzerOptions().NamespaceDeclarations;
+        var option = context.GetCSharpAnalyzerOptions(this).NamespaceDeclarations;
         if (ShouldSkipAnalysis(context, option.Notification)
             || !ConvertNamespaceAnalysis.CanOfferUseBlockScoped(option, declaration, forAnalyzer: true))
         {
@@ -54,6 +54,7 @@ private void AnalyzeNamespace(SyntaxNodeAnalysisContext context)
             : declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.SemicolonToken.Span.End));
 
         return DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             diagnosticLocation,
             option.Notification,

src/Analyzers/CSharp/Analyzers/ConvertNamespace/ConvertToFileScopedNamespaceDiagnosticAnalyzer.cs

@@ -43,7 +43,7 @@ private void AnalyzeNamespace(SyntaxNodeAnalysisContext context)
 
     private Diagnostic? AnalyzeNamespace(SyntaxNodeAnalysisContext context, CompilationUnitSyntax root, BaseNamespaceDeclarationSyntax declaration)
     {
-        var option = context.GetCSharpAnalyzerOptions().NamespaceDeclarations;
+        var option = context.GetCSharpAnalyzerOptions(this).NamespaceDeclarations;
         if (ShouldSkipAnalysis(context, option.Notification)
             || !ConvertNamespaceAnalysis.CanOfferUseFileScoped(option, root, declaration, forAnalyzer: true))
         {
@@ -57,6 +57,7 @@ private void AnalyzeNamespace(SyntaxNodeAnalysisContext context)
             : declaration.SyntaxTree.GetLocation(TextSpan.FromBounds(declaration.SpanStart, declaration.Name.Span.End));
 
         return DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             diagnosticLocation,
             option.Notification,

src/Analyzers/CSharp/Analyzers/ConvertProgram/ConvertToProgramMainDiagnosticAnalyzer.cs

@@ -42,7 +42,7 @@ protected override void InitializeWorker(AnalysisContext context)
     private void ProcessCompilationUnit(SyntaxNodeAnalysisContext context)
     {
         var root = (CompilationUnitSyntax)context.Node;
-        var option = context.GetCSharpAnalyzerOptions().PreferTopLevelStatements;
+        var option = context.GetCSharpAnalyzerOptions(this).PreferTopLevelStatements;
 
         if (ShouldSkipAnalysis(context, option.Notification)
             || !CanOfferUseProgramMain(option, root, context.Compilation, forAnalyzer: true))
@@ -53,6 +53,7 @@ private void ProcessCompilationUnit(SyntaxNodeAnalysisContext context)
         var severity = option.Notification.Severity;
 
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             GetUseProgramMainDiagnosticLocation(
                 root, isHidden: severity.WithDefaultSeverity(DiagnosticSeverity.Hidden) == ReportDiagnostic.Hidden),

src/Analyzers/CSharp/Analyzers/ConvertProgram/ConvertToTopLevelStatementsDiagnosticAnalyzer.cs

@@ -48,7 +48,7 @@ protected override void InitializeWorker(AnalysisContext context)
     private void ProcessCompilationUnit(SyntaxNodeAnalysisContext context)
     {
         // Don't want to suggest moving if the user doesn't have a preference for top-level-statements.
-        var option = context.GetCSharpAnalyzerOptions().PreferTopLevelStatements;
+        var option = context.GetCSharpAnalyzerOptions(this).PreferTopLevelStatements;
         if (ShouldSkipAnalysis(context, option.Notification)
             || !CanOfferUseTopLevelStatements(option, forAnalyzer: true))
         {
@@ -73,6 +73,7 @@ private void ProcessCompilationUnit(SyntaxNodeAnalysisContext context)
                 {
                     // Looks good.  Let the user know this type/method can be converted to a top level program.
                     context.ReportDiagnostic(DiagnosticHelper.Create(
+                        this,
                         this.Descriptor,
                         GetUseTopLevelStatementsDiagnosticLocation(
                             methodDeclaration, isHidden: option.Notification.Severity.WithDefaultSeverity(DiagnosticSeverity.Hidden) == ReportDiagnostic.Hidden),

src/Analyzers/CSharp/Analyzers/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionDiagnosticAnalyzer.cs

@@ -39,7 +39,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
     {
-        var styleOption = context.GetCSharpAnalyzerOptions().PreferSwitchExpression;
+        var styleOption = context.GetCSharpAnalyzerOptions(this).PreferSwitchExpression;
         if (!styleOption.Value || ShouldSkipAnalysis(context, styleOption.Notification))
         {
             // User has disabled this feature.
@@ -65,7 +65,8 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         additionalLocations.Add(switchStatement.GetLocation());
         additionalLocations.AddIfNotNull(declaratorToRemoveOpt?.GetLocation());
 
-        context.ReportDiagnostic(DiagnosticHelper.Create(Descriptor,
+        context.ReportDiagnostic(DiagnosticHelper.Create(
+            this, Descriptor,
             // Report the diagnostic on the "switch" keyword.
             location: switchStatement.GetFirstToken().GetLocation(),
             notificationOption: styleOption.Notification,

src/Analyzers/CSharp/Analyzers/InlineDeclaration/CSharpInlineDeclarationDiagnosticAnalyzer.cs

@@ -70,7 +70,7 @@ private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context, INamedTypeSymb
             return;
         }
 
-        var option = context.GetCSharpAnalyzerOptions().PreferInlinedVariableDeclaration;
+        var option = context.GetCSharpAnalyzerOptions(this).PreferInlinedVariableDeclaration;
         if (!option.Value || ShouldSkipAnalysis(context, option.Notification))
         {
             // Don't bother doing any work if the user doesn't even have this preference set.
@@ -238,6 +238,7 @@ private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context, INamedTypeSymb
             : localDeclarator;
 
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             Descriptor,
             reportNode.GetLocation(),
             option.Notification,

src/Analyzers/CSharp/Analyzers/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessAnalyzer.cs

@@ -36,7 +36,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
     {
-        var styleOption = syntaxContext.GetCSharpAnalyzerOptions().PreferConditionalDelegateCall;
+        var styleOption = syntaxContext.GetCSharpAnalyzerOptions(this).PreferConditionalDelegateCall;
         if (!styleOption.Value || ShouldSkipAnalysis(syntaxContext, styleOption.Notification))
         {
             // Bail if the user has disabled this feature.
@@ -182,6 +182,7 @@ private void ReportDiagnostics(
         // Fade out the code up to the expression statement.
         var fadeLocation = Location.Create(tree, TextSpan.FromBounds(firstStatement.SpanStart, previousToken.Span.End));
         syntaxContext.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+            this,
             Descriptor,
             fadeLocation,
             NotificationOption2.ForSeverity(Descriptor.DefaultSeverity),
@@ -192,6 +193,7 @@ private void ReportDiagnostics(
 
         // Put a diagnostic with the appropriate severity on the expression-statement itself.
         syntaxContext.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             Descriptor,
             expressionStatement.GetLocation(),
             notificationOption,
@@ -203,6 +205,7 @@ private void ReportDiagnostics(
         {
             fadeLocation = Location.Create(tree, TextSpan.FromBounds(nextToken.Span.Start, ifStatement.Span.End));
             syntaxContext.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+                this,
                 Descriptor,
                 fadeLocation,
                 NotificationOption2.ForSeverity(Descriptor.DefaultSeverity),

src/Analyzers/CSharp/Analyzers/MakeAnonymousFunctionStatic/MakeAnonymousFunctionStaticDiagnosticAnalyzer.cs

@@ -38,7 +38,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
     {
-        var option = context.GetCSharpAnalyzerOptions().PreferStaticAnonymousFunction;
+        var option = context.GetCSharpAnalyzerOptions(this).PreferStaticAnonymousFunction;
         if (!option.Value || ShouldSkipAnalysis(context, option.Notification))
             return;
 

src/Analyzers/CSharp/Analyzers/MakeLocalFunctionStatic/MakeLocalFunctionStaticDiagnosticAnalyzer.cs

@@ -40,7 +40,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
             return;
         }
 
-        var option = context.GetCSharpAnalyzerOptions().PreferStaticLocalFunction;
+        var option = context.GetCSharpAnalyzerOptions(this).PreferStaticLocalFunction;
         if (!option.Value || ShouldSkipAnalysis(context, option.Notification))
         {
             return;
@@ -50,6 +50,7 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         if (MakeLocalFunctionStaticHelper.CanMakeLocalFunctionStaticBecauseNoCaptures(localFunction, semanticModel))
         {
             context.ReportDiagnostic(DiagnosticHelper.Create(
+                this,
                 Descriptor,
                 localFunction.Identifier.GetLocation(),
                 option.Notification,

src/Analyzers/CSharp/Analyzers/MakeStructMemberReadOnly/CSharpMakeStructMemberReadOnlyAnalyzer.cs

@@ -66,7 +66,7 @@ bool ShouldAnalyze(SymbolStartAnalysisContext context, [NotNullWhen(true)] out C
 
                 var cancellationToken = context.CancellationToken;
                 var declaration = reference.GetSyntax(cancellationToken);
-                var options = context.GetCSharpAnalyzerOptions(declaration.SyntaxTree);
+                var options = context.GetCSharpAnalyzerOptions(declaration.SyntaxTree, this);
                 option = options.PreferReadOnlyStructMember;
                 if (!option.Value || ShouldSkipAnalysis(declaration.SyntaxTree, context.Options, context.Compilation.Options, option.Notification, cancellationToken))
                     return false;
@@ -157,6 +157,7 @@ private void AnalyzeBlock(
         lock (methodToDiagnostic)
         {
             methodToDiagnostic[owningMethod] = DiagnosticHelper.Create(
+                this,
                 Descriptor,
                 location,
                 notificationOption,

src/Analyzers/CSharp/Analyzers/MakeStructReadOnly/CSharpMakeStructReadOnlyDiagnosticAnalyzer.cs

@@ -57,6 +57,7 @@ protected override void InitializeWorker(AnalysisContext context)
                         return;
 
                     context.ReportDiagnostic(DiagnosticHelper.Create(
+                        this,
                         Descriptor,
                         location,
                         option.Notification,
@@ -91,7 +92,7 @@ private bool IsCandidate(
         if (typeReference.GetSyntax(cancellationToken) is not TypeDeclarationSyntax typeDeclaration)
             return false;
 
-        var options = context.GetCSharpAnalyzerOptions(typeDeclaration.SyntaxTree);
+        var options = context.GetCSharpAnalyzerOptions(typeDeclaration.SyntaxTree, this);
         option = options.PreferReadOnlyStruct;
         if (!option.Value || ShouldSkipAnalysis(typeDeclaration.SyntaxTree, context.Options, context.Compilation.Options, option.Notification, cancellationToken))
             return false;

src/Analyzers/CSharp/Analyzers/MisplacedUsingDirectives/MisplacedUsingDirectivesDiagnosticAnalyzer.cs

@@ -56,7 +56,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void AnalyzeNamespaceNode(SyntaxNodeAnalysisContext context)
     {
-        var option = context.GetCSharpAnalyzerOptions().UsingDirectivePlacement;
+        var option = context.GetCSharpAnalyzerOptions(this).UsingDirectivePlacement;
         if (option.Value == AddImportPlacement.InsideNamespace
             || ShouldSkipAnalysis(context, option.Notification))
         {
@@ -77,7 +77,7 @@ option.Value is AddImportPlacement.OutsideNamespaceIgnoringAliases
 
     private void AnalyzeCompilationUnitNode(SyntaxNodeAnalysisContext context)
     {
-        var option = context.GetCSharpAnalyzerOptions().UsingDirectivePlacement;
+        var option = context.GetCSharpAnalyzerOptions(this).UsingDirectivePlacement;
         var compilationUnit = (CompilationUnitSyntax)context.Node;
 
         if (option.Value != AddImportPlacement.InsideNamespace
@@ -103,13 +103,14 @@ private static bool ShouldSuppressDiagnostic(CompilationUnitSyntax compilationUn
             t => t.Kind() is not (SyntaxKind.UsingDirective or SyntaxKind.NamespaceDeclaration or SyntaxKind.FileScopedNamespaceDeclaration));
     }
 
-    private static void ReportDiagnostics(
+    private void ReportDiagnostics(
        SyntaxNodeAnalysisContext context, DiagnosticDescriptor descriptor,
        IEnumerable<UsingDirectiveSyntax> usingDirectives, CodeStyleOption2<AddImportPlacement> option)
     {
         foreach (var usingDirective in usingDirectives)
         {
             context.ReportDiagnostic(DiagnosticHelper.Create(
+                this,
                 descriptor,
                 usingDirective.GetLocation(),
                 option.Notification,

src/Analyzers/CSharp/Analyzers/NewLines/ArrowExpressionClausePlacement/ArrowExpressionClausePlacementDiagnosticAnalyzer.cs

@@ -34,7 +34,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void AnalyzeTree(SyntaxTreeAnalysisContext context, CompilationOptions compilationOptions)
     {
-        var option = context.GetCSharpAnalyzerOptions().AllowBlankLineAfterTokenInArrowExpressionClause;
+        var option = context.GetCSharpAnalyzerOptions(this).AllowBlankLineAfterTokenInArrowExpressionClause;
         if (option.Value || ShouldSkipAnalysis(context, compilationOptions, option.Notification))
             return;
 
@@ -76,6 +76,7 @@ private void ProcessArrowExpressionClause(
             return;
 
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             arrowExpressionClause.ArrowToken.GetLocation(),
             notificationOption,

src/Analyzers/CSharp/Analyzers/NewLines/ConditionalExpressionPlacement/ConditionalExpressionPlacementDiagnosticAnalyzer.cs

@@ -34,7 +34,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void ProcessConditionalExpression(SyntaxNodeAnalysisContext context)
     {
-        var option = context.GetCSharpAnalyzerOptions().AllowBlankLineAfterTokenInConditionalExpression;
+        var option = context.GetCSharpAnalyzerOptions(this).AllowBlankLineAfterTokenInConditionalExpression;
         if (option.Value || ShouldSkipAnalysis(context, option.Notification))
             return;
 
@@ -57,6 +57,7 @@ private void ProcessConditionalExpression(SyntaxNodeAnalysisContext context)
         }
 
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             conditionalExpression.QuestionToken.GetLocation(),
             option.Notification,

src/Analyzers/CSharp/Analyzers/NewLines/ConsecutiveBracePlacement/ConsecutiveBracePlacementDiagnosticAnalyzer.cs

@@ -33,7 +33,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void AnalyzeTree(SyntaxTreeAnalysisContext context, CompilationOptions compilationOptions)
     {
-        var option = context.GetCSharpAnalyzerOptions().AllowBlankLinesBetweenConsecutiveBraces;
+        var option = context.GetCSharpAnalyzerOptions(this).AllowBlankLinesBetweenConsecutiveBraces;
         if (option.Value || ShouldSkipAnalysis(context, compilationOptions, option.Notification))
             return;
 
@@ -80,6 +80,7 @@ private void ProcessToken(SyntaxTreeAnalysisContext context, NotificationOption2
             return;
 
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             secondBrace.GetLocation(),
             notificationOption,

src/Analyzers/CSharp/Analyzers/NewLines/ConstructorInitializerPlacement/ConstructorInitializerPlacementDiagnosticAnalyzer.cs

@@ -34,7 +34,7 @@ protected override void InitializeWorker(AnalysisContext context)
 
     private void AnalyzeTree(SyntaxTreeAnalysisContext context, CompilationOptions compilationOptions)
     {
-        var option = context.GetCSharpAnalyzerOptions().AllowBlankLineAfterColonInConstructorInitializer;
+        var option = context.GetCSharpAnalyzerOptions(this).AllowBlankLineAfterColonInConstructorInitializer;
         if (option.Value || ShouldSkipAnalysis(context, compilationOptions, option.Notification))
             return;
 
@@ -88,6 +88,7 @@ private void ProcessConstructorInitializer(
             return;
 
         context.ReportDiagnostic(DiagnosticHelper.Create(
+            this,
             this.Descriptor,
             colonToken.GetLocation(),
             notificationOption,