@phuc1403/musketeer 0.10.0 → 0.12.0

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

@@ -0,0 +1,197 @@
+using System.Text.RegularExpressions;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// Checks the agents' responsibilities against the deterministic extraction before anything is rendered. Agents may
+/// only describe the components extract found; every component needs at least one responsibility; each is one plain
+/// line of text, said once; and its citation must cover real code inside that component's own declaration. All problems
+/// are reported at once, sorted by component id then item, so a retry can fix everything in one pass.
+/// </summary>
+public static partial class ResponsibilityValidation
+{
+    public const int MaxCitedLines = 60;
+    public const int MaxTextLength = 300;
+
+    /// <param name="sourceLines">The lines of every file a component is declared in, keyed by repo-relative path.</param>
+    /// <param name="fileOf">Which batch file each responsibility id came from, to route unknown-id errors.</param>
+    public static List<string> Validate(
+        ExtractResult extraction,
+        IReadOnlyDictionary<string, IReadOnlyList<Responsibility>> responsibilities,
+        IReadOnlyDictionary<string, IReadOnlyList<string>> sourceLines,
+        IReadOnlyDictionary<string, string>? fileOf = null)
+    {
+        var errors = new List<(string Id, int Item, string Message)>();
+        var components = extraction.Components.ToDictionary(c => c.Id, StringComparer.Ordinal);
+        // Computed once per file and reused across every citation into it, since CiteProblem may be called many
+        // times for the same file (several components, or several responsibilities of one component).
+        var codeLines = new Dictionary<string, IReadOnlyList<bool>>(StringComparer.Ordinal);
+
+        foreach (var id in responsibilities.Keys.Where(id => !components.ContainsKey(id)))
+        {
+            errors.Add((id, 0, UnknownId(id, components.Keys, fileOf)));
+        }
+
+        foreach (var component in extraction.Components)
+        {
+            if (!responsibilities.TryGetValue(component.Id, out var items) || items.Count == 0)
+            {
+                errors.Add((component.Id, 0, $"{component.Id}: no responsibilities"));
+                continue;
+            }
+
+            var seen = new Dictionary<string, int>(StringComparer.Ordinal);
+            for (var index = 0; index < items.Count; index++)
+            {
+                var item = index + 1;
+                var prefix = $"{component.Id}[{item}]: ";
+                if (TextProblem(items[index].Text) is { } textProblem)
+                {
+                    errors.Add((component.Id, item, prefix + textProblem));
+                }
+                else if (!seen.TryAdd(Normalize(items[index].Text), item))
+                {
+                    errors.Add((component.Id, item, $"{prefix}repeats item {seen[Normalize(items[index].Text)]}"));
+                }
+
+                if (CiteProblem(items[index].Cite, component, sourceLines, codeLines) is { } citeProblem)
+                {
+                    errors.Add((component.Id, item, prefix + citeProblem));
+                }
+            }
+        }
+
+        return errors
+            .OrderBy(e => e.Id, StringComparer.Ordinal)
+            .ThenBy(e => e.Item)
+            .Select(e => e.Message)
+            .ToList();
+    }
+
+    private static string UnknownId(string id, IEnumerable<string> componentIds, IReadOnlyDictionary<string, string>? fileOf)
+    {
+        var message = $"{id}: not a component in components.json";
+        if (fileOf?.TryGetValue(id, out var file) == true)
+        {
+            message += $" ({file})";
+        }
+
+        var match = componentIds.FirstOrDefault(c => string.Equals(c, id, StringComparison.OrdinalIgnoreCase));
+        return match is null ? message : $"{message}; did you mean '{match}'?";
+    }
+
+    /// <summary>
+    /// One plain markdown line: no hidden or control unicode (<see cref="PlainText"/>), balanced code spans
+    /// (<see cref="MarkdownCodeSpans"/> - CommonMark backtick-run matching, so an escaped backtick cannot smuggle real
+    /// HTML past the check by being mistaken for a delimiter), and outside those code spans no backslash, angle
+    /// bracket, square bracket or bare URL - anything that could render as something other than plain text, or point
+    /// the reader somewhere the tool never checked.
+    /// </summary>
+    private static string? TextProblem(string text)
+    {
+        if (string.IsNullOrWhiteSpace(text))
+        {
+            return "text is empty";
+        }
+
+        if (text.Contains('\n') || text.Contains('\r'))
+        {
+            return "text must be a single line";
+        }
+
+        if (PlainText.HasDisallowedUnicode(text))
+        {
+            return "text contains a control or invisible unicode character";
+        }
+
+        if (text.Trim().Length > MaxTextLength)
+        {
+            return $"text is {text.Trim().Length} characters; keep it under {MaxTextLength}";
+        }
+
+        var (outsideCode, unclosed) = MarkdownCodeSpans.Strip(text);
+        if (unclosed)
+        {
+            return "text has an unclosed ` code span";
+        }
+
+        if (outsideCode.Contains('\\'))
+        {
+            return "text contains a backslash; put code in `backticks`";
+        }
+
+        if (outsideCode.IndexOfAny(['<', '>']) >= 0)
+        {
+            return "text contains HTML; put code in `backticks`";
+        }
+
+        if (outsideCode.IndexOfAny(['[', ']']) >= 0)
+        {
+            return "text contains a link; put code in `backticks`";
+        }
+
+        return outsideCode.Contains("://", StringComparison.Ordinal)
+               || outsideCode.Contains("www.", StringComparison.OrdinalIgnoreCase)
+            ? "text contains a URL; put code in `backticks`"
+            : null;
+    }
+
+    private static string? CiteProblem(
+        string cite,
+        Component component,
+        IReadOnlyDictionary<string, IReadOnlyList<string>> sourceLines,
+        Dictionary<string, IReadOnlyList<bool>> codeLines)
+    {
+        if (Citation.Parse(cite) is not { } citation)
+        {
+            return $"cite '{cite}' is not <file>:<line> or <file>:<start>-<end>";
+        }
+
+        var citable = component.Spans.Concat(component.Reaches ?? []).ToList();
+        var spans = citable.Where(s => s.File == citation.File).ToList();
+        if (spans.Count == 0)
+        {
+            return $"cite '{cite}' is not in the component's files: {string.Join(", ", citable.Select(s => s.File).Distinct())}";
+        }
+
+        // The render command checks every span file exists before validating; a missing one here is a caller bug.
+        var lines = sourceLines[citation.File];
+        if (citation.End > lines.Count)
+        {
+            return $"cite '{cite}' is past the end of the file ({lines.Count} lines)";
+        }
+
+        if (!codeLines.TryGetValue(citation.File, out var code))
+        {
+            code = SourceCodeLines.Compute(lines);
+            codeLines[citation.File] = code;
+        }
+
+        // Every code line must be citable, and the first and last lines must lie inside a citable span. Lines between
+        // two citable members (blank, comment, brace) are not code, so a citation may run across neighbouring helper
+        // members without claiming anything uncited, but it cannot start or end outside them.
+        bool Citable(int line) => spans.Any(s => s.Start <= line && line <= s.End);
+        if (Enumerable.Range(citation.Start, citation.LineCount).Any(n => !Citable(n) && (code[n - 1] || n == citation.Start || n == citation.End)))
+        {
+            var where = component.Reaches is { Count: > 0 }
+                ? "the component's declaration and the helper code it runs"
+                : "the component's declaration";
+            return $"cite '{cite}' is outside {where} ({string.Join(", ", spans.Select(s => $"{s.Start}-{s.End}"))})";
+        }
+
+        if (citation.LineCount > MaxCitedLines)
+        {
+            return $"cite '{cite}' spans {citation.LineCount} lines; cite at most {MaxCitedLines}";
+        }
+
+        return Enumerable.Range(citation.Start, citation.LineCount).Any(n => code[n - 1])
+            ? null
+            : $"cite '{cite}' covers no code (only blank, comment or brace lines)";
+    }
+
+    // "  Stores EACH   order. " and "stores each order." are the same responsibility.
+    private static string Normalize(string text) => Whitespace().Replace(text.Trim(), " ").ToLowerInvariant();
+
+    [GeneratedRegex(@"\s+")]
+    private static partial Regex Whitespace();
+}

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

