Remove type parameter from RegisterCodeBlockEndAction methods. (changeset 1398588)

src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.cs

-// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System;
 using System.Collections.Generic;
@@ -658,7 +658,7 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
             public override void Initialize(AnalysisContext context)
             {
                 context.RegisterCodeBlockStartAction<SyntaxKind>(new NodeAnalyzer().Initialize);
-                context.RegisterCodeBlockEndAction<SyntaxKind>(OnCodeBlockEnded);
+                context.RegisterCodeBlockEndAction(OnCodeBlockEnded);
             }
 
             public static void OnCodeBlockEnded(CodeBlockEndAnalysisContext context)

src/Compilers/Core/AnalyzerDriver/AnalyzerDriverHelper.cs

@@ -302,7 +302,7 @@ internal class AnalyzerDriverHelper
             VerifyArguments(declarationsInNode, getKind, semanticModel, actions, analyzerOptions, addDiagnostic, continueOnAnalyzerException);
 
             var codeBlockStartActions = actions.GetCodeBlockStartActions<TLanguageKindEnum>();
-            var codeBlockEndActions = actions.GetCodeBlockEndActions<TLanguageKindEnum>();
+            var codeBlockEndActions = actions.CodeBlockEndActions;
 
             if (!codeBlockStartActions.Any() && !codeBlockEndActions.Any())
             {
@@ -325,7 +325,7 @@ internal class AnalyzerDriverHelper
 
         internal static void ExecuteCodeBlockActions<TLanguageKindEnum>(
             IEnumerable<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> codeBlockStartActions,
-            IEnumerable<CodeBlockEndAnalyzerAction<TLanguageKindEnum>> codeBlockEndActions,
+            IEnumerable<CodeBlockEndAnalyzerAction> codeBlockEndActions,
             SyntaxNode declaredNode,
             ISymbol declaredSymbol,
             ImmutableArray<SyntaxNode> executableCodeBlocks,
@@ -344,7 +344,7 @@ internal class AnalyzerDriverHelper
             Debug.Assert(executableCodeBlocks.Any());
 
             // Compute the sets of code block end and stateful syntax node actions.
-            var endedActions = PooledHashSet<CodeBlockEndAnalyzerAction<TLanguageKindEnum>>.GetInstance();
+            var endedActions = PooledHashSet<CodeBlockEndAnalyzerAction>.GetInstance();
             var executableNodeActions = ArrayBuilder<SyntaxNodeAnalyzerAction<TLanguageKindEnum>>.GetInstance();
 
             // Include the stateless code block actions.

src/Compilers/Core/AnalyzerDriver/DiagnosticAnalyzerAction.cs

@@ -114,7 +114,7 @@ public CodeBlockStartAnalyzerAction(Action<CodeBlockStartAnalysisContext<TLangua
         public Action<CodeBlockStartAnalysisContext<TLanguageKindEnum>> Action { get { return this.action; } }
     }
 
-    internal sealed class CodeBlockEndAnalyzerAction<TLanguageKindEnum> : AnalyzerAction where TLanguageKindEnum : struct
+    internal sealed class CodeBlockEndAnalyzerAction : AnalyzerAction
     {
         private readonly Action<CodeBlockEndAnalysisContext> action;
 

src/Compilers/Core/AnalyzerDriver/DiagnosticStartAnalysisScope.cs

@@ -58,10 +58,10 @@ public override void RegisterCodeBlockStartAction<TLanguageKindEnum>(Action<Code
             this.scope.RegisterCodeBlockStartAction<TLanguageKindEnum>(this.analyzer, action);
         }
 
-        public override void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBlockEndAnalysisContext> action)
+        public override void RegisterCodeBlockEndAction(Action<CodeBlockEndAnalysisContext> action)
         {
             DiagnosticAnalysisContextHelpers.VerifyArguments(action);
-            this.scope.RegisterCodeBlockEndAction<TLanguageKindEnum>(this.analyzer, action);
+            this.scope.RegisterCodeBlockEndAction(this.analyzer, action);
         }
 
         public override void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
@@ -111,9 +111,9 @@ public override void RegisterCodeBlockStartAction<TLanguageKindEnum>(Action<Code
             this.scope.RegisterCodeBlockStartAction<TLanguageKindEnum>(this.analyzer, action);
         }
 
-        public override void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBlockEndAnalysisContext> action)
+        public override void RegisterCodeBlockEndAction(Action<CodeBlockEndAnalysisContext> action)
         {
-            this.scope.RegisterCodeBlockEndAction<TLanguageKindEnum>(this.analyzer, action);
+            this.scope.RegisterCodeBlockEndAction(this.analyzer, action);
         }
 
         public override void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
@@ -206,28 +206,26 @@ public override ImmutableArray<SymbolAnalyzerAction> SymbolActions
             get { return base.SymbolActions.AddRange(this.sessionScope.SymbolActions); }
         }
 
