Move common code up to base class.

src/Features/CSharp/Portable/AddBraces/CSharpAddBracesDiagnosticAnalyzer.cs

@@ -40,10 +40,7 @@ internal sealed class CSharpAddBracesDiagnosticAnalyzer : DiagnosticAnalyzer, IB
                 SyntaxKind.LockStatement);
 
         public override void Initialize(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeNode, s_syntaxKindsOfInterest);
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeNode, s_syntaxKindsOfInterest);
 
         public DiagnosticAnalyzerCategory GetAnalyzerCategory() => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
 

src/Features/CSharp/Portable/InlineDeclaration/CSharpInlineDeclarationDiagnosticAnalyzer.cs

@@ -37,10 +37,7 @@ public DiagnosticAnalyzerCategory GetAnalyzerCategory()
         public bool OpenFileOnly(Workspace workspace) => false;
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeSyntaxNode, SyntaxKind.Argument);
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeSyntaxNode, SyntaxKind.Argument);
 
         private void AnalyzeSyntaxNode(SyntaxNodeAnalysisContext context)
         {

src/Features/CSharp/Portable/InvokeDelegateWithConditionalAccess/InvokeDelegateWithConditionalAccessAnalyzer.cs

@@ -29,10 +29,7 @@ public InvokeDelegateWithConditionalAccessAnalyzer()
         public bool OpenFileOnly(Workspace workspace) => false;
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IfStatement);
-        }
+            => context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IfStatement);
 
         private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
         {

src/Features/CSharp/Portable/UseExpressionBody/AbstractUseExpressionBodyDiagnosticAnalyzer.cs

@@ -37,10 +37,7 @@ internal abstract class AbstractUseExpressionBodyDiagnosticAnalyzer<TDeclaration
         public DiagnosticAnalyzerCategory GetAnalyzerCategory() => DiagnosticAnalyzerCategory.SemanticDocumentAnalysis;
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeSyntax, _syntaxKinds);
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, _syntaxKinds);
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         {

src/Features/CSharp/Portable/UsePatternMatching/CSharpAsAndNullCheckDiagnosticAnalyzer.cs

@@ -32,10 +32,7 @@ public CSharpAsAndNullCheckDiagnosticAnalyzer()
         }
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IfStatement);
-        }
+            => context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IfStatement);
 
         private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
         {

src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckDiagnosticAnalyzer.cs

@@ -38,10 +38,7 @@ public CSharpIsAndCastCheckDiagnosticAnalyzer()
         }
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IsExpression);
-        }
+            => context.RegisterSyntaxNodeAction(SyntaxNodeAction, SyntaxKind.IsExpression);
 
         private void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
         {

src/Features/Core/Portable/CodeStyle/AbstractCodeStyleDiagnosticAnalyzer.cs

@@ -74,6 +74,8 @@ public sealed override void Initialize(AnalysisContext context)
         {
             // Code style analyzers should not run on generated code.
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+
             InitializeWorker(context);
         }
 

src/Features/Core/Portable/PopulateSwitch/PopulateSwitchDiagnosticAnalyzer.cs

@@ -28,13 +28,14 @@ internal sealed class PopulateSwitchDiagnosticAnalyzer : DiagnosticAnalyzer, IBu
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(s_descriptor);
         public bool OpenFileOnly(Workspace workspace) => false;
 
-        public override void Initialize(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
+        private static MethodInfo s_registerMethod = typeof(AnalysisContext).GetTypeInfo().GetDeclaredMethod("RegisterOperationActionImmutableArrayInternal");
 
-            var internalMethod = typeof(AnalysisContext).GetTypeInfo().GetDeclaredMethod("RegisterOperationActionImmutableArrayInternal");
-            internalMethod.Invoke(context, new object[] { new Action<OperationAnalysisContext>(AnalyzeOperation), ImmutableArray.Create(OperationKind.SwitchStatement) });
-        }
+        public override void Initialize(AnalysisContext context)
+            => s_registerMethod.Invoke(context, new object[]
+               {
+                   new Action<OperationAnalysisContext>(AnalyzeOperation),
+                   ImmutableArray.Create(OperationKind.SwitchStatement)
+               });
 
         private void AnalyzeOperation(OperationAnalysisContext context)
         {

src/Features/Core/Portable/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs

@@ -37,19 +37,16 @@ internal abstract class AbstractUseAutoPropertyAnalyzer<TPropertyDeclaration, TF
         protected abstract SyntaxNode GetNodeToFade(TFieldDeclaration fieldDeclaration, TVariableDeclarator variableDeclarator);
 
         public sealed override void Initialize(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterCompilationStartAction(csac =>
-            {
-                var analysisResults = new ConcurrentBag<AnalysisResult>();
-                var ineligibleFields = new ConcurrentBag<IFieldSymbol>();
-
-                csac.RegisterSymbolAction(sac => AnalyzeProperty(analysisResults, sac), SymbolKind.Property);
-                RegisterIneligibleFieldsAction(csac, ineligibleFields);
-
-                csac.RegisterCompilationEndAction(cac => Process(analysisResults, ineligibleFields, cac));
-            });
-        }
+            => context.RegisterCompilationStartAction(csac =>
+               {
+                   var analysisResults = new ConcurrentBag<AnalysisResult>();
+                   var ineligibleFields = new ConcurrentBag<IFieldSymbol>();
+               
+                   csac.RegisterSymbolAction(sac => AnalyzeProperty(analysisResults, sac), SymbolKind.Property);
+                   RegisterIneligibleFieldsAction(csac, ineligibleFields);
+               
+                   csac.RegisterCompilationEndAction(cac => Process(analysisResults, ineligibleFields, cac));
+               });
 
         private void AnalyzeProperty(ConcurrentBag<AnalysisResult> analysisResults, SymbolAnalysisContext symbolContext)
         {

src/Features/Core/Portable/UseCoalesceExpression/AbstractUseCoalesceExpressionDiagnosticAnalyzer.cs

@@ -30,10 +30,7 @@ protected AbstractUseCoalesceExpressionDiagnosticAnalyzer()
         protected abstract bool IsNotEquals(TBinaryExpressionSyntax condition);
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeSyntax, GetSyntaxKindToAnalyze());
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, GetSyntaxKindToAnalyze());
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         {

src/Features/Core/Portable/UseCoalesceExpression/AbstractUseCoalesceExpressionForNullableDiagnosticAnalyzer.cs

@@ -32,10 +32,7 @@ protected AbstractUseCoalesceExpressionForNullableDiagnosticAnalyzer()
         protected abstract ISyntaxFactsService GetSyntaxFactsService();
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeSyntax, GetSyntaxKindToAnalyze());
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, GetSyntaxKindToAnalyze());
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         {

src/Features/Core/Portable/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs

@@ -39,19 +39,16 @@ protected AbstractUseCollectionInitializerDiagnosticAnalyzer()
         }
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterCompilationStartAction(compilationContext =>
-            {
-                var ienumerableType = compilationContext.Compilation.GetTypeByMetadataName("System.Collections.IEnumerable") as INamedTypeSymbol;
-                if (ienumerableType != null)
-                {
-                    context.RegisterSyntaxNodeAction(
-                        nodeContext => AnalyzeNode(nodeContext, ienumerableType),
-                        GetObjectCreationSyntaxKind());
-                }
-            });
-        }
+            => context.RegisterCompilationStartAction(compilationContext =>
+               {
+                   var ienumerableType = compilationContext.Compilation.GetTypeByMetadataName("System.Collections.IEnumerable") as INamedTypeSymbol;
+                   if (ienumerableType != null)
+                   {
+                       context.RegisterSyntaxNodeAction(
+                           nodeContext => AnalyzeNode(nodeContext, ienumerableType),
+                           GetObjectCreationSyntaxKind());
+                   }
+               });
 
         protected abstract bool AreCollectionInitializersSupported(SyntaxNodeAnalysisContext context);
         protected abstract TSyntaxKind GetObjectCreationSyntaxKind();

