@phuc1403/musketeer 0.12.0 → 0.14.0

package/template/.claude/skills/logical-components/scripts/LogicalComponents/MarkdownCodeSpans.cs

@@ -1,72 +0,0 @@
-using System.Text;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// CommonMark code-span parsing for <see cref="ResponsibilityValidation"/>'s plain-text check: a backtick run of
-/// length n opens a code span, which closes at the next run of exactly length n (a run of a different length inside is
-/// literal content; a run with no matching close is an unclosed delimiter, not a span). A naive `` `[^`]*` `` match
-/// gets this wrong for an escaped or mismatched backtick, which could let HTML or a link hide inside what looks like,
-/// but is not, a real code span.
-/// </summary>
-public static class MarkdownCodeSpans
-{
-    /// <summary>The text with every real code span removed, and whether any backtick run was left unmatched.</summary>
-    public static (string Outside, bool Unclosed) Strip(string text)
-    {
-        var outside = new StringBuilder();
-        var unclosed = false;
-        var i = 0;
-        while (i < text.Length)
-        {
-            if (text[i] != '`')
-            {
-                outside.Append(text[i]);
-                i++;
-                continue;
-            }
-
-            var openStart = i;
-            while (i < text.Length && text[i] == '`')
-            {
-                i++;
-            }
-
-            var openLength = i - openStart;
-            var closeStart = -1;
-            var j = i;
-            while (j < text.Length)
-            {
-                if (text[j] != '`')
-                {
-                    j++;
-                    continue;
-                }
-
-                var runStart = j;
-                while (j < text.Length && text[j] == '`')
-                {
-                    j++;
-                }
-
-                if (j - runStart == openLength)
-                {
-                    closeStart = runStart;
-                    break;
-                }
-            }
-
-            if (closeStart >= 0)
-            {
-                i = closeStart + openLength;
-            }
-            else
-            {
-                unclosed = true;
-                outside.Append('`', openLength);
-            }
-        }
-
-        return (outside.ToString(), unclosed);
-    }
-}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/MarkdownRenderer.cs

@@ -1,78 +0,0 @@
-using System.Text;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// Writes the final document: <c># Logical Components</c> (one section per component, sorted by display name, each
-/// responsibility with its citation) and <c># Coupling</c> (a legend, then a Mermaid flowchart of the extracted edges).
-/// Everything but the responsibility text comes from the deterministic extraction; the output has LF line endings and no
-/// timestamp.
-/// Call only with responsibilities that passed <see cref="ResponsibilityValidation"/>.
-/// </summary>
-public static class MarkdownRenderer
-{
-    /// <summary>
-    /// How to read the diagram, so incoming and outgoing arrows are not read backwards, and what it leaves out, so an
-    /// entry point with no incoming arrow is not mistaken for dead code.
-    /// </summary>
-    private const string Legend =
-        "`A --> B` means A depends on B: it calls, creates, holds or inherits from B. A component's incoming arrows are its "
-        + "afferent coupling, its outgoing arrows its efferent coupling. Only components in `*.Application` and "
-        + "`*.Infrastructure` projects are drawn; callers in other projects, such as the host, are not shown.";
-
-    public static string Render(
-        ExtractResult extraction, IReadOnlyDictionary<string, IReadOnlyList<Responsibility>> responsibilities)
-    {
-        var md = new StringBuilder();
-        md.Append("# Logical Components\n\n");
-        foreach (var component in extraction.Components
-                     .OrderBy(c => c.Name, StringComparer.Ordinal)
-                     .ThenBy(c => c.Id, StringComparer.Ordinal))
-        {
-            md.Append($"## {component.Name}\n\n");
-            md.Append($"`{SymbolNames.ReadableFullName(component.Type)}`\n\n");
-            foreach (var responsibility in responsibilities[component.Id])
-            {
-                md.Append($"- {responsibility.Text.Trim()} (`{Citation.Parse(responsibility.Cite)}`)\n");
-            }
-
-            md.Append('\n');
-        }
-
-        // ELK lays out a large flowchart far more readably than Mermaid's default dagre.
-        md.Append("# Coupling\n\n").Append(Legend).Append("\n\n```mermaid\n%%{init: {\"layout\": \"elk\"}}%%\nflowchart LR\n");
-        var nodes = extraction.Components
-            .Select(c => (c.Id, c.Name))
-            .Concat(extraction.ExternalNodes.Select(n => (n.Id, n.Name)))
-            .OrderBy(n => n.Id, StringComparer.Ordinal);
-        foreach (var (id, name) in nodes)
-        {
-            md.Append($"    {NodeId(id)}[\"{Escape(name)}\"]\n");
-        }
-
-        // A --> B: A depends on B (efferent for A, afferent for B). How A reaches B (di, new, static, inherits) is not
-        // drawn; it stays in components.json.
-        foreach (var edge in extraction.Edges)
-        {
-            md.Append($"    {NodeId(edge.From)} --> {NodeId(edge.To)}\n");
-        }
-
-        md.Append("```\n");
-        return md.ToString();
-    }
-
-    // Mermaid node labels are double-quoted; a literal quote is written as an entity. Angle brackets are escaped the
-    // same way: some renderers treat a label as HTML, and an unescaped `<` in a type or module name could otherwise
-    // inject markup into the diagram.
-    private static string Escape(string label) => label.Replace("\"", "#quot;").Replace("<", "#lt;").Replace(">", "#gt;");
-
-    /// <summary>
-    /// A Mermaid-safe node id: prefixed so a component called <c>end</c>, <c>graph</c> or <c>class</c> is never read as
-    /// a keyword, and every character that is not an ASCII letter or digit - including a literal underscore, so the
-    /// escape below cannot collide with one already in the id - is replaced by <c>_x{hex}_</c>. That makes the mapping
-    /// injective (two different ids always get two different node ids), unlike collapsing every such character to a
-    /// single <c>_</c>, which let ids as different as "My Module_Queue" and "My-Module.Queue" collide.
-    /// </summary>
-    private static string NodeId(string id) => "n_" + string.Concat(
-        id.Select(c => char.IsAsciiLetterOrDigit(c) ? c.ToString() : $"_x{(int)c:x}_"));
-}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/MemberUseResolution.cs

