C# SonarAnalysisContext.RegisterCompilationStartAction方法代码示例

        protected sealed override void Initialize(SonarAnalysisContext context)
        {
            var analysisContext = new ParameterLoadingAnalysisContext(context);
            Initialize(analysisContext);

            context.RegisterCompilationStartAction(
                cac =>
                {
                    ParameterLoader.SetParameterValues(this, cac.Options);
                    foreach (var compilationStartActions in analysisContext.CompilationStartActions)
                    {
                        compilationStartActions(cac);
                    }
                });
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterCompilationStartAction(
                compilationStartContext =>
                {
                    var allNamedTypeSymbols = compilationStartContext.Compilation.GlobalNamespace.GetAllNamedTypes();
                    var allInterfacesWithImplementationsOverridenEquals =
                        allNamedTypeSymbols
                            .Where(t => t.AllInterfaces.Any() && HasEqualsOverride(t))
                            .SelectMany(t => t.AllInterfaces)
                            .ToImmutableHashSet();

                    compilationStartContext.RegisterSyntaxNodeActionInNonGenerated(
                        c =>
                        {
                            var binary = (BinaryExpressionSyntax)c.Node;
                            if (!IsBinaryCandidateForReporting(binary, c.SemanticModel))
                            {
                                return;
                            }

                            var typeLeft = c.SemanticModel.GetTypeInfo(binary.Left).Type;
                            var typeRight = c.SemanticModel.GetTypeInfo(binary.Right).Type;
                            if (typeLeft == null ||
                                typeRight == null ||
                                IsAllowedType(typeLeft) ||
                                IsAllowedType(typeRight))
                            {
                                return;
                            }

                            if (MightOverrideEquals(typeLeft, allInterfacesWithImplementationsOverridenEquals) ||
                                MightOverrideEquals(typeRight, allInterfacesWithImplementationsOverridenEquals))
                            {
                                c.ReportDiagnostic(Diagnostic.Create(Rule, binary.OperatorToken.GetLocation()));
                            }
                        },
                        SyntaxKind.EqualsExpression,
                        SyntaxKind.NotEqualsExpression);
                });
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterCompilationStartAction(analysisContext =>
            {
                var fieldsByNamedType = MultiValueDictionary<INamedTypeSymbol, IFieldSymbol>.Create<HashSet<IFieldSymbol>>();
                var fieldsAssigned = ImmutableHashSet<IFieldSymbol>.Empty;

                analysisContext.RegisterSymbolAction(c =>
                {
                    var namedTypeSymbol = (INamedTypeSymbol)c.Symbol;
                    if (!namedTypeSymbol.IsClass() ||
                        namedTypeSymbol.Implements(KnownType.System_IDisposable))
                    {
                        return;
                    }

                    var disposableFields = namedTypeSymbol.GetMembers()
                        .OfType<IFieldSymbol>()
                        .Where(IsNonStaticNonPublicDisposableField)
                        .ToImmutableHashSet();

                    fieldsByNamedType.AddRangeWithKey(namedTypeSymbol, disposableFields);
                }, SymbolKind.NamedType);


                analysisContext.RegisterSyntaxNodeAction(c =>
                {
                    var assignment = (AssignmentExpressionSyntax)c.Node;
                    var expression = assignment.Right;
                    var fieldSymbol = c.SemanticModel.GetSymbolInfo(assignment.Left).Symbol as IFieldSymbol;

                    fieldsAssigned = AddFieldIfNeeded(fieldSymbol, expression, fieldsAssigned);
                }, SyntaxKind.SimpleAssignmentExpression);

                analysisContext.RegisterSyntaxNodeAction(c =>
                {
                    var field = (FieldDeclarationSyntax)c.Node;

                    foreach (var variableDeclaratorSyntax in field.Declaration.Variables
                        .Where(declaratorSyntax => declaratorSyntax.Initializer != null))
                    {
                        var fieldSymbol = c.SemanticModel.GetDeclaredSymbol(variableDeclaratorSyntax) as IFieldSymbol;

                        fieldsAssigned = AddFieldIfNeeded(fieldSymbol, variableDeclaratorSyntax.Initializer.Value,
                            fieldsAssigned);
                    }

                }, SyntaxKind.FieldDeclaration);

                analysisContext.RegisterCompilationEndAction(c =>
                {
                    foreach (var kv in fieldsByNamedType)
                    {
                        foreach (var classSyntax in kv.Key.DeclaringSyntaxReferences
                            .Select(declaringSyntaxReference => declaringSyntaxReference.GetSyntax())
                            .OfType<ClassDeclarationSyntax>())
                        {
                            var assignedFields = kv.Value.Intersect(fieldsAssigned).ToList();

                            if (!assignedFields.Any())
                            {
                                continue;
                            }
                            var variableNames = string.Join(", ",
                                assignedFields.Select(symbol => $"\"{symbol.Name}\"").OrderBy(s => s));

                            c.ReportDiagnosticIfNonGenerated(
                                Diagnostic.Create(Rule, classSyntax.Identifier.GetLocation(), variableNames),
                                c.Compilation);
                        }
                    }
                });
            });
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterCompilationStartAction(
                compilationStartContext =>
                {
                    var allNamedTypeSymbols = compilationStartContext.Compilation.GlobalNamespace.GetAllNamedTypes();
                    var typeInterfaceMappings = allNamedTypeSymbols.Select(type =>
                        new
                        {
                            Type = type.OriginalDefinition,
                            Interfaces = type.OriginalDefinition.AllInterfaces.Select(i => i.OriginalDefinition)
                        });

                    var interfaceImplementerMappings = new Dictionary<INamedTypeSymbol, HashSet<INamedTypeSymbol>>();
                    foreach (var typeInterfaceMapping in typeInterfaceMappings)
                    {
                        if (typeInterfaceMapping.Type.IsInterface())
                        {
                            if (!interfaceImplementerMappings.ContainsKey(typeInterfaceMapping.Type))
                            {
                                interfaceImplementerMappings.Add(typeInterfaceMapping.Type, new HashSet<INamedTypeSymbol>());
                            }

                            interfaceImplementerMappings[typeInterfaceMapping.Type].Add(typeInterfaceMapping.Type);
                        }

                        foreach (var @interface in typeInterfaceMapping.Interfaces)
                        {
                            if (!interfaceImplementerMappings.ContainsKey(@interface))
                            {
                                interfaceImplementerMappings.Add(@interface, new HashSet<INamedTypeSymbol>());
                            }

                            interfaceImplementerMappings[@interface].Add(typeInterfaceMapping.Type);
                        }
                    }

                    compilationStartContext.RegisterSyntaxNodeActionInNonGenerated(
                        c =>
                        {
                            var cast = (CastExpressionSyntax)c.Node;
                            var interfaceType = c.SemanticModel.GetTypeInfo(cast.Type).Type as INamedTypeSymbol;
                            var expressionType = c.SemanticModel.GetTypeInfo(cast.Expression).Type as INamedTypeSymbol;

                            CheckTypesForInvalidCast(interfaceType, expressionType, interfaceImplementerMappings,
                                cast.Type.GetLocation(), c);
                        },
                        SyntaxKind.CastExpression);

                    compilationStartContext.RegisterSyntaxNodeAction(
                        c =>
                        {
                            var cast = (BinaryExpressionSyntax)c.Node;
                            var interfaceType = c.SemanticModel.GetTypeInfo(cast.Right).Type as INamedTypeSymbol;
                            var expressionType = c.SemanticModel.GetTypeInfo(cast.Left).Type as INamedTypeSymbol;

                            CheckTypesForInvalidCast(interfaceType, expressionType, interfaceImplementerMappings,
                                cast.Right.GetLocation(), c);
                        },
                        SyntaxKind.AsExpression,
                        SyntaxKind.IsExpression);
                });

            context.RegisterExplodedGraphBasedAnalysis((e, c) => CheckEmptyNullableCast(e, c));
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterCompilationStartAction(
                analysisContext =>
                {
                    var disposeMethod = GetDisposeMethod(analysisContext.Compilation);
                    if (disposeMethod == null)
                    {
                        return;
                    }

                    var disposeMethodsCalledFromDispose = MultiValueDictionary<INamedTypeSymbol, IMethodSymbol>.Create<HashSet<IMethodSymbol>>();
                    var implementingDisposeMethods = ImmutableHashSet<IMethodSymbol>.Empty;
                    var allDisposeMethods = ImmutableHashSet<IMethodSymbol>.Empty;

                    analysisContext.RegisterSymbolAction(c =>
                        CollectDisposeMethods(c, disposeMethod, ref allDisposeMethods, ref implementingDisposeMethods),
                        SymbolKind.Method);

                    analysisContext.RegisterCodeBlockStartAction<SyntaxKind>(
                        cbc =>
                        {
                            var methodDeclaration = cbc.CodeBlock as MethodDeclarationSyntax;
                            if (methodDeclaration == null ||
                                methodDeclaration.Identifier.ValueText != DisposeMethodName)
                            {
                                return;
                            }

                            var declaredMethodSymbol = cbc.SemanticModel.GetDeclaredSymbol(methodDeclaration);
                            if (declaredMethodSymbol == null ||
                                !MethodIsDisposeImplementation(declaredMethodSymbol, disposeMethod))
                            {
                                return;
                            }

                            var disposableType = declaredMethodSymbol.ContainingType;
                            cbc.RegisterSyntaxNodeAction(
                                c => CollectDisposeMethodsCalledFromDispose((InvocationExpressionSyntax) c.Node,
                                    c.SemanticModel, disposableType, disposeMethodsCalledFromDispose),
                                SyntaxKind.InvocationExpression);
                        });

                    analysisContext.RegisterCompilationEndAction(
                        c =>
                            ReportDisposeMethods(allDisposeMethods, implementingDisposeMethods,
                                disposeMethodsCalledFromDispose, c));
                });
        }

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterCompilationStartAction(analysisContext =>
            {
                var candidateFields = ImmutableHashSet<IFieldSymbol>.Empty;
                var assignedAsReadonly = ImmutableHashSet<IFieldSymbol>.Empty;
                var nonCandidateFields = ImmutableHashSet<IFieldSymbol>.Empty;

                analysisContext.RegisterSyntaxNodeAction(c =>
                {
                    var fieldDeclaration = (FieldDeclarationSyntax) c.Node;

                    foreach (var field in fieldDeclaration.Declaration.Variables
                        .Select(variableDeclaratorSyntax => new
                        {
                            Syntax = variableDeclaratorSyntax,
                            Symbol = c.SemanticModel.GetDeclaredSymbol(variableDeclaratorSyntax) as IFieldSymbol
                        })
                        .Where(f => f.Symbol != null)
                        .Where(f => FieldIsRelevant(f.Symbol)))
                    {
                        candidateFields = candidateFields.Add(field.Symbol);

                        if (field.Syntax.Initializer != null)
                        {
                            assignedAsReadonly = assignedAsReadonly.Add(field.Symbol);
                        }
                    }
                }, SyntaxKind.FieldDeclaration);

                analysisContext.RegisterSyntaxNodeAction(
                    c =>
                    {
                        var assignment = (AssignmentExpressionSyntax) c.Node;
                        var expression = assignment.Left;

                        ProcessExpressionChange(expression, c.SemanticModel, ref nonCandidateFields, ref assignedAsReadonly);
                    },
                    SyntaxKind.SimpleAssignmentExpression,
                    SyntaxKind.AddAssignmentExpression,
                    SyntaxKind.SubtractAssignmentExpression,
                    SyntaxKind.MultiplyAssignmentExpression,
                    SyntaxKind.DivideAssignmentExpression,
                    SyntaxKind.ModuloAssignmentExpression,
                    SyntaxKind.AndAssignmentExpression,
                    SyntaxKind.ExclusiveOrAssignmentExpression,
                    SyntaxKind.OrAssignmentExpression,
                    SyntaxKind.LeftShiftAssignmentExpression,
                    SyntaxKind.RightShiftAssignmentExpression);

                analysisContext.RegisterSyntaxNodeAction(
                    c =>
                    {
                        var unary = (PrefixUnaryExpressionSyntax)c.Node;
                        var expression = unary.Operand;

                        ProcessExpressionChange(expression, c.SemanticModel, ref nonCandidateFields, ref assignedAsReadonly);
                    },
                    SyntaxKind.PreDecrementExpression,
                    SyntaxKind.PreIncrementExpression);

                analysisContext.RegisterSyntaxNodeAction(
                    c =>
                    {
                        var unary = (PostfixUnaryExpressionSyntax)c.Node;
                        var expression = unary.Operand;

                        ProcessExpressionChange(expression, c.SemanticModel, ref nonCandidateFields, ref assignedAsReadonly);
                    },
                    SyntaxKind.PostDecrementExpression,
                    SyntaxKind.PostIncrementExpression);

                analysisContext.RegisterSyntaxNodeAction(c =>
                {
                    var argument = (ArgumentSyntax) c.Node;
                    if (argument.RefOrOutKeyword.IsKind(SyntaxKind.None))
                    {
                        return;
                    }

                    var fieldSymbol = c.SemanticModel.GetSymbolInfo(argument.Expression).Symbol as IFieldSymbol;
                    if (FieldIsRelevant(fieldSymbol))
                    {
                        nonCandidateFields = nonCandidateFields.Add(fieldSymbol);
                    }
                }, SyntaxKind.Argument);

                analysisContext.RegisterCompilationEndAction(c =>
                {
                    var fields = candidateFields.Except(nonCandidateFields);
                    fields = fields.Intersect(assignedAsReadonly);
                    foreach (var field in fields)
                    {
                        var declarationReference = field.DeclaringSyntaxReferences.FirstOrDefault();
                        var fieldSyntax = declarationReference?.GetSyntax() as VariableDeclaratorSyntax;
                        if (fieldSyntax == null)
                        {
                            continue;
                        }

//.........这里部分代码省略.........

        protected override void Initialize(SonarAnalysisContext context)
        {
            context.RegisterCompilationStartAction(analysisContext =>
            {
                analysisContext.RegisterSyntaxNodeAction(
                    c =>
                    {
                        var methodDeclaration = c.Node as MethodDeclarationSyntax;
                        var classDeclaration = c.Node as ClassDeclarationSyntax;

                        if (methodDeclaration != null &&
                            !IsMethodCandidate(methodDeclaration, c.SemanticModel))
                        {
                            return;
                        }

                        var declarationSymbol = c.SemanticModel.GetDeclaredSymbol(c.Node);
                        if (declarationSymbol == null)
                        {
                            return;
                        }

                        var helper = GetTypeParameterHelper(methodDeclaration, classDeclaration);
                        if (helper.TypeParameterList == null || helper.TypeParameterList.Parameters.Count == 0)
                        {
                            return;
                        }

                        var declarations = declarationSymbol.DeclaringSyntaxReferences
                            .Select(reference => reference.GetSyntax());

                        var usedTypeParameters = GetUsedTypeParameters(declarations, c, analysisContext.Compilation);

                        foreach (var typeParameter in helper.TypeParameterList.Parameters
                            .Select(typeParameter => typeParameter.Identifier.Text)
                            .Where(typeParameter => !usedTypeParameters.Contains(typeParameter)))
                        {
                            c.ReportDiagnostic(Diagnostic.Create(Rule,
                                helper.TypeParameterList.Parameters.First(tp => tp.Identifier.Text == typeParameter)
                                    .GetLocation(),
                                typeParameter, helper.ContainerSyntaxTypeName));
                        }
                    },
                    SyntaxKind.MethodDeclaration,
                    SyntaxKind.ClassDeclaration);
            });
        }