src/Features/Core/Portable/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs

@@ -40,10 +40,7 @@ protected AbstractUseNullPropagationDiagnosticAnalyzer()
         protected abstract bool ShouldAnalyze(ParseOptions options);
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeSyntax, GetSyntaxKindToAnalyze());
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeSyntax, GetSyntaxKindToAnalyze());
 
         private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
         {

src/Features/Core/Portable/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs

@@ -41,10 +41,7 @@ protected AbstractUseObjectInitializerDiagnosticAnalyzer()
         }
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.RegisterSyntaxNodeAction(AnalyzeNode, GetObjectCreationSyntaxKind());
-        }
+            => context.RegisterSyntaxNodeAction(AnalyzeNode, GetObjectCreationSyntaxKind());
 
         protected abstract TSyntaxKind GetObjectCreationSyntaxKind();
 

src/Features/Core/Portable/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs

@@ -56,14 +56,11 @@ public DiagnosticAnalyzerCategory GetAnalyzerCategory()
         protected abstract bool IsSupported(ParseOptions options);
 
         protected override void InitializeWorker(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            s_registerOperationActionInfo.Invoke(context, new object[]
-            {
-                new Action<OperationAnalysisContext>(AnalyzeOperation),
-                ImmutableArray.Create(OperationKind.ThrowStatement)
-            });
-        }
+            => s_registerOperationActionInfo.Invoke(context, new object[]
+               {
+                   new Action<OperationAnalysisContext>(AnalyzeOperation),
+                   ImmutableArray.Create(OperationKind.ThrowStatement)
+               });
 
         private void AnalyzeOperation(OperationAnalysisContext context)
         {