-        public override bool HasCodeBlockStartActions<TLanguageKindEnum>()
+        public override ImmutableArray<CodeBlockEndAnalyzerAction> CodeBlockEndActions
         {
-            return
-                base.HasCodeBlockStartActions<TLanguageKindEnum>() ||
-                this.sessionScope.HasCodeBlockStartActions<TLanguageKindEnum>();
+            get { return base.CodeBlockEndActions.AddRange(this.sessionScope.CodeBlockEndActions); }
         }
 
-        public override ImmutableArray<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> GetCodeBlockStartActions<TLanguageKindEnum>()
+        public override bool HasCodeBlockEndActions
         {
-            return base.GetCodeBlockStartActions<TLanguageKindEnum>().AddRange(this.sessionScope.GetCodeBlockStartActions<TLanguageKindEnum>());
+            get { return base.HasCodeBlockEndActions || this.sessionScope.HasCodeBlockEndActions; }
         }
 
-        public override bool HasCodeBlockEndActions<TLanguageKindEnum>()
+        public override bool HasCodeBlockStartActions<TLanguageKindEnum>()
         {
             return
-                base.HasCodeBlockEndActions<TLanguageKindEnum>() ||
-                this.sessionScope.HasCodeBlockEndActions<TLanguageKindEnum>();
+                base.HasCodeBlockStartActions<TLanguageKindEnum>() ||
+                this.sessionScope.HasCodeBlockStartActions<TLanguageKindEnum>();
         }
 
-        public override ImmutableArray<CodeBlockEndAnalyzerAction<TLanguageKindEnum>> GetCodeBlockEndActions<TLanguageKindEnum>()
+        public override ImmutableArray<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> GetCodeBlockStartActions<TLanguageKindEnum>()
         {
-            return base.GetCodeBlockEndActions<TLanguageKindEnum>().AddRange(this.sessionScope.GetCodeBlockEndActions<TLanguageKindEnum>());
+            return base.GetCodeBlockStartActions<TLanguageKindEnum>().AddRange(this.sessionScope.GetCodeBlockStartActions<TLanguageKindEnum>());
         }
 
         public override ImmutableArray<SyntaxNodeAnalyzerAction<TLanguageKindEnum>> GetSyntaxNodeActions<TLanguageKindEnum>()
