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(); }