protected override void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action <Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilation);
if (attributeUsageAttribute == null)
{
return;
}
if (symbol.IsAbstract || !symbol.IsAttribute())
{
return;
}
if (attributeUsageAttribute == null)
{
return;
}
var hasAttributeUsageAttribute = symbol.GetAttributes().Any(attribute => attribute.AttributeClass == attributeUsageAttribute);
if (!hasAttributeUsageAttribute)
{
addDiagnostic(symbol.CreateDiagnostic(Rule, symbol.Name));
}
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(compilationContext =>
{
var obsoleteAttribute = compilationContext.Compilation.GetTypeByMetadataName("System.ObsoleteAttribute");
var exportAttributeV1 = compilationContext.Compilation.GetTypeByMetadataName("System.ComponentModel.Composition.ExportAttribute");
var importingConstructorAttributeV1 = compilationContext.Compilation.GetTypeByMetadataName("System.ComponentModel.Composition.ImportingConstructorAttribute");
var exportAttributeV2 = compilationContext.Compilation.GetTypeByMetadataName("System.Composition.ExportAttribute");
var importingConstructorAttributeV2 = compilationContext.Compilation.GetTypeByMetadataName("System.Composition.ImportingConstructorAttribute");
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
if (exportAttributeV1 is null && exportAttributeV2 is null)
{
// We don't need to check assemblies unless they're referencing MEF, so we're done
return;
}
compilationContext.RegisterSymbolAction(symbolContext =>
{
var namedType = (INamedTypeSymbol)symbolContext.Symbol;
var namedTypeAttributes = namedType.GetApplicableAttributes(attributeUsageAttribute);
AnalyzeSymbolForAttribute(ref symbolContext, obsoleteAttribute, exportAttributeV1, importingConstructorAttributeV1, namedType, namedTypeAttributes);
AnalyzeSymbolForAttribute(ref symbolContext, obsoleteAttribute, exportAttributeV2, importingConstructorAttributeV2, namedType, namedTypeAttributes);
}, SymbolKind.NamedType);
});
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(compilationContext =>
{
var mefV1ExportAttribute = WellKnownTypes.MEFV1ExportAttribute(compilationContext.Compilation);
var mefV2ExportAttribute = WellKnownTypes.MEFV2ExportAttribute(compilationContext.Compilation);
if (mefV1ExportAttribute == null || mefV2ExportAttribute == null)
{
// We don't need to check assemblies unless they're referencing both versions of MEF, so we're done
return;
}
;
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
var exportAttributes = new List <INamedTypeSymbol>()
{
mefV1ExportAttribute, mefV2ExportAttribute
};
compilationContext.RegisterSymbolAction(c => AnalyzeSymbol(c, exportAttributes, attributeUsageAttribute), SymbolKind.NamedType);
});
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(compilationContext =>
{
var exportAttribute = compilationContext.Compilation.GetTypeByMetadataName("System.Composition.ExportAttribute");
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
if (exportAttribute == null)
{
// We don't need to check assemblies unless they're referencing both MEFv2, so we're done
return;
}
compilationContext.RegisterSymbolAction(symbolContext =>
{
var namedType = (INamedTypeSymbol)symbolContext.Symbol;
var namedTypeAttributes = namedType.GetApplicableAttributes(attributeUsageAttribute);
var exportAttributeApplication = namedTypeAttributes.FirstOrDefault(ad => ad.AttributeClass.DerivesFrom(exportAttribute));
if (exportAttributeApplication != null)
{
if (!namedTypeAttributes.Any(ad => ad.AttributeClass.Name == "SharedAttribute" &&
ad.AttributeClass.ContainingNamespace.Equals(exportAttribute.ContainingNamespace)))
{
// '{0}' is exported with MEFv2 and hence must be marked as Shared
symbolContext.ReportDiagnostic(Diagnostic.Create(Rule, exportAttributeApplication.ApplicationSyntaxReference.GetSyntax().GetLocation(), namedType.Name));
}
}
}, SymbolKind.NamedType);
});
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(compilationContext =>
{
var exportAttributeV1 = WellKnownTypes.MEFV1ExportAttribute(compilationContext.Compilation);
var exportAttributeV2 = WellKnownTypes.MEFV2ExportAttribute(compilationContext.Compilation);
var inheritedExportAttribute = WellKnownTypes.InheritedExportAttribute(compilationContext.Compilation);
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
if (exportAttributeV1 is null && exportAttributeV2 is null)
{
// We don't need to check assemblies unless they're referencing MEF, so we're done
return;
}
compilationContext.RegisterSymbolAction(symbolContext =>
{
var namedType = (INamedTypeSymbol)symbolContext.Symbol;
var exportAttributes = namedType.GetApplicableExportAttributes(exportAttributeV1, exportAttributeV2, inheritedExportAttribute);
var namedTypeAttributes = namedType.GetApplicableAttributes(attributeUsageAttribute);
AnalyzeSymbolForAttribute(ref symbolContext, exportAttributeV1, namedType, exportAttributes, namedTypeAttributes);
AnalyzeSymbolForAttribute(ref symbolContext, exportAttributeV2, namedType, exportAttributes, namedTypeAttributes);
}, SymbolKind.NamedType);
});
}
protected override DiagnosticAnalyzerSymbolAnalyzer GetDiagnosticAnalyzerSymbolAnalyzer(CompilationStartAnalysisContext compilationContext, INamedTypeSymbol diagnosticAnalyzer, INamedTypeSymbol diagnosticAnalyzerAttribute)
{
Compilation compilation = compilationContext.Compilation;
INamedTypeSymbol compilationType = compilation.GetTypeByMetadataName(s_compilationTypeFullName);
if (compilationType == null)
{
return(null);
}
INamedTypeSymbol symbolType = compilation.GetTypeByMetadataName(s_symbolTypeFullName);
if (symbolType == null)
{
return(null);
}
INamedTypeSymbol operationType = compilation.GetTypeByMetadataName(s_operationTypeFullName);
if (operationType == null)
{
return(null);
}
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilation);
return(new FieldsAnalyzer(compilationType, symbolType, operationType, attributeUsageAttribute, diagnosticAnalyzer, diagnosticAnalyzerAttribute));
}
public override void Initialize(AnalysisContext analysisContext)
{
analysisContext.RegisterCompilationStartAction(compilationContext =>
{
INamedTypeSymbol attributeType = WellKnownTypes.Attribute(compilationContext.Compilation);
INamedTypeSymbol attributeUsageAttributeType = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
if (attributeType == null || attributeUsageAttributeType == null)
{
return;
}
compilationContext.RegisterSymbolAction(context =>
{
AnalyzeSymbol((INamedTypeSymbol)context.Symbol, attributeType, attributeUsageAttributeType, 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);
INamedTypeSymbol attributeUsageAttributeType = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
if (attributeType == null || attributeUsageAttributeType == null)
{
return;
}
compilationContext.RegisterSymbolAction(context =>
{
AnalyzeSymbol((INamedTypeSymbol)context.Symbol, attributeType, attributeUsageAttributeType, context.ReportDiagnostic);
},
SymbolKind.NamedType);
});
}
protected override DiagnosticAnalyzerSymbolAnalyzer GetDiagnosticAnalyzerSymbolAnalyzer(CompilationStartAnalysisContext compilationContext, INamedTypeSymbol diagnosticAnalyzer, INamedTypeSymbol diagnosticAnalyzerAttribute)
{
var attributeUsageAttribute = WellKnownTypes.AttributeUsageAttribute(compilationContext.Compilation);
return(new AttributeAnalyzer(diagnosticAnalyzer, diagnosticAnalyzerAttribute, attributeUsageAttribute));
}
