private void AnalyzeSymbol(INamedTypeSymbol symbol, INamedTypeSymbol attributeType, Compilation compilation, Action <Diagnostic> addDiagnostic)
 {
     if (symbol != null && symbol.GetBaseTypesAndThis().Contains(WellKnownTypes.Attribute(compilation)) && symbol.DeclaredAccessibility != Accessibility.Private)
     {
         IEnumerable <IParameterSymbol> parametersToCheck = GetAllPublicConstructorParameters(symbol);
         if (parametersToCheck.Any())
         {
             IDictionary <string, IPropertySymbol> propertiesMap = GetAllPropertiesInTypeChain(symbol);
             AnalyzeParameters(compilation, parametersToCheck, propertiesMap, symbol, addDiagnostic);
         }
     }
 }
        public override void Initialize(AnalysisContext analysisContext)
        {
            analysisContext.RegisterCompilationStartAction(compilationContext =>
            {
                INamedTypeSymbol attributeType = WellKnownTypes.Attribute(compilationContext.Compilation);
                if (attributeType == null)
                {
                    return;
                }

                compilationContext.RegisterSymbolAction(context =>
                {
                    AnalyzeSymbol((INamedTypeSymbol)context.Symbol, attributeType, context.Compilation, context.ReportDiagnostic);
                },
                                                        SymbolKind.NamedType);
            });
        }
        public override void Initialize(AnalysisContext analysisContext)
        {
            analysisContext.EnableConcurrentExecution();
            analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);

            analysisContext.RegisterCompilationStartAction(compilationContext =>
            {
                INamedTypeSymbol attributeType = WellKnownTypes.Attribute(compilationContext.Compilation);
                if (attributeType == null)
                {
                    return;
                }

                compilationContext.RegisterSymbolAction(context =>
                {
                    AnalyzeSymbol((INamedTypeSymbol)context.Symbol, attributeType, context.Compilation, context.ReportDiagnostic);
                },
                                                        SymbolKind.NamedType);
            });
        }
Example #4
0
        public override void Initialize(AnalysisContext analysisContext)
        {
            // this is stateless analyzer, can run concurrently
            analysisContext.EnableConcurrentExecution();

            // this has no meaning on running on generated code which user can't control
            analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);

            analysisContext.RegisterCompilationStartAction(c =>
            {
                var @string   = WellKnownTypes.String(c.Compilation);
                var attribute = WellKnownTypes.Attribute(c.Compilation);
                if (@string == null || attribute == null)
                {
                    // we don't have required types
                    return;
                }

                var analyzer = new PerCompilationAnalyzer(@string, attribute);
                c.RegisterSymbolAction(analyzer.Analyze, SymbolKind.Property);
            });
        }