C# CompilationStartAnalysisContext.RegisterSyntaxNodeAction方法代码示例

        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;
        }

 /// <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 void OnCompilationStart(CompilationStartAnalysisContext context)
        {
            _candidateReadonlyFields = new HashSet<IFieldSymbol>();
            _writtenFields = new HashSet<IFieldSymbol>();

            _internalsVisibleToAttribute = context.Compilation.GetTypeByMetadataName(
                                                "System.Runtime.CompilerServices.InternalsVisibleToAttribute");

            context.RegisterSymbolAction(LocateCandidateReadonlyFields, SymbolKind.Field);
            context.RegisterSyntaxNodeAction(CheckForAssignment, s_compoundAssignmentExpressionKinds);
            context.RegisterSyntaxNodeAction(CheckForRefOrOutParameter, SyntaxKind.Argument);
            context.RegisterSyntaxNodeAction(CheckForExternMethodWithRefParameters, SyntaxKind.MethodDeclaration);
            context.RegisterSyntaxNodeAction(CheckForExternIndexer, SyntaxKind.IndexerDeclaration);
            context.RegisterSyntaxNodeAction(CheckForInvocations, SyntaxKind.InvocationExpression);
            context.RegisterCompilationEndAction(ReportUnwrittenFields);
        }

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

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

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

 private void OnCompilationStart(CompilationStartAnalysisContext context)
 {
     var listType = context.Compilation.GetTypeByMetadataName(IListMetadataName);
     var readonlyListType = context.Compilation.GetTypeByMetadataName(IReadOnlyListMetadataName);
     var enumerableType = context.Compilation.GetTypeByMetadataName(EnumerableMetadataName);
     if (readonlyListType != null && enumerableType != null && listType != null)
     {
         context.RegisterSyntaxNodeAction(nodeContext => AnalyzeCall(nodeContext, enumerableType, readonlyListType, listType), SyntaxKind.InvocationExpression);
     }
 }

        protected override void RegisterAttributeAnalyzer(CompilationStartAnalysisContext context, Action onResourceFound)
        {
            context.RegisterSyntaxNodeAction(nc =>
            {
                if (!CheckAttribute(nc.Node))
                {
                    return;
                }

                if (!CheckResxGeneratedFile(nc.SemanticModel, nc.Node, ((AttributeSyntax)nc.Node).ArgumentList.Arguments[0].Expression, nc.CancellationToken))
                {
                    return;
                }

                onResourceFound();
            }, SyntaxKind.Attribute);
        }

 private static void HandleCompilationStart(CompilationStartAnalysisContext context)
 {
     // If SA1503 is suppressed, we need to handle compound blocks as well.
     if (context.IsAnalyzerSuppressed(SA1503BracesMustNotBeOmitted.DiagnosticId))
     {
         context.RegisterSyntaxNodeAction(HandleIfStatement, SyntaxKind.IfStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((DoStatementSyntax)ctx.Node).Statement), SyntaxKind.DoStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((WhileStatementSyntax)ctx.Node).Statement), SyntaxKind.WhileStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((ForStatementSyntax)ctx.Node).Statement), SyntaxKind.ForStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((ForEachStatementSyntax)ctx.Node).Statement), SyntaxKind.ForEachStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((LockStatementSyntax)ctx.Node).Statement), SyntaxKind.LockStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((UsingStatementSyntax)ctx.Node).Statement), SyntaxKind.UsingStatement);
         context.RegisterSyntaxNodeAction(ctx => CheckChildStatement(ctx, ctx.Node, ((FixedStatementSyntax)ctx.Node).Statement), SyntaxKind.FixedStatement);
     }
 }

        private static void AnalyzeArrayList(CompilationStartAnalysisContext compilationContext)
        {
            var arrayListType = compilationContext.Compilation.GetTypeByMetadataName("System.Collections.ArrayList");

            compilationContext.RegisterSyntaxNodeAction(syntaxContext =>
            {
                var variableTypeInfo = syntaxContext.SemanticModel.GetTypeInfo(syntaxContext.Node).Type as INamedTypeSymbol;

                if (variableTypeInfo.SpecialType == SpecialType.System_String)
                {

                }

                if (variableTypeInfo == null)
                    return;

                if (variableTypeInfo.Equals(arrayListType))
                {
                    syntaxContext.ReportDiagnostic(Diagnostic.Create(Rule, syntaxContext.Node.GetLocation()));
                }
            }, SyntaxKind.ObjectCreationExpression);
        }

 public override void CreateAnalyzerWithinCompilation(CompilationStartAnalysisContext context)
 {
     context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.PragmaWarningDirectiveTrivia);
 }

        private static void TrackAssignmentsToLocalsAndPrivateFields(CompilationStartAnalysisContext context, ISet<NodeAndSymbol> trackedNodesAndSymbols)
        {
            context.RegisterSyntaxNodeAction(
                c =>
                {
                    var assignment = c.Node as AssignmentExpressionSyntax;
                    if (assignment.Parent.IsKind(SyntaxKind.UsingStatement))
                    {
                        return;
                    }

                    var referencedSymbol = c.SemanticModel.GetSymbolInfo(assignment.Left).Symbol;
                    if (referencedSymbol == null || !IsLocalOrPrivateField(referencedSymbol))
                    {
                        return;
                    }

                    if (IsInstantiation(assignment.Right, c.SemanticModel))
                    {
                        trackedNodesAndSymbols.Add(new NodeAndSymbol { Node = assignment, Symbol = referencedSymbol });
                    }
                },
                SyntaxKind.SimpleAssignmentExpression);
        }

        private static void ExcludeDisposedAndClosedLocalsAndPrivateFields(CompilationStartAnalysisContext context, ISet<ISymbol> excludedSymbols)
        {
            context.RegisterSyntaxNodeAction(
                c =>
                {
                    SimpleNameSyntax name;
                    ExpressionSyntax expression;

                    if (c.Node.IsKind(SyntaxKind.InvocationExpression))
                    {
                        var invocation = (InvocationExpressionSyntax)c.Node;
                        var memberAccessNode = invocation.Expression as MemberAccessExpressionSyntax;

                        name = memberAccessNode?.Name;
                        expression = memberAccessNode?.Expression;
                    }
                    else if (c.Node.IsKind(SyntaxKind.ConditionalAccessExpression))
                    {
                        var conditionalAccess = (ConditionalAccessExpressionSyntax)c.Node;
                        var invocation = conditionalAccess.WhenNotNull as InvocationExpressionSyntax;
                        if (invocation == null)
                        {
                            return;
                        }

                        var memberBindingNode = invocation.Expression as MemberBindingExpressionSyntax;

                        name = memberBindingNode?.Name;
                        expression = conditionalAccess.Expression;
                    }
                    else
                    {
                        throw new ArgumentException();
                    }

                    if (name == null || !DisposeMethods.Contains(name.Identifier.Text))
                    {
                        return;
                    }

                    var referencedSymbol = c.SemanticModel.GetSymbolInfo(expression).Symbol;
                    if (referencedSymbol != null && IsLocalOrPrivateField(referencedSymbol))
                    {
                        excludedSymbols.Add(referencedSymbol);
                    }
                },
                SyntaxKind.InvocationExpression,
                SyntaxKind.ConditionalAccessExpression);
        }

 protected override AbstractAnalyzer GetAnalyzer(CompilationStartAnalysisContext context, INamedTypeSymbol disposableType)
 {
     Analyzer analyzer = new Analyzer(disposableType);
     context.RegisterSyntaxNodeAction(analyzer.AnalyzeNode, SyntaxKind.SimpleMemberAccessExpression, SyntaxKind.UsingStatement);
     return analyzer;
 }

        private static void TrackInitializedLocalsAndPrivateFields(CompilationStartAnalysisContext context, ISet<NodeAndSymbol> trackedNodesAndSymbols)
        {
            context.RegisterSyntaxNodeAction(
                c =>
                {
                    VariableDeclarationSyntax declaration;
                    if (c.Node.IsKind(SyntaxKind.LocalDeclarationStatement))
                    {
                        declaration = ((LocalDeclarationStatementSyntax)c.Node).Declaration;
                    }
                    else if (c.Node.IsKind(SyntaxKind.FieldDeclaration))
                    {
                        var fieldDeclaration = (FieldDeclarationSyntax)c.Node;
                        if (!fieldDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.PrivateKeyword)))
                        {
                            return;
                        }

                        declaration = fieldDeclaration.Declaration;
                    }
                    else
                    {
                        throw new ArgumentException();
                    }

                    foreach (var variableNode in declaration.Variables.Where(v => v.Initializer != null && IsInstantiation(v.Initializer.Value, c.SemanticModel)))
                    {
                        trackedNodesAndSymbols.Add(new NodeAndSymbol { Node = variableNode, Symbol = c.SemanticModel.GetDeclaredSymbol(variableNode) });
                    }
                },
                SyntaxKind.LocalDeclarationStatement,
                SyntaxKind.FieldDeclaration);
        }