Fix for bug 1087195: Add overloads to RegisterSymbolAction and...

Fix for bug 1087195: Add overloads to RegisterSymbolAction and RegisterSyntaxNodeAction that take ImmutableArray for symbol/syntax kinds (changeset 1378545)

Src/Compilers/Core/Portable/CodeAnalysis.csproj

@@ -96,6 +96,7 @@
     <Compile Include="Compilation\SymbolFilter.cs" />
     <Compile Include="DiagnosticAnalyzer\CompilerDiagnosticAnalyzer.CompilationAnalyzer.cs" />
     <Compile Include="DiagnosticAnalyzer\CompilerDiagnosticAnalyzer.cs" />
+    <Compile Include="DiagnosticAnalyzer\DiagnosticAnalysisContextHelpers.cs" />
     <Compile Include="Diagnostic\LocalizableResourceString.cs" />
     <Compile Include="Diagnostic\LocalizableString.cs" />
     <Compile Include="Emit\DebugInformationFormat.cs" />

Src/Compilers/Core/Portable/DiagnosticAnalyzer/DiagnosticAnalysisContextHelpers.cs

+// Copyright (c) Microsoft Open Technologies, Inc.  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.Immutable;
+using System.Threading;
+
+namespace Microsoft.CodeAnalysis.Diagnostics
+{
+    internal static class DiagnosticAnalysisContextHelpers
+    {
+        internal static void VerifyArguments<TContext>(Action<TContext> action)
+            where TContext : struct
+        {
+            VerifyAction(action);
+        }
+
+        internal static void VerifyArguments<TContext>(Action<TContext> action, ImmutableArray<SymbolKind> symbolKinds)
+            where TContext : struct
+        {
+            VerifyAction(action);
+            VerifySymbolKinds(symbolKinds);
+        }
+
+        internal static void VerifyArguments<TContext, TLanguageKindEnum>(Action<TContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
+            where TContext : struct
+            where TLanguageKindEnum : struct
+        {
+            VerifyAction(action);
+            VerifySyntaxKinds(syntaxKinds);
+        }
+
+        internal static void VerifyArguments(Diagnostic diagnostic)
+        {
+            if (diagnostic == null)
+            {
+                throw new ArgumentNullException(nameof(diagnostic));
+            }
+        }
+
+        private static void VerifyAction<TContext>(Action<TContext> action)
+            where TContext : struct
+        {
+            if (action == null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+        }
+
+        private static void VerifySymbolKinds(ImmutableArray<SymbolKind> symbolKinds)
+        {
+            if (symbolKinds.IsDefault)
+            {
+                throw new ArgumentNullException(nameof(symbolKinds));
+            }
+
+            if (symbolKinds.IsEmpty)
+            {
+                throw new ArgumentException(CodeAnalysisResources.ArgumentCannotBeEmpty, nameof(symbolKinds));
+            }
+        }
+
+        private static void VerifySyntaxKinds<TLanguageKindEnum>(ImmutableArray<TLanguageKindEnum> syntaxKinds)
+            where TLanguageKindEnum : struct
+        {
+            if (syntaxKinds.IsDefault)
+            {
+                throw new ArgumentNullException(nameof(syntaxKinds));
+            }
+
+            if (syntaxKinds.IsEmpty)
+            {
+                throw new ArgumentException(CodeAnalysisResources.ArgumentCannotBeEmpty, nameof(syntaxKinds));
+            }
+        }
+    }
+}

Src/Compilers/Core/Portable/DiagnosticAnalyzer/DiagnosticStartAnalysisScope.cs

@@ -16,13 +16,13 @@ internal abstract class SessionStartAnalysisScope
         public abstract void RegisterCompilationEndAction(Action<CompilationEndAnalysisContext> action);
 
         public abstract void RegisterSemanticModelAction(Action<SemanticModelAnalysisContext> action);
-        public abstract void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds);
+        public abstract void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds);
 
         public abstract void RegisterCodeBlockStartAction<TLanguageKindEnum>(Action<CodeBlockStartAnalysisContext<TLanguageKindEnum>> action) where TLanguageKindEnum : struct;
         public abstract void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBlockEndAnalysisContext> action) where TLanguageKindEnum : struct;
 
         public abstract void RegisterSyntaxTreeAction(Action<SyntaxTreeAnalysisContext> action);
