Simplify HostAnalysisScope since it is only ever used in the context …

…of a single analyzer

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerExecutor.cs

@@ -189,7 +189,6 @@ internal ImmutableDictionary<DiagnosticAnalyzer, TimeSpan> AnalyzerExecutionTime
         /// <summary>
         /// Executes the <see cref="DiagnosticAnalyzer.Initialize(AnalysisContext)"/> for the given analyzer.
         /// </summary>
-        /// <param name="analyzer">Analyzer to get session wide analyzer actions.</param>
         /// <param name="sessionScope">Session scope to store register session wide analyzer actions.</param>
         /// <param name="severityFilter">Severity filter for analysis.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
@@ -198,18 +197,15 @@ internal ImmutableDictionary<DiagnosticAnalyzer, TimeSpan> AnalyzerExecutionTime
         /// Use <see cref="ExecuteCompilationStartActions(ImmutableArray{CompilationStartAnalyzerAction}, HostCompilationStartAnalysisScope, CancellationToken)"/> API
         /// to get execute these actions to get the per-compilation analyzer actions.
         /// </remarks>
-        public void ExecuteInitializeMethod(DiagnosticAnalyzer analyzer, HostSessionStartAnalysisScope sessionScope, SeverityFilter severityFilter, CancellationToken cancellationToken)
+        public void ExecuteInitializeMethod(HostSessionStartAnalysisScope sessionScope, SeverityFilter severityFilter, CancellationToken cancellationToken)
         {
-            if (analyzer != sessionScope.Analyzer)
-                throw new InvalidOperationException();
-
-            var context = new AnalyzerAnalysisContext(analyzer, sessionScope, severityFilter);
+            var context = new AnalyzerAnalysisContext(sessionScope, severityFilter);
 
             // The Initialize method should be run asynchronously in case it is not well behaved, e.g. does not terminate.
             ExecuteAndCatchIfThrows(
-                analyzer,
+                sessionScope.Analyzer,
                 data => data.analyzer.Initialize(data.context),
-                (analyzer, context),
+                (analyzer: sessionScope.Analyzer, context),
                 contextInfo: null,
                 cancellationToken);
         }
