internal SourceAttributeData(
SyntaxReference?applicationNode,
NamedTypeSymbol?attributeClass,
MethodSymbol?attributeConstructor,
ImmutableArray <TypedConstant> constructorArguments,
ImmutableArray <int> constructorArgumentsSourceIndices,
ImmutableArray <KeyValuePair <string, TypedConstant> > namedArguments,
bool hasErrors,
bool isConditionallyOmitted)
{
Debug.Assert(!isConditionallyOmitted || attributeClass is object && attributeClass.IsConditional);
Debug.Assert(!constructorArguments.IsDefault);
Debug.Assert(!namedArguments.IsDefault);
Debug.Assert(constructorArgumentsSourceIndices.IsDefault ||
constructorArgumentsSourceIndices.Any() && constructorArgumentsSourceIndices.Length == constructorArguments.Length);
Debug.Assert(attributeConstructor is object || hasErrors);
_attributeClass = attributeClass;
_attributeConstructor = attributeConstructor;
_constructorArguments = constructorArguments;
_constructorArgumentsSourceIndices = constructorArgumentsSourceIndices;
_namedArguments = namedArguments;
_isConditionallyOmitted = isConditionallyOmitted;
_hasErrors = hasErrors;
_applicationNode = applicationNode;
}
public static Diagnostic CreateDiagnostic(
this AttributeData attributeData,
DiagnosticDescriptor descriptor,
params object[] args)
{
SyntaxReference?syntaxReference = attributeData.ApplicationSyntaxReference;
Location location = syntaxReference is not null
? syntaxReference.SyntaxTree.GetLocation(syntaxReference.Span)
: Location.None;
return(location.CreateDiagnostic(descriptor, args));
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(context =>
{
if (!context.Compilation.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemRuntimeCompilerServicesModuleInitializerAttribute, out var moduleInitializerAttribute))
{
return;
}
// Only validate libraries (which will still produce some false positives, but that is acceptable)
if (context.Compilation.Options.OutputKind != OutputKind.DynamicallyLinkedLibrary)
{
return;
}
context.RegisterSymbolAction(context =>
{
if (context.Symbol is IMethodSymbol method)
{
// Eliminate methods that would fail the CS8814, CS8815, and CS8816 checks
// for what can have [ModuleInitializer] applied
if (method.GetResultantVisibility() == SymbolVisibility.Private ||
method.Parameters.Length > 0 ||
method.IsGenericMethod ||
method.ContainingType.IsGenericType ||
!method.IsStatic ||
!method.ReturnsVoid)
{
return;
}
AttributeData?initializerAttribute = context.Symbol.GetAttributes(moduleInitializerAttribute).FirstOrDefault();
SyntaxReference?attributeReference = initializerAttribute?.ApplicationSyntaxReference;
if (attributeReference is not null)
{
context.ReportDiagnostic(attributeReference.GetSyntax(context.CancellationToken).CreateDiagnostic(Rule));
}
}
},
SymbolKind.Method);
});
}
internal static CSharpSyntaxNode GetNonNullSyntaxNode(this Symbol?symbol)
{
if (symbol is object)
{
SyntaxReference?reference = symbol.DeclaringSyntaxReferences.FirstOrDefault();
if (reference == null && symbol.IsImplicitlyDeclared)
{
Symbol?containingSymbol = symbol.ContainingSymbol;
if ((object?)containingSymbol != null)
{
reference = containingSymbol.DeclaringSyntaxReferences.FirstOrDefault();
}
}
if (reference != null)
{
return((CSharpSyntaxNode)reference.GetSyntax());
}
}
return((CSharpSyntaxNode)CSharpSyntaxTree.Dummy.GetRoot());
}
public static Location GetLocation(this SyntaxReference? @this)
{
return(@this?.SyntaxTree.GetLocation(@this.Span) ?? Location.None);
}
public static void Report(GeneratorExecutionContext context, DiagnosticDescriptor desc, SyntaxReference?syntax, bool throwException, params object[] args)
{
context.ReportDiagnostic(Diagnostic.Create(desc, syntax == null ? Location.None : Location.Create(syntax.SyntaxTree, syntax.Span), args));
var message = String.Format(desc.MessageFormat.ToString(), args);
System.Console.WriteLine(message);
if (throwException)
{
throw new Exception(message);
}
}
internal ImportedXmlNamespace(string xmlNamespace, SyntaxReference?declaringSyntaxReference)
{
XmlNamespace = xmlNamespace;
DeclaringSyntaxReference = declaringSyntaxReference;
}
public static void Report(GeneratorExecutionContext context, DiagnosticDescriptor desc, SyntaxReference?syntax, params object[] args)
{
System.Console.WriteLine(String.Format(desc.MessageFormat.ToString(), args));
context.ReportDiagnostic(Diagnostic.Create(desc, syntax == null ? Location.None : Location.Create(syntax.SyntaxTree, syntax.Span), args));
}
internal ImportedNamespaceOrType(INamespaceOrTypeSymbol namespaceOrType, SyntaxReference?declaringSyntaxReference)
{
NamespaceOrType = namespaceOrType;
DeclaringSyntaxReference = declaringSyntaxReference;
}
public AliasAndExternAliasDirective(AliasSymbol alias, ExternAliasDirectiveSyntax?externAliasDirective, bool skipInLookup)
{
this.Alias = alias;
this.ExternAliasDirectiveReference = externAliasDirective?.GetReference();
this.SkipInLookup = skipInLookup;
}
internal bool TryGetSyntaxReference([NotNullWhen(true)] out SyntaxReference?syntaxReference)
{
return(this.Symbol.DeclaringSyntaxReferences.TrySingle(out syntaxReference));
}
public AliasAndUsingDirective(AliasSymbol alias, UsingDirectiveSyntax?usingDirective)
{
this.Alias = alias;
this.UsingDirectiveReference = usingDirective?.GetReference();
}
public NamespaceOrTypeAndUsingDirective(NamespaceOrTypeSymbol namespaceOrType, UsingDirectiveSyntax?usingDirective, ImmutableArray <AssemblySymbol> dependencies)
{
this.NamespaceOrType = namespaceOrType;
this.UsingDirectiveReference = usingDirective?.GetReference();
this.Dependencies = dependencies.NullToEmpty();
}