Migrate open-coded attribute lookups to SymbolExtensions.HasAttribute

[SergeyTeplyakov]

Summary

SymbolExtensions.HasAttribute was introduced alongside EPC42 (DataContractSerializableMemberAnalyzer):

public static bool HasAttribute(this ISymbol symbol, INamedTypeSymbol? attributeType)

Several analyzers predate it and open-code the same attribute lookup. This issue tracks migrating them so there is a single way to ask "is this symbol marked with attribute X?".

Purely a cleanup — no behavior change intended, and there are a few traps that make a blind find/replace wrong (see below).

Straightforward call sites

These are plain boolean checks against a resolved attribute type and map directly onto HasAttribute:

• EventSourceAnalysis/EventSourceAnalyzer.cs:278 — attributes.Any(a => a.AttributeClass?.IsClrType(compilation, typeof(NonEventAttribute)) == true)
• EventSourceAnalysis/EventSourceAnalyzer.cs:334 — same NonEventAttribute check, negated

Note both currently resolve the attribute type through CompilationExtensions.IsClrType (which does a GetTypeByFullName per call), whereas HasAttribute takes an already-resolved INamedTypeSymbol. Resolving the well-known type once in a RegisterCompilationStartAction and passing it down is the better shape and avoids the repeated lookup.

Call sites that need a companion helper first

HasAttribute returns bool, but these need the AttributeData itself, so they cannot migrate until we add something like TryGetAttribute / GetAttributeOrDefault returning AttributeData?:

• ExcludeFromCodeCoverageOnPartialClassAnalyzer.cs:32-44 — needs attribute.ApplicationSyntaxReference to compute the diagnostic location.
• EventSourceAnalysis/EventSourceAnalyzer.cs:284-285 — needs the EventAttribute instance to read its arguments.
• StructSizeCalculator.cs:68-75 — needs structLayoutAttribute.NamedArguments to read Size.

Proposal:

public static AttributeData? TryGetAttribute(this ISymbol symbol, INamedTypeSymbol? attributeType);

and implement HasAttribute on top of it, or keep them independent to preserve the allocation-free foreach in HasAttribute (it runs per-symbol).

Call sites that must NOT be migrated as-is

These match attributes by name rather than by symbol identity, which is deliberate — the attribute type is not referenced by the analyzer and may come from anywhere:

• CoreAnalyzers/MustUseResultAnalyzer.cs:91-95 — matches "MustUseResultAttribute" and JetBrains' "MustUseReturnValueAttribute" by name, in addition to the symbol-based check for our own MustUseResultAttribute. Swapping in HasAttribute would silently drop JetBrains annotation support.
• AsyncAnalyzers/ConfigureAwaitConfiguration.cs:12,17 — matches assembly-level attributes with Name.StartsWith("DoNotUseConfigureAwait") / "UseConfigureAwaitFalse"; users declare these attributes in their own assemblies, so there is no symbol to compare against.
• StructSizeCalculator.cs:69 — matches nameof(StructLayoutAttribute) by name.

If we want these covered too, it needs a separate name-based overload, e.g. HasAttributeWithName(this ISymbol symbol, string name), and it should be introduced consciously rather than as part of a mechanical sweep.

Suggested scope

1. Add TryGetAttribute (returning AttributeData?) next to HasAttribute in SymbolExtensions.
2. Migrate the two EventSourceAnalyzer boolean checks and the three AttributeData consumers listed above, hoisting the well-known type resolution to compilation start where it is easy.
3. Leave the name-based matchers alone, or introduce an explicit name-based overload in a follow-up.
4. No new tests needed — the existing analyzer tests must stay green (currently 418).

[SergeyTeplyakov]

Follow-up: also consolidate interface-implementation checks onto SymbolExtensions.ImplementsAny

EPC42 introduced a second shared helper next to HasAttribute:

public static bool ImplementsAny(this ITypeSymbol type, params INamedTypeSymbol?[] interfaceTypes);

It compares AllInterfaces[i].OriginalDefinition against already-resolved INamedTypeSymbols with SymbolEqualityComparer.Default, and tolerates null entries (an interface may be missing from the compilation). It should become the single way to ask "does this type implement interface X?".

Dead code to delete

NamedSymbolExtensions.IsDerivedFromInterface is the pre-existing answer to this question:

• NamedSymbolExtensions.cs:88 — IsDerivedFromInterface(this INamedTypeSymbol, Type) -> AllInterfaces.Any(s => s.IsType(type))
• NamedSymbolExtensions.cs:25 — IsType(this INamedTypeSymbol, Type) -> GetTypeQualifiedAssemblyName() == type.AssemblyQualifiedName

Both are brittle: they take a System.Type and compare assembly-qualified name strings, so the result depends on the assembly identity the analyzer itself was compiled against versus the one in the analyzed compilation. That breaks across target frameworks and type-forwarded types (e.g. System.Runtime vs mscorlib), and it silently returns false rather than failing loudly.

A grep over src/ shows neither has any call site outside its own file - IsDerivedFromInterface is called from nowhere, and IsType is called only from IsDerivedFromInterface. So the cleanest move is to delete both (and GetTypeQualifiedAssemblyName if nothing else uses it) rather than migrate them. ImplementsAny covers the use case correctly for any future caller.

Existing call sites worth reviewing

These open-code the AllInterfaces walk. They are not a straight swap because they match generic interfaces via IsGenericType(compilation, typeof(ISet<>)) rather than a resolved symbol, but they are the same question and would read better against a shared helper:

• CoreAnalyzers/SetContainsAnalyzer.cs:68-70
• EventSourceAnalysis/EventSourceAnalyzer.cs:390-392 (an exact duplicate of the above - the shared helper would also remove the copy/paste)
• CoreAnalyzers/MustUseResultAnalyzer.cs:73 - walks AllInterfaces to find interface implementations of a method, a different question; leave alone.

If we want the generic case covered, the shape would be an overload taking unbound generic definitions, e.g. ImplementsAnyConstructedFrom(this ITypeSymbol type, params INamedTypeSymbol?[] unboundInterfaces), resolved once at compilation start instead of per-call.

Updated scope

5. Delete IsDerivedFromInterface / IsType (dead, and unsound by construction); point any future caller at ImplementsAny.
6. Optionally de-duplicate the identical ISet<> checks in SetContainsAnalyzer and EventSourceAnalyzer behind a generic-aware overload.