@@ -226,7 +222,7 @@ public void ExecuteCompilationStartActions(ImmutableArray<CompilationStartAnalyz
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
-                var context = new AnalyzerCompilationStartAnalysisContext(startAction.Analyzer, compilationScope,
+                var context = new AnalyzerCompilationStartAnalysisContext(compilationScope,
                     Compilation, AnalyzerOptions, _compilationAnalysisValueProviderFactory, cancellationToken);
 
                 ExecuteAndCatchIfThrows(
@@ -242,36 +238,31 @@ public void ExecuteCompilationStartActions(ImmutableArray<CompilationStartAnalyz
         /// Executes the symbol start actions.
         /// </summary>
         /// <param name="symbol">Symbol whose symbol start actions are to be executed.</param>
-        /// <param name="analyzer">Analyzer whose symbol start actions are to be executed.</param>
         /// <param name="actions"><see cref="AnalyzerActions"/> whose symbol start actions are to be executed.</param>
         /// <param name="symbolScope">Symbol scope to store the analyzer actions.</param>
         /// <param name="isGeneratedCodeSymbol">Flag indicating if the symbol being analyzed is generated code.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
         public void ExecuteSymbolStartActions(
             ISymbol symbol,
-            DiagnosticAnalyzer analyzer,
             ImmutableArray<SymbolStartAnalyzerAction> actions,
             HostSymbolStartAnalysisScope symbolScope,
             bool isGeneratedCodeSymbol,
             SyntaxTree? filterTree,
             TextSpan? filterSpan,
             CancellationToken cancellationToken)
         {
-            if (analyzer != symbolScope.Analyzer)
-                throw new InvalidOperationException();
-
-            if (isGeneratedCodeSymbol && _shouldSkipAnalysisOnGeneratedCode(analyzer) ||
-                IsAnalyzerSuppressedForSymbol(analyzer, symbol, cancellationToken))
+            if (isGeneratedCodeSymbol && _shouldSkipAnalysisOnGeneratedCode(symbolScope.Analyzer) ||
+                IsAnalyzerSuppressedForSymbol(symbolScope.Analyzer, symbol, cancellationToken))
             {
                 return;
             }
 
             foreach (var startAction in actions)
             {
-                Debug.Assert(startAction.Analyzer == analyzer);
+                Debug.Assert(startAction.Analyzer == symbolScope.Analyzer);
                 cancellationToken.ThrowIfCancellationRequested();
 
-                var context = new AnalyzerSymbolStartAnalysisContext(startAction.Analyzer, symbolScope,
+                var context = new AnalyzerSymbolStartAnalysisContext(symbolScope,
                     symbol, Compilation, AnalyzerOptions, isGeneratedCodeSymbol, filterTree, filterSpan, cancellationToken);
 
                 ExecuteAndCatchIfThrows(

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerManager.AnalyzerExecutionContext.cs

@@ -91,7 +91,7 @@ static Task<HostSessionStartAnalysisScope> getSessionAnalysisScopeTaskSlowAsync(
                         return Task.Run(() =>
                         {
                             var sessionScope = new HostSessionStartAnalysisScope(context._analyzer);
-                            executor.ExecuteInitializeMethod(context._analyzer, sessionScope, executor.SeverityFilter, cancellationToken);
+                            executor.ExecuteInitializeMethod(sessionScope, executor.SeverityFilter, cancellationToken);
                             return sessionScope;
                         }, cancellationToken);
                     }
@@ -117,11 +117,9 @@ public Task<HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeAsync(
                     {
                         _lazyCompilationScopeTask = Task.Run(() =>
                         {
-                            if (sessionScope.Analyzer != _analyzer)
-                                throw new InvalidOperationException();
-
+                            Debug.Assert(sessionScope.Analyzer == _analyzer);
                             var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope);
-                            analyzerExecutor.ExecuteCompilationStartActions(sessionScope.GetAnalyzerActions(_analyzer).CompilationStartActions, compilationAnalysisScope, cancellationToken);
+                            analyzerExecutor.ExecuteCompilationStartActions(sessionScope.GetAnalyzerActions().CompilationStartActions, compilationAnalysisScope, cancellationToken);
                             return compilationAnalysisScope;
                         }, cancellationToken);
                     }
@@ -161,9 +159,9 @@ public Task<HostSymbolStartAnalysisScope> GetSymbolAnalysisScopeAsync(
                     HostSymbolStartAnalysisScope getSymbolAnalysisScopeCore()
                     {
                         var symbolAnalysisScope = new HostSymbolStartAnalysisScope(_analyzer);
-                        analyzerExecutor.ExecuteSymbolStartActions(symbol, _analyzer, symbolStartActions, symbolAnalysisScope, isGeneratedCodeSymbol, filterTree, filterSpan, cancellationToken);
+                        analyzerExecutor.ExecuteSymbolStartActions(symbol, symbolStartActions, symbolAnalysisScope, isGeneratedCodeSymbol, filterTree, filterSpan, cancellationToken);
 
-                        var symbolEndActions = symbolAnalysisScope.GetAnalyzerActions(_analyzer);
+                        var symbolEndActions = symbolAnalysisScope.GetAnalyzerActions();
                         if (symbolEndActions.SymbolEndActionsCount > 0)
                         {
                             var dependentSymbols = getDependentSymbols();

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerManager.cs

@@ -56,15 +56,11 @@ private Dictionary<DiagnosticAnalyzer, AnalyzerExecutionContext> CreateAnalyzerE
             "https://github.com/dotnet/roslyn/issues/26778",
             OftenCompletesSynchronously = true)]
         private async ValueTask<HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeAsync(
-            DiagnosticAnalyzer analyzer,
             HostSessionStartAnalysisScope sessionScope,
             AnalyzerExecutor analyzerExecutor,
             CancellationToken cancellationToken)
         {
-            if (analyzer != sessionScope.Analyzer)
-                throw new InvalidOperationException();
-
-            var analyzerExecutionContext = GetAnalyzerExecutionContext(analyzer);
+            var analyzerExecutionContext = GetAnalyzerExecutionContext(sessionScope.Analyzer);
             return await GetCompilationAnalysisScopeCoreAsync(sessionScope, analyzerExecutor, analyzerExecutionContext, cancellationToken).ConfigureAwait(false);
         }
 
@@ -172,13 +168,13 @@ private async ValueTask<HostSessionStartAnalysisScope> GetSessionAnalysisScopeCo
         public async ValueTask<AnalyzerActions> GetAnalyzerActionsAsync(DiagnosticAnalyzer analyzer, AnalyzerExecutor analyzerExecutor, CancellationToken cancellationToken)
         {
             var sessionScope = await GetSessionAnalysisScopeAsync(analyzer, analyzerExecutor, cancellationToken).ConfigureAwait(false);
-            if (sessionScope.GetAnalyzerActions(analyzer).CompilationStartActionsCount > 0 && analyzerExecutor.Compilation != null)
+            if (sessionScope.GetAnalyzerActions().CompilationStartActionsCount > 0 && analyzerExecutor.Compilation != null)
             {
-                var compilationScope = await GetCompilationAnalysisScopeAsync(analyzer, sessionScope, analyzerExecutor, cancellationToken).ConfigureAwait(false);
-                return compilationScope.GetAnalyzerActions(analyzer);
+                var compilationScope = await GetCompilationAnalysisScopeAsync(sessionScope, analyzerExecutor, cancellationToken).ConfigureAwait(false);
+                return compilationScope.GetAnalyzerActions();
             }
 
-            return sessionScope.GetAnalyzerActions(analyzer);
+            return sessionScope.GetAnalyzerActions();
         }
 
         /// <summary>
@@ -202,7 +198,7 @@ public async ValueTask<AnalyzerActions> GetPerSymbolAnalyzerActionsAsync(
                 if (filteredSymbolStartActions.Length > 0)
                 {
                     var symbolScope = await GetSymbolAnalysisScopeAsync(symbol, isGeneratedCodeSymbol, filterTree, filterSpan, analyzer, filteredSymbolStartActions, analyzerExecutor, cancellationToken).ConfigureAwait(false);
-                    return symbolScope.GetAnalyzerActions(analyzer);
+                    return symbolScope.GetAnalyzerActions();
                 }
             }
 
@@ -237,7 +233,7 @@ ImmutableArray<SymbolStartAnalyzerAction> getFilteredActionsByKind(ImmutableArra
         public async Task<bool> IsConcurrentAnalyzerAsync(DiagnosticAnalyzer analyzer, AnalyzerExecutor analyzerExecutor, CancellationToken cancellationToken)
         {
             var sessionScope = await GetSessionAnalysisScopeAsync(analyzer, analyzerExecutor, cancellationToken).ConfigureAwait(false);
-            return sessionScope.IsConcurrentAnalyzer(analyzer);
+            return sessionScope.IsConcurrentAnalyzer();
         }
 
         /// <summary>
@@ -247,7 +243,7 @@ public async Task<bool> IsConcurrentAnalyzerAsync(DiagnosticAnalyzer analyzer, A
         public async Task<GeneratedCodeAnalysisFlags> GetGeneratedCodeAnalysisFlagsAsync(DiagnosticAnalyzer analyzer, AnalyzerExecutor analyzerExecutor, CancellationToken cancellationToken)
         {
             var sessionScope = await GetSessionAnalysisScopeAsync(analyzer, analyzerExecutor, cancellationToken).ConfigureAwait(false);
-            return sessionScope.GetGeneratedCodeAnalysisFlags(analyzer);
+            return sessionScope.GetGeneratedCodeAnalysisFlags();
         }
 
         /// <summary>