@@ -259,10 +257,10 @@ public override AnalyzerActions GetAnalyzerActions(DiagnosticAnalyzer analyzer)
     /// </summary>
     internal sealed class HostCodeBlockStartAnalysisScope<TLanguageKindEnum> where TLanguageKindEnum : struct
     {
-        private ImmutableArray<CodeBlockEndAnalyzerAction<TLanguageKindEnum>> codeBlockEndActions = ImmutableArray<CodeBlockEndAnalyzerAction<TLanguageKindEnum>>.Empty;
+        private ImmutableArray<CodeBlockEndAnalyzerAction> codeBlockEndActions = ImmutableArray<CodeBlockEndAnalyzerAction>.Empty;
         private ImmutableArray<SyntaxNodeAnalyzerAction<TLanguageKindEnum>> syntaxNodeActions = ImmutableArray<SyntaxNodeAnalyzerAction<TLanguageKindEnum>>.Empty;
 
-        public ImmutableArray<CodeBlockEndAnalyzerAction<TLanguageKindEnum>> CodeBlockEndActions
+        public ImmutableArray<CodeBlockEndAnalyzerAction> CodeBlockEndActions
         {
             get { return this.codeBlockEndActions; }
         }
@@ -278,7 +276,7 @@ internal HostCodeBlockStartAnalysisScope()
 
         public void RegisterCodeBlockEndAction(DiagnosticAnalyzer analyzer, Action<CodeBlockEndAnalysisContext> action)
         {
-            this.codeBlockEndActions = this.codeBlockEndActions.Add(new CodeBlockEndAnalyzerAction<TLanguageKindEnum>(action, analyzer));
+            this.codeBlockEndActions = this.codeBlockEndActions.Add(new CodeBlockEndAnalyzerAction(action, analyzer));
         }
 
         public void RegisterSyntaxNodeAction(DiagnosticAnalyzer analyzer, Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
@@ -294,7 +292,7 @@ internal abstract class HostAnalysisScope
         private ImmutableArray<SyntaxTreeAnalyzerAction> syntaxTreeActions = ImmutableArray<SyntaxTreeAnalyzerAction>.Empty;
         private ImmutableArray<SymbolAnalyzerAction> symbolActions = ImmutableArray<SymbolAnalyzerAction>.Empty;
         private ImmutableArray<AnalyzerAction> codeBlockStartActions = ImmutableArray<AnalyzerAction>.Empty;
-        private ImmutableArray<AnalyzerAction> codeBlockEndActions = ImmutableArray<AnalyzerAction>.Empty;
+        private ImmutableArray<CodeBlockEndAnalyzerAction> codeBlockEndActions = ImmutableArray<CodeBlockEndAnalyzerAction>.Empty;
         private ImmutableArray<AnalyzerAction> syntaxNodeActions = ImmutableArray<AnalyzerAction>.Empty;
         private readonly Dictionary<DiagnosticAnalyzer, AnalyzerActions> analyzerActions = new Dictionary<DiagnosticAnalyzer, AnalyzerActions>();
 
@@ -318,24 +316,24 @@ public virtual ImmutableArray<SymbolAnalyzerAction> SymbolActions
             get { return this.symbolActions; }
         }
 
-        public virtual bool HasCodeBlockStartActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
+        public virtual ImmutableArray<CodeBlockEndAnalyzerAction> CodeBlockEndActions
         {
-            return this.codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().Any();
+            get { return this.codeBlockEndActions; }
         }
 
-        public virtual ImmutableArray<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> GetCodeBlockStartActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
+        public virtual bool HasCodeBlockEndActions
         {
-            return this.codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().AsImmutable();
+            get { return this.codeBlockEndActions.Any(); }
         }
 
-        public virtual bool HasCodeBlockEndActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
+        public virtual bool HasCodeBlockStartActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
         {
-            return this.codeBlockEndActions.OfType<CodeBlockEndAnalyzerAction<TLanguageKindEnum>>().Any();
+            return this.codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().Any();
         }
 
-        public virtual ImmutableArray<CodeBlockEndAnalyzerAction<TLanguageKindEnum>> GetCodeBlockEndActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
+        public virtual ImmutableArray<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> GetCodeBlockStartActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
         {
-            return this.codeBlockEndActions.OfType<CodeBlockEndAnalyzerAction<TLanguageKindEnum>>().AsImmutable();
+            return this.codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().AsImmutable();
         }
 
         public virtual ImmutableArray<SyntaxNodeAnalyzerAction<TLanguageKindEnum>> GetSyntaxNodeActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
@@ -385,9 +383,9 @@ public void RegisterSymbolAction(DiagnosticAnalyzer analyzer, Action<SymbolAnaly
             this.codeBlockStartActions = this.codeBlockStartActions.Add(analyzerAction);
         }
 
-        public void RegisterCodeBlockEndAction<TLanguageKindEnum>(DiagnosticAnalyzer analyzer, Action<CodeBlockEndAnalysisContext> action) where TLanguageKindEnum : struct
+        public void RegisterCodeBlockEndAction(DiagnosticAnalyzer analyzer, Action<CodeBlockEndAnalysisContext> action)
         {
-            CodeBlockEndAnalyzerAction<TLanguageKindEnum> analyzerAction = new CodeBlockEndAnalyzerAction<TLanguageKindEnum>(action, analyzer);
+            CodeBlockEndAnalyzerAction analyzerAction = new CodeBlockEndAnalyzerAction(action, analyzer);
             this.GetOrCreateAnalyzerActions(analyzer).AddCodeBlockEndAction(analyzerAction);
             this.codeBlockEndActions = this.codeBlockEndActions.Add(analyzerAction);
         }
@@ -427,7 +425,7 @@ internal sealed class AnalyzerActions
         private ImmutableArray<SemanticModelAnalyzerAction> semanticModelActions = ImmutableArray<SemanticModelAnalyzerAction>.Empty;
         private ImmutableArray<SymbolAnalyzerAction> symbolActions = ImmutableArray<SymbolAnalyzerAction>.Empty;
         private ImmutableArray<AnalyzerAction> codeBlockStartActions = ImmutableArray<AnalyzerAction>.Empty;
-        private ImmutableArray<AnalyzerAction> codeBlockEndActions = ImmutableArray<AnalyzerAction>.Empty;
+        private ImmutableArray<CodeBlockEndAnalyzerAction> codeBlockEndActions = ImmutableArray<CodeBlockEndAnalyzerAction>.Empty;
         private ImmutableArray<AnalyzerAction> syntaxNodeActions = ImmutableArray<AnalyzerAction>.Empty;
 
         internal AnalyzerActions()
@@ -468,14 +466,14 @@ internal ImmutableArray<SymbolAnalyzerAction> SymbolActions
             get { return this.symbolActions; }
         }
 
