private void AnalyzeCompilationStart(CompilationStartAnalysisContext csContext)
        {
            // Get named type symbols for targetted exception types
            ImmutableHashSet<INamedTypeSymbol> exceptionTypes = s_exceptionTypeNames
                .Select(name => csContext.Compilation.GetTypeByMetadataName(name))
                .Where(t => t != null)
                .ToImmutableHashSet();

            if (!exceptionTypes.IsEmpty)
            {
                // register symbol action for named types
                csContext.RegisterSymbolAction(saContext =>
                {
                    var symbol = (INamedTypeSymbol)saContext.Symbol;

                    // skip public symbols
                    if (symbol.IsPublic()) return;

                    // only report if base type matches 
                    if (symbol.BaseType != null && exceptionTypes.Contains(symbol.BaseType))
                    {
                        saContext.ReportDiagnostic(symbol.CreateDiagnostic(Rule));
                    }
                },
                SymbolKind.NamedType);
            }
        }

        private static void HandleCompilationStart(CompilationStartAnalysisContext context)
        {
            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);

            context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodDeclaration, SyntaxKind.MethodDeclaration);
            context.RegisterSyntaxNodeActionHonorExclusions(HandleDelegateDeclaration, SyntaxKind.DelegateDeclaration);
        }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(HandleDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration,
         SyntaxKind.EnumDeclaration, SyntaxKind.DelegateDeclaration, SyntaxKind.FieldDeclaration, SyntaxKind.MethodDeclaration,
         SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.EventFieldDeclaration, SyntaxKind.IndexerDeclaration,
         SyntaxKind.OperatorDeclaration, SyntaxKind.ConversionOperatorDeclaration, SyntaxKind.ConstructorDeclaration);
 }

        void Analyze(CompilationStartAnalysisContext compilationContext)
        {
            var compilation = compilationContext.Compilation;
            compilationContext.RegisterSyntaxTreeAction(async delegate (SyntaxTreeAnalysisContext context)
            {
                try
                {
                    if (!compilation.SyntaxTrees.Contains(context.Tree))
                        return;
                    var semanticModel = compilation.GetSemanticModel(context.Tree);
                    var root = await context.Tree.GetRootAsync(context.CancellationToken).ConfigureAwait(false);
                    var model = compilationContext.Compilation.GetSemanticModel(context.Tree);
                    if (model.IsFromGeneratedCode(compilationContext.CancellationToken))
                        return;
                    foreach (var type in root.DescendantNodesAndSelf(SkipMembers).OfType<ClassDeclarationSyntax>())
                    {
                        var fieldDeclarations = type
                            .ChildNodes()
                            .OfType<FieldDeclarationSyntax>()
                            .Where(f => FieldFilter(model, f))
                            .SelectMany(fd => fd.Declaration.Variables.Select(v => new { Field = fd, Variable = v, Symbol = semanticModel.GetDeclaredSymbol(v, context.CancellationToken) }));
                        foreach (var candidateField in fieldDeclarations)
                        {
                            context.CancellationToken.ThrowIfCancellationRequested();
                            // handled by ConvertToConstantIssue
                            if (candidateField?.Variable?.Initializer != null && semanticModel.GetConstantValue(candidateField.Variable.Initializer.Value, context.CancellationToken).HasValue)
                                continue;

                            // user-defined value type -- might be mutable
                            var field = candidateField.Symbol;
                            if (field != null && !field.GetReturnType().IsReferenceType)
                            {
                                if (field.GetReturnType().IsDefinedInSource())
                                {
                                    continue;
                                }
                            }
                            bool wasAltered = false;
                            bool wasUsed = false;
                            foreach (var member in type.Members)
                            {
                                if (member == candidateField.Field)
                                    continue;
                                if (IsAltered(model, member, candidateField.Symbol, context.CancellationToken, out wasUsed))
                                {
                                    wasAltered = true;
                                    break;
                                }
                            }
                            if (!wasAltered && wasUsed)
                            {
                                context.CancellationToken.ThrowIfCancellationRequested();
                                context.ReportDiagnostic(Diagnostic.Create(descriptor, candidateField.Variable.Identifier.GetLocation()));
                            }
                        }
                    }
                }
                catch (Exception) { }
            });
        }

 /// <summary>
 /// Documentation analysis is done only on compilation start, to delay
 /// </summary>
 /// <param name="context">the compilation start action.</param>
 private void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeAction(
         this.HandleClassOrInterfaceDeclaration,
         SyntaxKind.InterfaceDeclaration,
         SyntaxKind.ClassDeclaration);
 }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(BaseTypeDeclarationAction, BaseTypeDeclarationKinds);
     context.RegisterSyntaxNodeActionHonorExclusions(BasePropertyDeclarationAction, BasePropertyDeclarationKinds);
     context.RegisterSyntaxNodeActionHonorExclusions(BaseMethodDeclarationAction, BaseMethodDeclarationKinds);
     context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
 }

        private static void AnalyzeCompilationStart(CompilationStartAnalysisContext context)
        {
            ImmutableHashSet<INamedTypeSymbol> badBaseTypes = s_badBaseTypesToMessage.Keys
                                .Select(bt => context.Compilation.GetTypeByMetadataName(bt))
                                .Where(bt => bt != null)
                                .ToImmutableHashSet();

            if (badBaseTypes.Count > 0)
            {
                context.RegisterSymbolAction((saContext) =>
                    {
                        var namedTypeSymbol = saContext.Symbol as INamedTypeSymbol;

                        if (namedTypeSymbol.BaseType != null && badBaseTypes.Contains(namedTypeSymbol.BaseType))
                        {
                            string baseTypeName = namedTypeSymbol.BaseType.ToDisplayString();
                            Debug.Assert(s_badBaseTypesToMessage.ContainsKey(baseTypeName));
                            string message = string.Format(s_badBaseTypesToMessage[baseTypeName], namedTypeSymbol.ToDisplayString(), baseTypeName);
                            Diagnostic diagnostic = Diagnostic.Create(Rule, namedTypeSymbol.Locations.First(), namedTypeSymbol.Locations.Skip(1), message);
                            saContext.ReportDiagnostic(diagnostic);
                        }
                    }
                    , SymbolKind.NamedType);
            }
        }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.MethodDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.ConstructorDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.DelegateDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleSyntaxNode, SyntaxKind.IndexerDeclaration);
 }

 protected override void RegisterImmutableArrayAction(CompilationStartAnalysisContext context, INamedTypeSymbol immutableArrayOfTType)
 {
     context.RegisterCodeBlockStartAction<SyntaxKind>(
         c => c.RegisterSyntaxNodeAction(
             c2 => AnalyzeCollectionInitializerExpression(c2, immutableArrayOfTType),
             SyntaxKind.CollectionInitializerExpression));
 }

        /// <summary>Called once at compilation start to register actions in the compilation context.</summary>
        /// <param name="context">The analysis context.</param>
        internal void RegisterOperationAction(CompilationStartAnalysisContext context)
        {
            context.RegisterOperationAction(
                (operationContext) =>
                    {
                        IArrayCreationExpression arrayCreation = (IArrayCreationExpression)operationContext.Operation;

                        // ToDo: Need to suppress analysis of array creation expressions within attribute applications.

                        // Detect array creation expression that have rank 1 and size 0. Such expressions
                        // can be replaced with Array.Empty<T>(), provided that the element type can be a generic type argument.

                        if (arrayCreation.DimensionSizes.Length == 1
                            //// Pointer types can't be generic type arguments.
                            && arrayCreation.ElementType.TypeKind != TypeKind.Pointer)
                        {
                            Optional<object> arrayLength = arrayCreation.DimensionSizes[0].ConstantValue;
                            if (arrayLength.HasValue &&
                                arrayLength.Value is int &&
                                (int)arrayLength.Value == 0)
                            {
                                Report(operationContext, arrayCreation.Syntax);
                            }
                        }
                    },
                OperationKind.ArrayCreationExpression);
        }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseTypeDeclarations, SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.EnumDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandlePropertyLikeDeclarations, SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.IndexerDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodLikeDeclarations, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.DestructorDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclarations, SyntaxKind.NamespaceDeclaration);
 }

        protected override SymbolAndNodeAnalyzer GetAnalyzer(CompilationStartAnalysisContext context, CompilationSecurityTypes types, Version targetFrameworkVersion)
        {
            SymbolAndNodeAnalyzer analyzer = new SymbolAndNodeAnalyzer(types, CSharpSyntaxNodeHelper.Default, targetFrameworkVersion);
            context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration);

            return analyzer;
        }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodDeclaration, SyntaxKind.MethodDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleConstructorDeclaration, SyntaxKind.ConstructorDeclaration);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocationExpression, SyntaxKind.InvocationExpression);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleObjectCreationExpression, SyntaxKind.ObjectCreationExpression);
 }

 private void OnCompilationStart(CompilationStartAnalysisContext context)
 {
     var immutableArrayType = context.Compilation.GetTypeByMetadataName(ImmutableArrayMetadataName);
     if (immutableArrayType != null)
     {
         context.RegisterSyntaxNodeAction(syntaxContext => AnalyzeCall(syntaxContext, immutableArrayType), SyntaxKind.InvocationExpression);
     }
 }

 protected override Analyzer GetAnalyzer(CompilationStartAnalysisContext context, CompilationSecurityTypes cryptTypes)
 {
     Analyzer analyzer = new Analyzer(cryptTypes);
     context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode,
                                      SyntaxKind.InvocationExpression,
                                      SyntaxKind.ObjectCreationExpression);
     return analyzer;
 }

        private static void HandleCompilationStart(CompilationStartAnalysisContext context)
        {
            // handle everything except nameof
            context.RegisterSyntaxTreeActionHonorExclusions(HandleSyntaxTree);

            // handle nameof (which appears as an invocation expression??)
            context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocationExpressionSyntax, SyntaxKind.InvocationExpression);
        }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(HandleIfStatement, SyntaxKind.IfStatement);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleDoStatement, SyntaxKind.DoStatement);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleWhileStatement, SyntaxKind.WhileStatement);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleForStatement, SyntaxKind.ForStatement);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleForEachStatement, SyntaxKind.ForEachStatement);
 }

 public override void OnCompilationStart(CompilationStartAnalysisContext context)
 {
     SRSymbol = context.Compilation.GetTypeByMetadataName("System.SR");
     if (SRSymbol != null)
     {
         context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.InvocationExpression);
     }
 }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.EqualsExpression);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.NotEqualsExpression);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.GreaterThanExpression);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.LessThanExpression);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.GreaterThanOrEqualExpression);
     context.RegisterSyntaxNodeActionHonorExclusions(HandleBinaryExpression, SyntaxKind.LessThanOrEqualExpression);
 }

 private static void OnCompilationStart(CompilationStartAnalysisContext context)
 {
     INamedTypeSymbol objectType = context.Compilation.GetSpecialType(SpecialType.System_Object);
     INamedTypeSymbol equatableType = context.Compilation.GetTypeByMetadataName(IEquatableMetadataName);
     if (objectType != null && equatableType != null)
     {
         context.RegisterSymbolAction(c => AnalyzeSymbol(c, equatableType), SymbolKind.NamedType);
     }
 }