@@ -0,0 +1,115 @@
+using Microsoft.CodeAnalysis;
+
+namespace LogicalComponents;
+
+/// <summary>Which member runs in an implementation when a member of a seam (interface or abstract class) is used.</summary>
+public static class SeamDispatch
+{
+    /// <summary>
+    /// The member that runs in <paramref name="implementation"/> when <paramref name="member"/> of
+    /// <paramref name="seam"/> (as constructed at the use) is used: the implementation of that exact construction of the
+    /// interface member (a class implementing <c>IHandler&lt;Ping&gt;</c> and <c>IHandler&lt;Pong&gt;</c> runs its Pong
+    /// member for a Pong use), else the one of an open construction; for an abstract class, the most derived override,
+    /// possibly the seam's own body.
+    /// </summary>
+    public static ISymbol? ImplementationOf(INamedTypeSymbol implementation, INamedTypeSymbol seam, ISymbol member)
+    {
+        var wanted = SymbolNames.MemberId(member);
+        if (seam.TypeKind == TypeKind.Interface)
+        {
+            var definition = SymbolNames.FullName(seam.OriginalDefinition);
+            var constructions = implementation.AllInterfaces
+                .Where(i => SymbolNames.FullName(i.OriginalDefinition) == definition)
+                .ToList();
+            var exact = constructions.Where(i => Display(i) == Display(seam)).ToList();
+            return (exact.Count > 0 ? exact : constructions)
+                .SelectMany(i => i.GetMembers(member.Name))
+                .Where(candidate => SymbolNames.MemberId(candidate) == wanted)
+                .Select(implementation.FindImplementationForInterfaceMember)
+                .FirstOrDefault(found => found is not null);
+        }
+
+        for (var type = implementation; type is not null; type = type.BaseType)
+        {
+            foreach (var candidate in type.GetMembers(member.Name))
+            {
+                for (var overridden = candidate; overridden is not null; overridden = Overridden(overridden))
+                {
+                    if (SymbolNames.MemberId(overridden) == wanted)
+                    {
+                        return candidate;
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private static ISymbol? Overridden(ISymbol symbol) => symbol switch
+    {
+        IMethodSymbol method => method.OverriddenMethod,
+        IPropertySymbol property => property.OverriddenProperty,
+        IEventSymbol @event => @event.OverriddenEvent,
+        _ => null,
+    };
+
+    /// <summary>
+    /// The bindings for walking <paramref name="runs"/> (the member <see cref="ImplementationOf"/> found) as it executes
+    /// for <paramref name="member"/> of <paramref name="seam"/> (as constructed at the use) in
+    /// <paramref name="implementation"/>: <paramref name="implementation"/>'s own type parameters, unified from its
+    /// construction of the seam (an open-generic decorator's own type argument, e.g. <c>Decorator&lt;T&gt; : IHandler&lt;T&gt;</c>
+    /// against <c>IHandler&lt;Ping&gt;</c>), plus a generic method declared on the seam (e.g. <c>Send&lt;T&gt;</c>) bound to
+    /// the type argument the use supplied. <paramref name="outer"/> resolves a use's type argument that is itself still
+    /// an unbound type parameter of an enclosing walk. Without this, <see cref="MemberUseResolution"/> would walk
+    /// <paramref name="runs"/> with its own type parameters unbound, and a seam it calls in turn would look like it
+    /// matches every construction (<see cref="PortResolution"/>).
+    /// </summary>
+    public static TypeMap BindingFor(
+        INamedTypeSymbol implementation, INamedTypeSymbol seam, ISymbol member, ISymbol runs, TypeMap outer)
+    {
+        var bindings = new List<(ITypeParameterSymbol Parameter, ITypeSymbol Argument)>();
+
+        if (seam.IsGenericType)
+        {
+            var definition = SymbolNames.FullName(seam.OriginalDefinition);
+            var construction = Supertypes(implementation, seam.TypeKind)
+                .FirstOrDefault(s => SymbolNames.FullName(s.OriginalDefinition) == definition);
+            for (var i = 0; construction is not null && i < construction.TypeArguments.Length && i < seam.TypeArguments.Length; i++)
+            {
+                if (construction.TypeArguments[i] is ITypeParameterSymbol parameter
+                    && SymbolEqualityComparer.Default.Equals(parameter.ContainingSymbol, implementation))
+                {
+                    bindings.Add((parameter, seam.TypeArguments[i]));
+                }
+            }
+        }
+
+        if (member is IMethodSymbol { TypeArguments.Length: > 0 } used && runs is IMethodSymbol { TypeArguments.Length: > 0 } implemented)
+        {
+            bindings.AddRange(TypeMap.Zip(implemented.OriginalDefinition.TypeParameters, used.TypeArguments)
+                .Select(b => (b.Parameter, outer.Substitute(b.Argument))));
+        }
+
+        return TypeMap.FromBindings(bindings);
+    }
+
+    private static IEnumerable<INamedTypeSymbol> Supertypes(INamedTypeSymbol type, TypeKind seamKind)
+    {
+        if (seamKind == TypeKind.Interface)
+        {
+            return type.AllInterfaces;
+        }
+
+        var bases = new List<INamedTypeSymbol>();
+        for (var current = type.BaseType; current is not null; current = current.BaseType)
+        {
+            bases.Add(current);
+        }
+
+        return bases;
+    }
+
+    // Compared as text: symbols of the same type seen from two projects' compilations are not the same instance.
+    private static string Display(ITypeSymbol type) => type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+}

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

@@ -0,0 +1,79 @@
+using System.Text;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// Which lines of a whole file contain real code, for <see cref="ResponsibilityValidation"/>'s citation checks. Tracks
+/// `/* */` block-comment state across the file (so a continuation line without a leading `*` is still recognised as a
+/// comment, and a comment that closes mid-line is not mistaken for a comment-only line), and treats punctuation-only
+/// lines, preprocessor directives, and a lone `else`/`try`/`finally`/`do` with no condition of its own as not code.
+/// </summary>
+public static class SourceCodeLines
+{
+    public static IReadOnlyList<bool> Compute(IReadOnlyList<string> lines)
+    {
+        var result = new bool[lines.Count];
+        var inBlockComment = false;
+        for (var i = 0; i < lines.Count; i++)
+        {
+            result[i] = LineHasCode(lines[i], ref inBlockComment);
+        }
+
+        return result;
+    }
+
+    /// <summary>
+    /// Strips `//` line comments and `/* */` block comments from one line (updating <paramref name="inBlockComment"/>
+    /// for the next line), then true if what remains is more than punctuation <c>{}()[];,</c>, a preprocessor
+    /// directive, or a lone <c>else</c>/<c>try</c>/<c>finally</c>/<c>do</c>.
+    /// </summary>
+    private static bool LineHasCode(string line, ref bool inBlockComment)
+    {
+        var code = new StringBuilder();
+        var i = 0;
+        while (i < line.Length)
+        {
+            if (inBlockComment)
+            {
+                var close = line.IndexOf("*/", i, StringComparison.Ordinal);
+                if (close < 0)
+                {
+                    break; // the rest of the line is still inside the comment
+                }
+
+                inBlockComment = false;
+                i = close + 2;
+                continue;
+            }
+
+            if (line[i] == '/' && i + 1 < line.Length && line[i + 1] == '/')
+            {
+                break; // the rest of the line is a line comment
+            }
+
+            if (line[i] == '/' && i + 1 < line.Length && line[i + 1] == '*')
+            {
+                var close = line.IndexOf("*/", i + 2, StringComparison.Ordinal);
+                if (close < 0)
+                {
+                    inBlockComment = true;
+                    break;
+                }
+
+                i = close + 2;
+                continue;
+            }
+
+            code.Append(line[i]);
+            i++;
+        }
+
+        if (code.ToString().TrimStart(' ', '\t').StartsWith('#'))
+        {
+            return false;
+        }
+
+        var stripped = code.ToString().Trim('{', '}', '(', ')', '[', ']', ';', ',', ' ', '\t');
+        return stripped.Length > 0 && stripped is not ("else" or "try" or "finally" or "do");
+    }
+}

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

@@ -0,0 +1,53 @@
+using Microsoft.CodeAnalysis;
+
+namespace LogicalComponents;
+
+/// <summary>Stable textual names for symbols, independent of nullable annotations and of where the repo is checked out.</summary>
+public static class SymbolNames
+{
+    // No miscellaneous options: in particular no nullable '?' suffix, so IServiceCollection? == IServiceCollection.
+    private static readonly SymbolDisplayFormat Qualified = new(
+        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces);
+
+    /// <summary><c>Microsoft.Extensions.DependencyInjection.IServiceCollection</c>, whatever its nullability.</summary>
+    public static string QualifiedName(ITypeSymbol type) => type.ToDisplayString(Qualified);
+
+    /// <summary>
+    /// Full metadata name: namespace plus metadata name (generic arity kept, e.g. <c>Ns.Cache`1</c>). A nested type
+    /// carries its containing types (<c>Ns.Receipts+Builder</c>), so it can never collide with a top-level namesake.
+    /// </summary>
+    public static string FullName(INamedTypeSymbol type) =>
+        type.ContainingType is { } outer
+            ? $"{FullName(outer)}+{type.MetadataName}"
+            : type.ContainingNamespace.IsGlobalNamespace
+                ? type.MetadataName
+                : $"{type.ContainingNamespace.ToDisplayString()}.{type.MetadataName}";
+
+    /// <summary>
+    /// A member's identity across compilations (symbols of one member seen from two projects are not the same instance):
+    /// the documentation-comment id of its definition, e.g. <c>M:Ns.Handler`1.Handle(`0)</c>.
+    /// </summary>
+    public static string MemberId(ISymbol symbol) =>
+        symbol.OriginalDefinition.GetDocumentationCommentId() ?? symbol.OriginalDefinition.ToDisplayString();
+
+    /// <summary>A name safe as a diagram id: <c>Ns.Receipts+Cache`1</c> → <c>Ns_Receipts_Cache_1</c>.</summary>
+    public static string ToIdentifier(string fullName) =>
+        fullName.Replace('.', '_').Replace('+', '_').Replace('`', '_');
+
+    /// <summary>The simple name without arity: <c>Ns.Cache`1</c> → <c>Cache</c>, <c>Ns.Outer+Inner</c> → <c>Inner</c>.</summary>
+    public static string SimpleName(string fullName)
+    {
+        var name = fullName[(fullName.LastIndexOfAny(['.', '+']) + 1)..];
+        var tick = name.IndexOf('`');
+        return tick < 0 ? name : name[..tick];
+    }
+
+    /// <summary>The full name as a reader writes it: <c>Ns.Cache`1</c> → <c>Ns.Cache&lt;&gt;</c>, <c>`2</c> → <c>&lt;,&gt;</c>.</summary>
+    public static string ReadableFullName(string fullName)
+    {
+        var tick = fullName.LastIndexOf('`');
+        return tick < 0 || !int.TryParse(fullName[(tick + 1)..], out var arity)
+            ? fullName
+            : $"{fullName[..tick]}<{new string(',', arity - 1)}>";
+    }
+}

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

@@ -0,0 +1,106 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// What a generic helper's type parameters stand for at the use being followed. Walking <c>Dispatch.Send&lt;T&gt;</c>
+/// for <c>Send(new Ping())</c> maps <c>T</c> to <c>Ping</c>, so the <c>ICommandHandler&lt;T&gt;</c> it calls is
+/// resolved as <c>ICommandHandler&lt;Ping&gt;</c> and reaches only the Ping handlers, not every handler.
+/// </summary>
+public sealed class TypeMap
+{
+    private readonly Dictionary<ITypeParameterSymbol, ITypeSymbol> _map;
+
+    private TypeMap(Dictionary<ITypeParameterSymbol, ITypeSymbol> map)
+    {
+        _map = map;
+        Key = string.Join(";", map
+            .Select(p => $"{p.Key.ContainingSymbol.ToDisplayString()}.{p.Key.Name}={p.Value.ToDisplayString()}")
+            .Order(StringComparer.Ordinal));
+    }
+
+    public static TypeMap Empty { get; } = new(new Dictionary<ITypeParameterSymbol, ITypeSymbol>(SymbolEqualityComparer.Default));
+
+    /// <summary>Stable text of the bindings: the same member walked for two different bindings is two walks.</summary>
+    public string Key { get; }
+
+    /// <summary>
+    /// A map built from known (parameter, argument) pairs: a generic base class's own parameters bound to what the
+    /// derived class supplies (<see cref="CouplingResolver"/>), or an implementation's own parameters unified from its
+    /// construction of a seam, plus a generic seam method's parameters bound to the use's type arguments
+    /// (<see cref="SeamDispatch"/>). Pairs where the argument is the parameter itself carry no information and are
+    /// dropped, same as <see cref="For"/>.
+    /// </summary>
+    public static TypeMap FromBindings(IEnumerable<(ITypeParameterSymbol Parameter, ITypeSymbol Argument)> bindings)
+    {
+        var map = new Dictionary<ITypeParameterSymbol, ITypeSymbol>(SymbolEqualityComparer.Default);
+        foreach (var (parameter, argument) in bindings)
+        {
+            if (!SymbolEqualityComparer.Default.Equals(parameter, argument))
+            {
+                map[parameter] = argument;
+            }
+        }
+
+        return map.Count == 0 ? Empty : new TypeMap(map);
+    }
+
+    /// <summary>Pairs a generic definition's own type parameters with a construction's type arguments, positionally.</summary>
+    public static IEnumerable<(ITypeParameterSymbol Parameter, ITypeSymbol Argument)> Zip(
+        ImmutableArray<ITypeParameterSymbol> parameters, ImmutableArray<ITypeSymbol> arguments)
+    {
+        for (var i = 0; i < parameters.Length && i < arguments.Length; i++)
+        {
+            yield return (parameters[i], arguments[i]);
+        }
+    }
+
+    /// <summary>The type with every mapped type parameter replaced, inside generic arguments too.</summary>
+    public ITypeSymbol Substitute(ITypeSymbol type) => type switch
+    {
+        ITypeParameterSymbol parameter when _map.TryGetValue(parameter, out var bound) => bound,
+        INamedTypeSymbol { IsGenericType: true } named when named.TypeArguments.Any(Mentions) =>
+            named.OriginalDefinition.Construct([.. named.TypeArguments.Select(Substitute)]),
+        _ => type,
+    };
+
+    /// <summary>
+    /// The map for walking <paramref name="member"/>'s own code: the type parameters of its definition and of its
+    /// containing types, bound to the arguments this use supplies (read through this map, for nested generic helpers).
+    /// </summary>
+    public TypeMap For(ISymbol member)
+    {
+        var map = new Dictionary<ITypeParameterSymbol, ITypeSymbol>(SymbolEqualityComparer.Default);
+        void Bind(ImmutableArray<ITypeParameterSymbol> parameters, ImmutableArray<ITypeSymbol> arguments)
+        {
+            for (var i = 0; i < parameters.Length && i < arguments.Length; i++)
+            {
+                var argument = Substitute(arguments[i]);
+                if (!SymbolEqualityComparer.Default.Equals(parameters[i], argument))
+                {
+                    map[parameters[i]] = argument;
+                }
+            }
+        }
+
+        if (member is IMethodSymbol method)
+        {
+            Bind(method.OriginalDefinition.TypeParameters, method.TypeArguments);
+        }
+
+        for (var type = member.ContainingType; type is not null; type = type.ContainingType)
+        {
+            Bind(type.OriginalDefinition.TypeParameters, type.TypeArguments);
+        }
+
+        return map.Count == 0 ? Empty : new TypeMap(map);
+    }
+
+    private bool Mentions(ITypeSymbol type) => type switch
+    {
+        ITypeParameterSymbol parameter => _map.ContainsKey(parameter),
+        INamedTypeSymbol { IsGenericType: true } named => named.TypeArguments.Any(Mentions),
+        _ => false,
+    };
+}

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

@@ -0,0 +1,63 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace LogicalComponents;
+
+/// <summary>
+/// The syntax that runs when a member is used, for <see cref="MemberUseResolution"/> to walk. Always in (file, position)
+/// order, so the walk, and the first path it records, is the same on every checkout.
+/// </summary>
+public static class WalkRoots
+{
+    /// <summary>The declaration of a member: its body, accessor or initializer, from the implementing half if it is partial.</summary>
+    public static List<SyntaxNode> Body(ISymbol member) =>
+        Ordered(Implementation(member.OriginalDefinition).DeclaringSyntaxReferences.Select(r => r.GetSyntax()));
+
+    /// <summary>
+    /// What <c>new</c> runs: the constructor (for a primary constructor, only its parameter defaults and base call, never
+    /// the whole type) and the type's instance field and property initializers. <c>RunsImplicitBase</c> is set when the
+    /// constructor calls no <c>base(...)</c>/<c>this(...)</c> itself, so the base class's parameterless constructor runs.
+    /// </summary>
+    public static (List<SyntaxNode> Roots, bool RunsImplicitBase) Construction(IMethodSymbol constructor)
+    {
+        var roots = new List<SyntaxNode>();
+        var explicitChain = false;
+        foreach (var syntax in Implementation(constructor.OriginalDefinition).DeclaringSyntaxReferences.Select(r => r.GetSyntax()))
+        {
+            if (syntax is TypeDeclarationSyntax type)
+            {
+                var baseCall = type.BaseList?.Types.OfType<PrimaryConstructorBaseTypeSyntax>().FirstOrDefault();
+                explicitChain |= baseCall is not null;
+                roots.AddRange(new SyntaxNode?[] { type.ParameterList, baseCall }.OfType<SyntaxNode>());
+            }
+            else
+            {
+                explicitChain |= syntax is ConstructorDeclarationSyntax { Initializer: not null };
+                roots.Add(syntax);
+            }
+        }
+
+        foreach (var member in constructor.ContainingType.OriginalDefinition.GetMembers().Where(m => !m.IsStatic))
+        {
+            roots.AddRange(member.DeclaringSyntaxReferences.Select(r => r.GetSyntax()).Select(syntax => syntax switch
+            {
+                VariableDeclaratorSyntax { Initializer: { } initializer } => initializer,
+                PropertyDeclarationSyntax { Initializer: { } initializer } => initializer,
+                _ => null,
+            }).OfType<SyntaxNode>());
+        }
+
+        return (Ordered(roots), !explicitChain);
+    }
+
+    // A partial method, property or constructor is walked where its body is written.
+    private static ISymbol Implementation(ISymbol member) => member switch
+    {
+        IMethodSymbol { PartialImplementationPart: { } implementation } => implementation,
+        IPropertySymbol { PartialImplementationPart: { } implementation } => implementation,
+        _ => member,
+    };
+
+    private static List<SyntaxNode> Ordered(IEnumerable<SyntaxNode> roots) =>
+        roots.OrderBy(r => r.SyntaxTree.FilePath, StringComparer.Ordinal).ThenBy(r => r.SpanStart).ToList();
+}