@@ -1,272 +0,0 @@
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// Follows what a component's code uses until it lands on another component. A use of a member of:
-/// <list type="bullet">
-/// <item>a component is an edge to it;</item>
-/// <item>an interface or abstract class (a seam) goes on to the member that runs in each implementation of the
-/// construction used (see <see cref="SeamDispatch"/>);</item>
-/// <item>any other type of the repo (a helper, a record, a non-candidate) is seen through: the code that runs for that
-/// use is walked the same way, with the helper's type parameters bound to the use's type arguments (see
-/// <see cref="TypeMap"/>). It is walked per member and per accessor, so reading one property never couples to what
-/// another member or the setter calls, and compiler-written record members run nothing.</item>
-/// </list>
-/// Framework and library members end the walk. The kind of an edge is the kind of the last use; its citation is the
-/// line in the component where the chain starts; <c>via</c> names the seams and seen-through types on the first path
-/// found (members already walked for a component are not walked again). The helper code walked is the component's
-/// <c>reaches</c>.
-/// </summary>
-public sealed class MemberUseResolution(LoadedWorkspace loaded, IReadOnlySet<string> components, PortResolution ports)
-{
-    // How many seen-through hops one chain may follow before it is cut off with a warning: real helper chains never
-    // run this deep, but a generic helper that instantiates itself one level deeper at every hop (Nest<T> calling
-    // Nest<List<T>>) never revisits the same (member, bindings) pair, so the cycle guard below never catches it and the
-    // walk would otherwise recurse until the process stack overflows.
-    private const int MaxWalkDepth = 200;
-
-    public sealed record RawEdge(string From, string To, string Kind, IReadOnlyList<string> Via, string File, int Line);
-
-    /// <summary>
-    /// The edges a component's code leads to, the helper code it runs on the way (sorted, distinct), and warnings about
-    /// coupling the walk could not fully resolve.
-    /// </summary>
-    public sealed record Resolution(List<RawEdge> Edges, List<SourceSpan> Reaches, List<string> Warnings);
-
-    // Shared by every component's walk: what a piece of syntax uses never changes within one loaded solution.
-    private readonly Dictionary<SyntaxNode, List<MemberUses.MemberUse>> _uses = [];
-    private readonly Dictionary<INamedTypeSymbol, bool> _repoSource = new(SymbolEqualityComparer.Default);
-
-    /// <summary>
-    /// The edges from <paramref name="from"/> reached by <paramref name="uses"/>. <paramref name="self"/> holds the
-    /// component and the base classes whose code counts as its own: uses of those are not coupling. <paramref name="map"/>
-    /// binds the type parameters of any base class among <paramref name="uses"/>' declaring types to what the component
-    /// supplies as its base class construction, so a generic base's own seam calls resolve to the right construction.
-    /// </summary>
-    public async Task<Resolution> ResolveAsync(
-        string from, IReadOnlySet<string> self, IEnumerable<MemberUses.MemberUse> uses, TypeMap map,
-        CancellationToken cancellationToken)
-    {
-        var walk = new Walk(from, self);
-        foreach (var use in uses)
-        {
-            await ResolveUseAsync(use.Member, use.Kind, [], use.File, use.Line, map, walk, cancellationToken);
-        }
-
-        return new Resolution(
-            walk.Edges,
-            walk.Reaches.OrderBy(s => s.File, StringComparer.Ordinal).ThenBy(s => s.Start).ThenBy(s => s.End).ToList(),
-            walk.Warnings.Order(StringComparer.Ordinal).ToList());
-    }
-
-    // One component's walk: members already seen through (for the same type bindings) are not walked again, which also
-    // ends cycles. Depth guards the chains a cycle can't catch (see MaxWalkDepth).
-    private sealed class Walk(string from, IReadOnlySet<string> self)
-    {
-        public string From { get; } = from;
-        public IReadOnlySet<string> Self { get; } = self;
-        public HashSet<string> Visited { get; } = new(StringComparer.Ordinal);
-        public List<RawEdge> Edges { get; } = [];
-        public HashSet<SourceSpan> Reaches { get; } = [];
-        public HashSet<string> Warnings { get; } = new(StringComparer.Ordinal);
-        public int Depth { get; set; }
-
-        public void Warn(string message) => Warnings.Add(message);
-    }
-
-    private async Task ResolveUseAsync(
-        ISymbol member,
-        string kind,
-        ImmutableList<string> via,
-        string file,
-        int line,
-        TypeMap map,
-        Walk walk,
-        CancellationToken cancellationToken)
-    {
-        // A C# 14 extension member belongs to the static class around its extension block.
-        var declaring = member.ContainingType is { IsExtension: true } block ? block.ContainingType : member.ContainingType;
-        if (declaring is null)
-        {
-            return;
-        }
-
-        if (map.Substitute(declaring) is INamedTypeSymbol bound)
-        {
-            declaring = bound;
-        }
-
-        var owner = EdgeExtraction.Normalize(declaring.OriginalDefinition);
-        if (!IsRepo(owner) || walk.Self.Contains(SymbolNames.FullName(owner)))
-        {
-            return;
-        }
-
-        if (components.Contains(SymbolNames.FullName(owner)))
-        {
-            walk.Edges.Add(new RawEdge(walk.From, SymbolNames.FullName(owner), kind, via, file, line));
-            return;
-        }
-
-        if (EdgeExtraction.IsSeam(declaring) && !member.IsStatic && kind != EdgeExtraction.New)
-        {
-            // A concrete, non-virtual member of an abstract class cannot be overridden: it runs as written for every
-            // subclass (or none), so it is this walk's own behaviour rather than a per-implementation dispatch.
-            if (declaring.TypeKind == TypeKind.Class && !IsOverridable(member))
-            {
-                await SeeThroughAsync(member, kind, via.Add(SymbolNames.FullName(declaring)), file, line, map, walk, cancellationToken);
-                return;
-            }
-
-            var implementations = await ports.ImplementationsAsync(declaring, cancellationToken);
-            if (implementations.Count == 0 && declaring.TypeKind == TypeKind.Class)
-            {
-                walk.Warn($"{SymbolNames.FullName(declaring.OriginalDefinition)}.{member.Name} has no concrete subclass in the repo");
-            }
-
-            foreach (var implementation in implementations)
-            {
-                if (SeamDispatch.ImplementationOf(implementation, declaring, member) is not { } runs)
-                {
-                    continue;
-                }
-
-                // An inherited default body lives on the seam itself: walk it rather than resolve the seam again.
-                if (runs.ContainingType is { } runsIn && EdgeExtraction.IsSeam(runsIn))
-                {
-                    await SeeThroughAsync(runs, kind, via.Add(SymbolNames.FullName(declaring)), file, line, map, walk, cancellationToken);
-                }
-                else
-                {
-                    // Bind the implementation's own type parameters (an open-generic decorator) and the resolved
-                    // method's own type parameters (a generic method declared on the seam) to what this use actually
-                    // supplies, so a seam the implementation calls in turn resolves to the right construction too.
-                    var binding = SeamDispatch.BindingFor(implementation, declaring, member, runs, map);
-                    await ResolveUseAsync(runs, kind, via.Add(SymbolNames.FullName(declaring)), file, line, binding, walk, cancellationToken);
-                }
-            }
-
-            return;
-        }
-
-        await SeeThroughAsync(member, kind, via.Add(SymbolNames.FullName(owner)), file, line, map, walk, cancellationToken);
-    }
-
-    private async Task SeeThroughAsync(
-        ISymbol member,
-        string kind,
-        ImmutableList<string> via,
-        string file,
-        int line,
-        TypeMap map,
-        Walk walk,
-        CancellationToken cancellationToken)
-    {
-        // Compiler-written members (a record's ToString/Equals/Deconstruct, an auto-property accessor) run nothing of the
-        // type's own code; their declaring syntax is the whole type, which must not be walked. Constructors still run
-        // initializers. Using an instance field runs no code: its initializer ran when the object was constructed.
-        if ((member.IsImplicitlyDeclared && kind != EdgeExtraction.New) || member is IFieldSymbol { IsStatic: false })
-        {
-            return;
-        }
-
-        var inner = map.For(member);
-        var key = (kind == EdgeExtraction.New ? "new " : "") + SymbolNames.MemberId(member) + "|" + inner.Key;
-        if (!walk.Visited.Add(key))
-        {
-            return;
-        }
-
-        // A cycle that never repeats a (member, bindings) pair (a generic helper instantiating itself one level
-        // deeper at every hop) would otherwise recurse until the process stack overflows: cut it off instead.
-        if (walk.Depth >= MaxWalkDepth)
-        {
-            walk.Warn($"{walk.From}: coupling walk stopped at depth {MaxWalkDepth} following {member.Name}, possible unbounded generic recursion");
-            return;
-        }
-
-        walk.Depth++;
-        try
-        {
-            var (roots, runsImplicitBase) = kind == EdgeExtraction.New && member is IMethodSymbol constructor
-                ? WalkRoots.Construction(constructor)
-                : (WalkRoots.Body(member), false);
-            Record(roots, walk);
-
-            foreach (var root in roots)
-            {
-                foreach (var use in await UsesAsync(root, cancellationToken))
-                {
-                    await ResolveUseAsync(use.Member, use.Kind, via, file, line, inner, walk, cancellationToken);
-                }
-            }
-
-            if (runsImplicitBase
-                && member.ContainingType.BaseType?.InstanceConstructors.FirstOrDefault(c => c.Parameters.Length == 0) is { } baseConstructor)
-            {
-                await ResolveUseAsync(baseConstructor, EdgeExtraction.New, via, file, line, inner, walk, cancellationToken);
-            }
-
-            // The static constructor runs once, lazily, before the type's first static member use or instantiation:
-            // consistent with a static field's own initializer, which is already walked wherever that field is read.
-            if ((kind == EdgeExtraction.Static || kind == EdgeExtraction.New)
-                && member.ContainingType?.OriginalDefinition.StaticConstructors.FirstOrDefault(c => !c.IsImplicitlyDeclared)
-                    is { } staticConstructor)
-            {
-                await ResolveUseAsync(staticConstructor, EdgeExtraction.Call, via, file, line, inner, walk, cancellationToken);
-            }
-        }
-        finally
-        {
-            walk.Depth--;
-        }
-    }
-
-    /// <summary>A method, property or event that a subclass could give a different body: dispatch, not fixed code.</summary>
-    private static bool IsOverridable(ISymbol member) => member switch
-    {
-        IMethodSymbol method => method.IsVirtual || method.IsAbstract || method.IsOverride,
-        IPropertySymbol property => property.IsVirtual || property.IsAbstract || property.IsOverride,
-        IEventSymbol @event => @event.IsVirtual || @event.IsAbstract || @event.IsOverride,
-        _ => false,
-    };
-
-    // The walked helper code becomes citable for the component; a parameter declares a value and runs nothing.
-    private void Record(IEnumerable<SyntaxNode> roots, Walk walk)
-    {
-        foreach (var root in roots.Where(r => r is not (ParameterSyntax or ParameterListSyntax)))
-        {
-            var (sourceKind, relative) = CitableSource.Classify(loaded, root.SyntaxTree);
-            if (sourceKind == CitableSource.Kind.InRepo)
-            {
-                var lines = root.GetLocation().GetLineSpan();
-                walk.Reaches.Add(new SourceSpan(relative, lines.StartLinePosition.Line + 1, lines.EndLinePosition.Line + 1));
-            }
-        }
-    }
-
-    private async Task<List<MemberUses.MemberUse>> UsesAsync(SyntaxNode root, CancellationToken cancellationToken)
-    {
-        if (!_uses.TryGetValue(root, out var uses))
-        {
-            uses = await MemberUses.ReadAsync([root], loaded, cancellationToken);
-            _uses[root] = uses;
-        }
-
-        return uses;
-    }
-
-    private bool IsRepo(INamedTypeSymbol type)
-    {
-        if (!_repoSource.TryGetValue(type, out var isRepo))
-        {
-            isRepo = CitableSource.IsRepoSource(type, loaded);
-            _repoSource[type] = isRepo;
-        }
-
-        return isRepo;
-    }
-}