-        public abstract void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds) where TLanguageKindEnum : struct;
+        public abstract void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds) where TLanguageKindEnum : struct;
     }
 
     /// <summary>
@@ -33,13 +33,13 @@ internal abstract class CompilationStartAnalysisScope
         public abstract void RegisterCompilationEndAction(Action<CompilationEndAnalysisContext> action);
 
         public abstract void RegisterSemanticModelAction(Action<SemanticModelAnalysisContext> action);
-        public abstract void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds);
+        public abstract void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds);
 
         public abstract void RegisterCodeBlockStartAction<TLanguageKindEnum>(Action<CodeBlockStartAnalysisContext<TLanguageKindEnum>> action) where TLanguageKindEnum : struct;
         public abstract void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBlockEndAnalysisContext> action) where TLanguageKindEnum : struct;
 
         public abstract void RegisterSyntaxTreeAction(Action<SyntaxTreeAnalysisContext> action);
-        public abstract void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds) where TLanguageKindEnum : struct;
+        public abstract void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds) where TLanguageKindEnum : struct;
     }
 
     /// <summary>
@@ -49,7 +49,7 @@ internal abstract class CodeBlockStartAnalysisScope<TLanguageKindEnum> where TLa
     {
         public abstract void RegisterCodeBlockEndAction(Action<CodeBlockEndAnalysisContext> action);
 
-        public abstract void RegisterSyntaxNodeAction(Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds);
+        public abstract void RegisterSyntaxNodeAction(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds);
     }
 
     /// <summary>
@@ -86,7 +86,7 @@ public override void RegisterSemanticModelAction(Action<SemanticModelAnalysisCon
             this.scope.RegisterSemanticModelAction(this.analyzer, action);
         }
 
-        public override void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds)
+        public override void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds)
         {
             this.scope.RegisterSymbolAction(this.analyzer, action, symbolKinds);
         }
@@ -101,9 +101,9 @@ public override void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBl
             this.scope.RegisterCodeBlockEndAction<TLanguageKindEnum>(this.analyzer, action);
         }
 
-        public override void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds)
+        public override void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
         {
-            this.scope.RegisterSyntaxNodeAction<TLanguageKindEnum>(this.analyzer, action, syntaxKinds);
+            this.scope.RegisterSyntaxNodeAction(this.analyzer, action, syntaxKinds);
         }
     }
 
@@ -136,7 +136,7 @@ public override void RegisterSemanticModelAction(Action<SemanticModelAnalysisCon
             this.scope.RegisterSemanticModelAction(this.analyzer, action);
         }
 
-        public override void RegisterSymbolAction(Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds)
+        public override void RegisterSymbolAction(Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds)
         {
             this.scope.RegisterSymbolAction(this.analyzer, action, symbolKinds);
         }
@@ -151,9 +151,9 @@ public override void RegisterCodeBlockEndAction<TLanguageKindEnum>(Action<CodeBl
             this.scope.RegisterCodeBlockEndAction<TLanguageKindEnum>(this.analyzer, action);
         }
 
-        public override void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds)
+        public override void RegisterSyntaxNodeAction<TLanguageKindEnum>(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
         {
-            this.scope.RegisterSyntaxNodeAction<TLanguageKindEnum>(this.analyzer, action, syntaxKinds);
+            this.scope.RegisterSyntaxNodeAction(this.analyzer, action, syntaxKinds);
         }
     }
 
