[efficiency-improver] perf: eliminate LINQ iterator allocations in MSTest Analyzer DerivesFrom interface check

[Evangelink]

Goal and Rationale

Eliminate up to 2 heap-allocated LINQ iterator state machines from DerivesFrom() in ITypeSymbolExtensions.cs, a helper called by Inherits(), which is invoked 36+ times across the MSTest.Analyzers suite — once per method/type symbol during analysis.

Focus Area: Code-Level Efficiency — removing redundant iterator allocations in a per-symbol hot path.

Approach

The original code used a three-step LINQ chain over ImmutableArray<INamedTypeSymbol>:

// Before: up to 2 heap iterator allocations per call
IEnumerable<ITypeSymbol> allInterfaces = symbol.AllInterfaces.OfType<ITypeSymbol>();  // iterator #1
if (useOrigDef)
    allInterfaces = allInterfaces.Select(i => i.OriginalDefinition);                  // iterator #2
if (allInterfaces.Contains(candidateBaseType, SymbolEqualityComparer.Default))        // traverses both
    return true;

Replaced with a single direct foreach loop:

// After: zero heap allocations (ImmutableArray<T> struct enumerator)
bool useOriginalDefinition = SymbolEqualityComparer.Default.Equals(
    candidateBaseType.OriginalDefinition, candidateBaseType);
foreach (INamedTypeSymbol iface in symbol.AllInterfaces)
{
    ITypeSymbol candidate = useOriginalDefinition ? iface.OriginalDefinition : iface;
    if (SymbolEqualityComparer.Default.Equals(candidate, candidateBaseType))
        return true;
}

ImmutableArray<T>.GetEnumerator() returns a struct enumerator, so the foreach above is zero-allocation — it compiles directly to an index-based loop over the backing array.

Energy Efficiency Evidence

Proxy metric: managed heap allocations per analyzer invocation (GC pressure / DRAM churn).

	Before	After
OfType<ITypeSymbol>() iterator	1 heap alloc per DerivesFrom call on an interface	0
Select(i => i.OriginalDefinition) iterator	1 heap alloc (conditional — when candidate is non-generic)	0
Iterator traversal in Contains	through 1–2 state machine wrappers	direct index loop

DerivesFrom / Inherits is called at least once per method and class symbol the analyzer visits. In a project with 200 test methods across 30 classes, a single background analysis pass fires these 36+ times — before any class-level attribute checks. Removing the iterator allocations lowers Gen-0 GC pressure across the entire IDE and CI analysis lifecycle.

Reasoning linking proxy to energy: Each Gen-0 collection pauses the analysis thread briefly, consuming CPU cycles that produce no useful work. Fewer short-lived allocations → fewer collections → less wasted CPU energy per compilation.

Green Software Foundation Context

🌱 Hardware Efficiency: Using the ImmutableArray struct enumerator avoids indirection through a virtual MoveNext() dispatch chain, making better use of the hardware's instruction pipeline.

🌱 Software Carbon Intensity (SCI): MSTest.Analyzers runs on every developer machine and every CI build in any MSTest project. Reducing per-symbol allocation compounds across millions of analysis invocations per day across the .NET ecosystem.

Trade-offs

None. The logic is semantically identical:

• INamedTypeSymbol : ITypeSymbol, so OfType<ITypeSymbol>() was a no-op type filter (every element already satisfies the constraint).
• The ternary useOriginalDefinition ? iface.OriginalDefinition : iface exactly mirrors the original Select(i => i.OriginalDefinition) branch.
• Contains with SymbolEqualityComparer.Default is replicated by the if (Equals(candidate, candidateBaseType)) early-return.

The resulting code is also shorter and easier to read.

Reproducibility

# Run all MSTest.Analyzers unit tests (covers DerivesFrom indirectly via every
# analyzer that calls Inherits() in its AnalyzeSymbol callback):
dotnet run --project test/UnitTests/MSTest.Analyzers.UnitTests -f net8.0 --no-build

Test Status

CI validation pending (no local .NET SDK in agent environment). The change is a pure algorithmic refactor — identical semantics, different allocation profile. All 36+ call sites in the analyzer suite exercise this code path via their existing unit tests.

🤖 Automated content by GitHub Copilot. Posted via a maintainer's GitHub token, so it appears under their account — the account owner did not write or approve this content personally. Generated by the Efficiency Improver workflow. · 1.5K AIC · ⌖ 39.6 AIC · ⊞ 58.8K · [◷]( · ◷)

Add this agentic workflows to your repo

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/efficiency-improver.md@main

[Copilot]

Pull request overview

This PR improves the performance of the MSTest.Analyzers Roslyn helper ITypeSymbolExtensions.DerivesFrom() by removing a LINQ-based interface check and replacing it with a direct foreach over ImmutableArray<INamedTypeSymbol>, eliminating iterator allocations in a hot analyzer path.

Changes:

• Replaced AllInterfaces.OfType(...).Select(...).Contains(...) with a single allocation-free foreach loop.
• Preserved the existing “compare using OriginalDefinition when the candidate type is not constructed” behavior.

Show a summary per file

File	Description
src/Analyzers/MSTest.Analyzers/RoslynAnalyzerHelpers/ITypeSymbolExtensions.cs	Refactors the interface branch of DerivesFrom() to avoid LINQ iterator allocations by iterating symbol.AllInterfaces directly.

Review details

• Files reviewed: 1/1 changed files
• Comments generated: 0
• Review effort level: Low

[Evangelink]

Note

🤖 Automated review by GitHub Copilot. Posted via a maintainer's GitHub token, so it appears under their account — the account owner did not write or approve this content personally. Generated by the Expert Code Review workflow. To request a follow-up action, reply by tagging @copilot directly.

#	Dimension	Verdict
17	Documentation Accuracy	💬 1 NIT

✅ 21/22 dimensions clean.

• Documentation — inline comment on line 58 references deleted code; see inline comment for a suggested replacement.

---

Correctness confirmed (D1): The condition mapping is semantically equivalent to the original. useOriginalDefinition is true exactly when SymbolEqualityComparer.Default.Equals(candidateBaseType.OriginalDefinition, candidateBaseType) holds — i.e. the candidate is a non-generic or unbound-generic type. The original code applied Select(i => i.OriginalDefinition) under the same condition; the new code does iface.OriginalDefinition inline. Verified against concrete cases: IDisposable (non-generic), IList<T> (open generic), and IList<string> (constructed generic) all produce identical results.

Performance claim confirmed (D5): ImmutableArray<T>.GetEnumerator() returns ImmutableArray<T>.Enumerator, a struct — zero heap allocation for the loop itself. The original OfType<ITypeSymbol>() (a no-op filter since every INamedTypeSymbol already satisfies ITypeSymbol) allocated one LINQ iterator state machine unconditionally; the conditional Select() added a second. Both are eliminated. The claim in the block comment is accurate.

Test coverage (D13, observation): No tests are added, which is acceptable here — this is a pure behavior-preserving refactoring and the refactored path is exercised indirectly by the existing unit tests for every analyzer that calls Inherits().