private void AnalyzeCompilation(CompilationEndAnalysisContext context) { if (AssemblyHasPublicTypes(context.Compilation.Assembly)) { var comVisibleAttributeSymbol = WellKnownTypes.ComVisibleAttribute(context.Compilation); if (comVisibleAttributeSymbol == null) { return; } var attributeInstance = context.Compilation.Assembly.GetAttributes().FirstOrDefault(a => a.AttributeClass.Equals(comVisibleAttributeSymbol)); if (attributeInstance != null) { if (attributeInstance.ConstructorArguments.Length > 0 && attributeInstance.ConstructorArguments[0].Kind == TypedConstantKind.Primitive && attributeInstance.ConstructorArguments[0].Value != null & attributeInstance.ConstructorArguments[0].Value.Equals(true)) { // Has the attribute, with the value 'true'. context.ReportDiagnostic(Diagnostic.Create(Rule, Location.None, string.Format(FxCopRulesResources.CA1017_AttributeTrue, context.Compilation.Assembly.Name))); } } else { // No ComVisible attribute at all. context.ReportDiagnostic(Diagnostic.Create(Rule, Location.None, string.Format(FxCopRulesResources.CA1017_NoAttribute, context.Compilation.Assembly.Name))); } } return; }
public void AnalyzeCompilation(CompilationEndAnalysisContext context) { foreach (var item in this.fieldDisposedMap) { if (!item.Value) { context.ReportDiagnostic(item.Key.CreateDiagnostic(Rule)); } } }
public void AnalyzeCompilation(CompilationEndAnalysisContext context) { foreach (var item in _fieldDisposedMap) { if (!item.Value) { context.ReportDiagnostic(item.Key.CreateDiagnostic(Rule)); } } }
private void AnalyzeCompilation(CompilationEndAnalysisContext context) { var assemblyVersionAttributeSymbol = WellKnownTypes.AssemblyVersionAttribute(context.Compilation); var assemblyComplianceAttributeSymbol = WellKnownTypes.CLSCompliantAttribute(context.Compilation); if (assemblyVersionAttributeSymbol == null && assemblyComplianceAttributeSymbol == null) { return; } bool assemblyVersionAttributeFound = false; bool assemblyComplianceAttributeFound = false; // Check all assembly level attributes for the target attribute foreach (var attribute in context.Compilation.Assembly.GetAttributes()) { if (attribute.AttributeClass.Equals(assemblyVersionAttributeSymbol)) { // Mark the version attribute as found assemblyVersionAttributeFound = true; } else if (attribute.AttributeClass.Equals(assemblyComplianceAttributeSymbol)) { // Mark the compliance attribute as found assemblyComplianceAttributeFound = true; } } // Check for the case where we do not have the target attribute defined at all in our metadata references. If so, how can they reference it if (assemblyVersionAttributeSymbol == null) { assemblyVersionAttributeFound = false; } if (assemblyComplianceAttributeSymbol == null) { assemblyComplianceAttributeFound = false; } // If there's at least one diagnostic to report, let's report them if (!assemblyComplianceAttributeFound || !assemblyVersionAttributeFound) { if (!assemblyVersionAttributeFound) { context.ReportDiagnostic(Diagnostic.Create(CA1016Rule, Location.None)); } if (!assemblyComplianceAttributeFound) { context.ReportDiagnostic(Diagnostic.Create(CA1014Rule, Location.None)); } } }
private void AnalyzeCompilation(CompilationEndAnalysisContext context) { var globalNamespaces = context.Compilation.GlobalNamespace.GetNamespaceMembers() .Where(item => item.ContainingAssembly == context.Compilation.Assembly); var globalTypes = context.Compilation.GlobalNamespace.GetTypeMembers().Where(item => item.ContainingAssembly == context.Compilation.Assembly && IsExternallyVisible(item)); CheckTypeNames(globalTypes, context.ReportDiagnostic); CheckNamespaceMembers(globalNamespaces, context.Compilation, context.ReportDiagnostic); }
internal void AnalyzeCompilationEnd(CompilationEndAnalysisContext context) { foreach (var sourceSymbol in _sourceSymbolsToCheck) { var found = false; foreach (var type in sourceSymbol.GetBaseTypesAndThis()) { if (_typesWithSymbolDeclaredEventInvoked.Contains(type)) { found = true; break; } } if (!found) { var diagnostic = Diagnostic.Create(SymbolDeclaredEventRule, sourceSymbol.Locations[0], sourceSymbol.Name, _compilationType.Name, SymbolDeclaredEventName); context.ReportDiagnostic(diagnostic); } } }
public void OnCompilationEnd(CompilationEndAnalysisContext context) { foreach (var kv in _used.Where(kv => !kv.Value && (kv.Key.Locations.FirstOrDefault()?.IsInSource == true))) { context.CancellationToken.ThrowIfCancellationRequested(); var symbol = kv.Key; // report visible error only if symbol is not local symbol if (!(symbol is ILocalSymbol)) { context.ReportDiagnostic(Diagnostic.Create(s_rule, symbol.Locations[0], symbol.Locations.Skip(1), symbol.Name)); } // where code fix works foreach (var reference in symbol.DeclaringSyntaxReferences) { context.CancellationToken.ThrowIfCancellationRequested(); context.ReportDiagnostic(Diagnostic.Create(s_triggerRule, Location.Create(reference.SyntaxTree, reference.Span))); } } }
private void AnalyzeCompilation(CompilationEndAnalysisContext context) { OnAbstractMember("Compilation"); OnOptions(context.Options); }
public void AnalyzeCompilation(CompilationEndAnalysisContext context) { }
public static void AnalyzeCompilation(CompilationEndAnalysisContext context) { var diagnostics = context.Compilation.GetDeclarationDiagnostics(cancellationToken: context.CancellationToken); ReportDiagnostics(diagnostics, context.ReportDiagnostic, location => !IsSourceLocation(location)); }
private async Task ProcessCompilationCompletedAsync(CompilationCompletedEvent endEvent, CancellationToken cancellationToken) { try { // Execute analyzers in parallel. var tasks = ArrayBuilder<Task>.GetInstance(); foreach (var analyzerAndActions in _compilationEndActionsMap) { var task = Task.Run(() => { // Execute actions for a given analyzer sequentially. foreach (var endAction in analyzerAndActions.Value) { Debug.Assert(endAction.Analyzer == analyzerAndActions.Key); // Catch Exception from endAction AnalyzerDriverHelper.ExecuteAndCatchIfThrows(endAction.Analyzer, _addDiagnostic, continueOnAnalyzerException, () => { cancellationToken.ThrowIfCancellationRequested(); var compilationContext = new CompilationEndAnalysisContext(_compilation, this.analyzerOptions, _addDiagnostic, cancellationToken); endAction.Action(compilationContext); }, cancellationToken); } }, cancellationToken); tasks.Add(task); } await Task.WhenAll(tasks.ToArrayAndFree()).ConfigureAwait(false); } finally { endEvent.FlushCache(); } }