@@ -176,7 +176,7 @@ public override void RegisterCodeBlockEndAction(Action<CodeBlockEndAnalysisConte
             this.scope.RegisterCodeBlockEndAction(this.analyzer, action);
         }
 
-        public override void RegisterSyntaxNodeAction(Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds)
+        public override void RegisterSyntaxNodeAction(Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
         {
             this.scope.RegisterSyntaxNodeAction(this.analyzer, action, syntaxKinds);
         }
@@ -309,9 +309,9 @@ public void RegisterCodeBlockEndAction(DiagnosticAnalyzer analyzer, Action<CodeB
             this.codeBlockEndActions = this.codeBlockEndActions.Add(new CodeBlockEndAnalyzerAction<TLanguageKindEnum>(action, analyzer));
         }
 
-        public void RegisterSyntaxNodeAction(DiagnosticAnalyzer analyzer, Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds)
+        public void RegisterSyntaxNodeAction(DiagnosticAnalyzer analyzer, Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
         {
-            this.syntaxNodeActions = this.syntaxNodeActions.Add(new SyntaxNodeAnalyzerAction<TLanguageKindEnum>(action, ImmutableArray.Create<TLanguageKindEnum>(syntaxKinds), analyzer));
+            this.syntaxNodeActions = this.syntaxNodeActions.Add(new SyntaxNodeAnalyzerAction<TLanguageKindEnum>(action, syntaxKinds, analyzer));
         }
     }
 
@@ -399,9 +399,9 @@ public void RegisterSyntaxTreeAction(DiagnosticAnalyzer analyzer, Action<SyntaxT
             this.syntaxTreeActions = this.syntaxTreeActions.Add(analyzerAction);
         }
 
-        public void RegisterSymbolAction(DiagnosticAnalyzer analyzer, Action<SymbolAnalysisContext> action, params SymbolKind[] symbolKinds)
+        public void RegisterSymbolAction(DiagnosticAnalyzer analyzer, Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds)
         {
-            SymbolAnalyzerAction analyzerAction = new SymbolAnalyzerAction(action, ImmutableArray.Create<SymbolKind>(symbolKinds), analyzer);
+            SymbolAnalyzerAction analyzerAction = new SymbolAnalyzerAction(action, symbolKinds, analyzer);
             this.GetOrCreateAnalyzerActions(analyzer).AddSymbolAction(analyzerAction);
             this.symbolActions = this.symbolActions.Add(analyzerAction);
         }
@@ -420,9 +420,9 @@ public void RegisterSymbolAction(DiagnosticAnalyzer analyzer, Action<SymbolAnaly
             this.codeBlockEndActions = this.codeBlockEndActions.Add(analyzerAction);
         }
 
-        public void RegisterSyntaxNodeAction<TLanguageKindEnum>(DiagnosticAnalyzer analyzer, Action<SyntaxNodeAnalysisContext> action, params TLanguageKindEnum[] syntaxKinds) where TLanguageKindEnum : struct
+        public void RegisterSyntaxNodeAction<TLanguageKindEnum>(DiagnosticAnalyzer analyzer, Action<SyntaxNodeAnalysisContext> action, ImmutableArray<TLanguageKindEnum> syntaxKinds) where TLanguageKindEnum : struct
         {
-            SyntaxNodeAnalyzerAction<TLanguageKindEnum> analyzerAction = new SyntaxNodeAnalyzerAction<TLanguageKindEnum>(action, ImmutableArray.Create<TLanguageKindEnum>(syntaxKinds), analyzer);
+            SyntaxNodeAnalyzerAction<TLanguageKindEnum> analyzerAction = new SyntaxNodeAnalyzerAction<TLanguageKindEnum>(action, syntaxKinds, analyzer);
             this.GetOrCreateAnalyzerActions(analyzer).AddSyntaxNodeAction(analyzerAction);
             this.syntaxNodeActions = this.syntaxNodeActions.Add(analyzerAction);
         }