package/template/.claude/skills/logical-components/scripts/LogicalComponents/MemberUses.cs

@@ -1,231 +0,0 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
-namespace LogicalComponents;
-
-/// <summary>
-/// Reads what a piece of code uses, as members: <c>new</c> (the constructor an object creation, a <c>: this(...)</c> /
-/// <c>: base(...)</c> initializer or a primary-constructor base call runs), <c>static</c> (a static member, an extension
-/// method or C# 14 extension member, a user-defined operator or conversion) and <c>call</c> (an instance member used on
-/// any receiver, an indexer or conditional-access indexer, the enumerator, deconstruction and <c>MoveNext</c>/<c>Current</c>
-/// a <c>foreach</c> runs, the <c>Add</c> a collection initializer element runs, a deconstruction assignment's
-/// <c>Deconstruct</c>, and the <c>GetAwaiter</c>/<c>IsCompleted</c>/<c>GetResult</c> an <c>await</c> runs). A property or
-/// indexer use is the accessor that actually runs: a read is the getter, an assignment the setter, a compound
-/// assignment or increment both. Attribute names are not uses: an attribute is metadata the compiler reads, not code the
-/// annotated member runs. Only citable source is read, so generator output never contributes. What a use couples to is
-/// decided by <see cref="MemberUseResolution"/>.
-/// </summary>
-public static class MemberUses
-{
-    /// <summary>One use of <see cref="Member"/>, at a repo-relative file and 1-based line.</summary>
-    public sealed record MemberUse(ISymbol Member, string Kind, string File, int Line);
-
-    /// <summary>
-    /// Every member use inside the given syntax nodes, in source order. Nodes outside the repo, and nodes inside an
-    /// attribute list, are skipped.
-    /// </summary>
-    public static async Task<List<MemberUse>> ReadAsync(
-        IEnumerable<SyntaxNode> roots, LoadedWorkspace loaded, CancellationToken cancellationToken)
-    {
-        var uses = new List<MemberUse>();
-        foreach (var root in roots)
-        {
-            var (kind, file) = CitableSource.Classify(loaded, root.SyntaxTree);
-            if (kind != CitableSource.Kind.InRepo || loaded.Solution.GetDocument(root.SyntaxTree) is not { } document)
-            {
-                continue;
-            }
-
-            var model = await document.GetSemanticModelAsync(cancellationToken)
-                ?? throw new InvalidOperationException($"No semantic model for {file}");
-
-            // An attribute name resolves to its constructor, but applying an attribute is not running code: never
-            // descend into an attribute list at all, so nothing inside one is ever read as a use.
-            foreach (var node in root.DescendantNodesAndSelf(descendant => descendant is not AttributeListSyntax))
-            {
-                var line = node.GetLocation().GetLineSpan().StartLinePosition.Line + 1;
-                uses.AddRange(Uses(node, model, cancellationToken).Select(u => new MemberUse(u.Member, u.Kind, file, line)));
-            }
-        }
-
-        return uses;
-    }
-
-    private static IEnumerable<(ISymbol Member, string Kind)> Uses(SyntaxNode node, SemanticModel model, CancellationToken token)
-    {
-        ISymbol? Symbol() => model.GetSymbolInfo(node, token).Symbol;
-        (ISymbol, string) AsUse(ISymbol member) => (member, member.IsStatic ? EdgeExtraction.Static : EdgeExtraction.Call);
-
-        switch (node)
-        {
-            case BaseObjectCreationExpressionSyntax or ConstructorInitializerSyntax or PrimaryConstructorBaseTypeSyntax:
-                if (Symbol() is IMethodSymbol constructor)
-                {
-                    yield return (constructor, EdgeExtraction.New);
-                }
-
-                break;
-            case SimpleNameSyntax name when !IsInsideNameOf(name, model):
-                foreach (var use in Classify(Symbol(), name))
-                {
-                    yield return use;
-                }
-
-                break;
-            case ElementAccessExpressionSyntax or ElementBindingExpressionSyntax when Symbol() is IPropertySymbol indexer:
-                foreach (var accessor in AccessorsThatRun(indexer, node))
-                {
-                    yield return (accessor, EdgeExtraction.Call);
-                }
-
-                break;
-            case BinaryExpressionSyntax or PrefixUnaryExpressionSyntax or PostfixUnaryExpressionSyntax
-                or CastExpressionSyntax or AssignmentExpressionSyntax
-                when Symbol() is IMethodSymbol { MethodKind: MethodKind.UserDefinedOperator or MethodKind.Conversion } op:
-                yield return (op, EdgeExtraction.Static);
-                break;
-            // A deconstruction assignment, `(a, b) = point;`: tried before the operator-assignment case above, but only
-            // claims the node when it is actually a deconstruction, so a plain or compound assignment still falls
-            // through to it.
-            case AssignmentExpressionSyntax assignment when DeconstructMethods(model.GetDeconstructionInfo(assignment)).ToList()
-                is { Count: > 0 } assignmentDeconstructs:
-                foreach (var method in assignmentDeconstructs)
-                {
-                    yield return AsUse(method);
-                }
-
-                break;
-            case CommonForEachStatementSyntax loop:
-                var info = model.GetForEachStatementInfo(loop);
-                foreach (var member in new ISymbol?[] { info.GetEnumeratorMethod, info.MoveNextMethod, info.CurrentProperty?.GetMethod })
-                {
-                    if (member is not null)
-                    {
-                        yield return AsUse(member);
-                    }
-                }
-
-                // foreach (var (a, b) in pairs): the per-element deconstruction, same as an explicit assignment's.
-                if (loop is ForEachVariableStatementSyntax deconstructingLoop)
-                {
-                    foreach (var method in DeconstructMethods(model.GetDeconstructionInfo(deconstructingLoop)))
-                    {
-                        yield return AsUse(method);
-                    }
-                }
-
-                break;
-            case InitializerExpressionSyntax initializer when initializer.IsKind(SyntaxKind.CollectionInitializerExpression):
-                foreach (var element in initializer.Expressions)
-                {
-                    if (model.GetCollectionInitializerSymbolInfo(element).Symbol is IMethodSymbol add)
-                    {
-                        yield return AsUse(add);
-                    }
-                }
-
-                break;
-            case AwaitExpressionSyntax awaitExpression:
-                var awaited = model.GetAwaitExpressionInfo(awaitExpression);
-                foreach (var member in new ISymbol?[] { awaited.GetAwaiterMethod, awaited.IsCompletedProperty?.GetMethod, awaited.GetResultMethod })
-                {
-                    if (member is not null)
-                    {
-                        yield return AsUse(member);
-                    }
-                }
-
-                break;
-        }
-    }
-
-    /// <summary>The Deconstruct methods a deconstruction runs, including any nested tuple/pattern's own.</summary>
-    private static IEnumerable<IMethodSymbol> DeconstructMethods(DeconstructionInfo info)
-    {
-        if (info.Method is { } method)
-        {
-            yield return method;
-        }
-
-        foreach (var nested in info.Nested)
-        {
-            foreach (var method2 in DeconstructMethods(nested))
-            {
-                yield return method2;
-            }
-        }
-    }
-
-    /// <summary>
-    /// A symbol a name refers to, as uses: static or extension members are <c>static</c> (a classic extension method is
-    /// seen as its unreduced static form), other members are <c>call</c>, a property is the accessors that run. Locals,
-    /// parameters, types, namespaces and consts (copied into the caller at compile time) are not uses.
-    /// </summary>
-    private static IEnumerable<(ISymbol, string)> Classify(ISymbol? symbol, SyntaxNode usage)
-    {
-        var kind = symbol is not null && (symbol.IsStatic || symbol.ContainingType is { IsExtension: true })
-            ? EdgeExtraction.Static
-            : EdgeExtraction.Call;
-        switch (symbol)
-        {
-            case IFieldSymbol { IsConst: true }:
-            case IMethodSymbol { MethodKind: MethodKind.LocalFunction or MethodKind.AnonymousFunction }:
-                break;
-            case IMethodSymbol { ReducedFrom: { } extension }:
-                yield return (extension, EdgeExtraction.Static);
-                break;
-            case IPropertySymbol property:
-                foreach (var accessor in AccessorsThatRun(property, usage))
-                {
-                    yield return (accessor, kind);
-                }
-
-                break;
-            case IMethodSymbol or IFieldSymbol or IEventSymbol:
-                yield return (symbol, kind);
-                break;
-        }
-    }
-
-    /// <summary>
-    /// The accessors a property or indexer use runs, from where it stands: the target of <c>=</c> (including an object
-    /// initializer) runs the setter; a compound assignment, <c>++</c>/<c>--</c>, or a <c>ref</c>/<c>out</c> argument runs
-    /// both; anything else is a read and runs the getter. An accessor the property does not have runs nothing.
-    /// </summary>
-    private static IEnumerable<IMethodSymbol> AccessorsThatRun(IPropertySymbol property, SyntaxNode usage)
-    {
-        // The whole access expression: `a.B` for the name B, `a?.B` for a conditional access, the name itself otherwise.
-        var access = usage.Parent switch
-        {
-            MemberAccessExpressionSyntax member when member.Name == usage => member,
-            MemberBindingExpressionSyntax binding => (SyntaxNode)binding,
-            _ => usage,
-        };
-
-        var (reads, writes) = access.Parent switch
-        {
-            AssignmentExpressionSyntax assignment when assignment.Left == access =>
-                (!assignment.IsKind(SyntaxKind.SimpleAssignmentExpression), true),
-            PrefixUnaryExpressionSyntax or PostfixUnaryExpressionSyntax => (true, true),
-            ArgumentSyntax { RefKindKeyword.RawKind: not 0 } => (true, true),
-            _ => (true, false),
-        };
-
-        if (reads && property.GetMethod is { } getter)
-        {
-            yield return getter;
-        }
-
-        if (writes && property.SetMethod is { } setter)
-        {
-            yield return setter;
-        }
-    }
-
-    // nameof(Foo.Bar) mentions a member without using it.
-    private static bool IsInsideNameOf(SyntaxNode node, SemanticModel model) =>
-        node.Ancestors().OfType<InvocationExpressionSyntax>().Any(invocation =>
-            invocation.Expression is IdentifierNameSyntax { Identifier.Text: "nameof" }
-            && model.GetSymbolInfo(invocation).Symbol is null);
-}