-        internal ImmutableArray<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> GetCodeBlockStartActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
+        internal ImmutableArray<CodeBlockEndAnalyzerAction> CodeBlockEndActions
         {
-            return this.codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().ToImmutableArray();
+            get { return this.codeBlockEndActions; }
         }
 
-        internal ImmutableArray<CodeBlockEndAnalyzerAction<TLanguageKindEnum>> GetCodeBlockEndActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
+        internal ImmutableArray<CodeBlockStartAnalyzerAction<TLanguageKindEnum>> GetCodeBlockStartActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
         {
-            return this.codeBlockEndActions.OfType<CodeBlockEndAnalyzerAction<TLanguageKindEnum>>().ToImmutableArray();
+            return this.codeBlockStartActions.OfType<CodeBlockStartAnalyzerAction<TLanguageKindEnum>>().ToImmutableArray();
         }
 
         internal ImmutableArray<SyntaxNodeAnalyzerAction<TLanguageKindEnum>> GetSyntaxNodeActions<TLanguageKindEnum>() where TLanguageKindEnum : struct
@@ -513,7 +511,7 @@ internal void AddSymbolAction(SymbolAnalyzerAction action)
             this.codeBlockStartActions = this.codeBlockStartActions.Add(action);
         }
 
-        internal void AddCodeBlockEndAction<TLanguageKindEnum>(CodeBlockEndAnalyzerAction<TLanguageKindEnum> action) where TLanguageKindEnum : struct
+        internal void AddCodeBlockEndAction(CodeBlockEndAnalyzerAction action)
         {
             this.codeBlockEndActions = this.codeBlockEndActions.Add(action);
         }

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

@@ -772,7 +772,7 @@ protected override async Task AnalyzeDeclaringReferenceAsync(SymbolDeclaredCompi
 
             var statelessNodeActionsByKind = this.NodeActionsByKind;
             var executeSyntaxNodeActions = statelessNodeActionsByKind.Any();
-            var executeCodeBlockActions = AnalyzerDriverHelper.CanHaveExecutableCodeBlock(symbol) && (this.compilationAnalysisScope.HasCodeBlockStartActions<TLanguageKindEnum>() || this.compilationAnalysisScope.HasCodeBlockEndActions<TLanguageKindEnum>());
+            var executeCodeBlockActions = AnalyzerDriverHelper.CanHaveExecutableCodeBlock(symbol) && (this.compilationAnalysisScope.HasCodeBlockStartActions<TLanguageKindEnum>() || this.compilationAnalysisScope.HasCodeBlockEndActions);
 
             if (executeSyntaxNodeActions || executeCodeBlockActions)
             {
@@ -936,7 +936,7 @@ protected override async Task AnalyzeDeclaringReferenceAsync(SymbolDeclaredCompi
         {
             AnalyzerDriverHelper.ExecuteCodeBlockActions(
                 compilationScope.GetCodeBlockStartActions<TLanguageKindEnum>(),
-                compilationScope.GetCodeBlockEndActions<TLanguageKindEnum>(),
+                compilationScope.CodeBlockEndActions,
                 declaredNode,
                 declaredSymbol,
                 executableCodeBlocks,

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

@@ -93,9 +93,8 @@ public void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params Sy
         /// Register an action to be executed at the end of semantic analysis of a method body or an expression appearing outside a method body.
         /// A code block end action reports <see cref="Diagnostic"/>s about code blocks.
         /// </summary>
-        /// <typeparam name="TLanguageKindEnum">Enum type giving the syntax node kinds of the source language for which the action applies.</typeparam>
         /// <param name="action">Action to be executed at the end of semantic analysis of a code block.</param>
-        public abstract void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBlockEndAnalysisContext> action) where TLanguageKindEnum : struct;
+        public abstract void RegisterCodeBlockEndAction(Action<CodeBlockEndAnalysisContext> action);
 
         /// <summary>
         /// Register an action to be executed at completion of parsing of a code document.
@@ -230,9 +229,8 @@ public void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params Sy
         /// Register an action to be executed at the end of semantic analysis of a method body or an expression appearing outside a method body.
         /// A code block end action reports <see cref="Diagnostic"/>s about code blocks.
         /// </summary>
-        /// <typeparam name="TLanguageKindEnum">Enum type giving the syntax node kinds of the source language for which the action applies.</typeparam>
         /// <param name="action">Action to be executed at the end of semantic analysis of a code block.</param>
-        public abstract void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBlockEndAnalysisContext> action) where TLanguageKindEnum : struct;
+        public abstract void RegisterCodeBlockEndAction(Action<CodeBlockEndAnalysisContext> action);
 
         /// <summary>
         /// Register an action to be executed at completion of parsing of a code document.

src/Compilers/Test/Utilities/Core2/Diagnostics/TestDiagnosticAnalyzer.cs

@@ -48,7 +48,7 @@ public override void Initialize(AnalysisContext context)
 
             context.RegisterCompilationEndAction(this.AnalyzeCompilation);
             context.RegisterSemanticModelAction(this.AnalyzeSemanticModel);
-            context.RegisterCodeBlockEndAction<TLanguageKindEnum>(this.AnalyzeCodeBlock);
+            context.RegisterCodeBlockEndAction(this.AnalyzeCodeBlock);
             context.RegisterSymbolAction(this.AnalyzeSymbol, AllSymbolKinds.ToArray());
             context.RegisterSyntaxTreeAction(this.AnalyzeSyntaxTree);
             context.RegisterSyntaxNodeAction<TLanguageKindEnum>(this.AnalyzeNode, AllSyntaxKinds.ToArray());

src/Compilers/VisualBasic/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.vb

-' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+' Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 Imports System.Collections.Immutable
 Imports System.Globalization
@@ -532,7 +532,7 @@ End Namespace
             End Property
 
             Public Overrides Sub Initialize(context As AnalysisContext)
-                context.RegisterCodeBlockEndAction(Of SyntaxKind)(AddressOf OnCodeBlock)
+                context.RegisterCodeBlockEndAction(AddressOf OnCodeBlock)
             End Sub
 
             Private Shared Sub OnCodeBlock(context As CodeBlockEndAnalysisContext)