@descryy/adapter-csharp 0.1.0

package/dist/parse.js

@@ -0,0 +1,861 @@
+/**
+ * One C# file, read into the shape the resolver wants.
+ *
+ * Hand-written walk, as in Java, Go, Rust and PHP, and for the same reason:
+ * containment is what a resolver needs and a query's match set is exactly what
+ * discards it.
+ *
+ * ## What C# changes
+ *
+ * Three things here are genuinely new work rather than a translation of an
+ * earlier language's rules.
+ *
+ *   - **A type may be declared in several files.** `partial class` is the first
+ *     construct in this project whose declaration is legitimately multi-file and
+ *     says so in the source. DEC-083 settles the identity question; this reader
+ *     only has to collect the parts.
+ *   - **`using` imports a namespace, not a type.** PHP's `use` names one class
+ *     and resolves in one step. C#'s brings in every type in a namespace, so a
+ *     bare name is resolved by searching the enclosing namespaces outward and
+ *     then each import — which means a name may be found in two places, and
+ *     that is an ambiguity to disclose rather than a tie to break.
+ *   - **The base list does not say which entry is the class.** DEC-084 decides
+ *     it: at most one base class, and the language requires it first, so entries
+ *     after the first are interfaces unconditionally and only one entry per
+ *     class declaration ever needs resolving. The `IFoo` convention is not read.
+ *
+ * Nested types are ordinary here in a way they are not in PHP, so a type carries
+ * its nesting path rather than a single name.
+ */
+/** Keywords that name no user type. `var` is handled separately. */
+const PREDEFINED = new Set([
+    "int", "uint", "long", "ulong", "short", "ushort", "byte", "sbyte",
+    "float", "double", "decimal", "bool", "char", "string", "object",
+    "void", "dynamic", "nint", "nuint", "var",
+]);
+/**
+ * The type a type expression names.
+ *
+ * `undefined` — none (predefined, `var`, or absent).
+ * `null`      — a type is named but which one is ambiguous.
+ * `string`    — the single type named, as written, generic arguments dropped.
+ *
+ * Generic arguments are dropped deliberately: `List<Order>` names `List`, and
+ * `Order` inside it is a separate reference the walker records on its own. A
+ * single collapsed name would attribute the collection's methods to its element.
+ */
+export function typeName(node) {
+    if (node === null || node === undefined)
+        return undefined;
+    switch (node.type) {
+        case "predefined_type":
+        case "implicit_type":
+            return undefined;
+        case "identifier": {
+            const text = node.text.trim();
+            return PREDEFINED.has(text) ? undefined : text;
+        }
+        case "qualified_name": {
+            const text = node.text.trim().replace(/<[^>]*>/g, "");
+            return text === "" ? undefined : text;
+        }
+        case "generic_name":
+            return typeName(node.namedChild(0));
+        case "nullable_type":
+            return typeName(node.childForFieldName("type") ?? node.namedChild(0));
+        case "array_type":
+            return typeName(node.childForFieldName("type") ?? node.namedChild(0));
+        case "pointer_type":
+        case "ref_type":
+        case "scoped_type":
+            return typeName(node.namedChild(0));
+        case "tuple_type":
+            return null;
+        default: {
+            if (node.namedChildCount === 1)
+                return typeName(node.namedChild(0));
+            if (node.namedChildCount === 0) {
+                const text = node.text.trim();
+                if (text === "" || PREDEFINED.has(text))
+                    return undefined;
+                return /^[\w.]+$/.test(text) ? text : undefined;
+            }
+            return null;
+        }
+    }
+}
+function hasModifier(node, keyword) {
+    for (let index = 0; index < node.childCount; index += 1) {
+        const child = node.child(index);
+        if (child?.type === "modifier" && child.text === keyword)
+            return true;
+    }
+    return false;
+}
+/**
+ * `[Fact]`, `[Theory]`, `[Xunit.Fact]` -> the last segment, **and its arguments**.
+ *
+ * The names alone were enough while `isTest` was the only consumer. A framework
+ * extractor needs the other half: `[Route("System/ActivityLog")]` collapses to
+ * `Route`, and the argument that is dropped **is the route**.
+ *
+ * That is the third instance of one shape in this adapter set — identity
+ * normalises, fidelity preserves, and both readings are correct for different
+ * consumers. The first two were a property's written type (`string` against
+ * `string?`) and a base list's generic argument
+ * (`IEntityTypeConfiguration<Order>`). Each collapse surfaced downstream as a
+ * clean zero rather than as an error, so both are carried side by side now.
+ */
+function attributeArgumentsOf(node) {
+    const found = {};
+    for (let index = 0; index < node.childCount; index += 1) {
+        const child = node.child(index);
+        if (child?.type !== "attribute_list")
+            continue;
+        for (let inner = 0; inner < child.namedChildCount; inner += 1) {
+            const attribute = child.namedChild(inner);
+            if (attribute?.type !== "attribute")
+                continue;
+            const name = attribute.childForFieldName("name")?.text.trim();
+            if (name === undefined)
+                continue;
+            const bare = name.replace(/<[^>]*>/g, "");
+            const simple = bare.slice(bare.lastIndexOf(".") + 1);
+            // The first string literal argument, as written. A non-literal argument
+            // yields nothing rather than its source text: a path assembled at runtime
+            // is not a path this adapter can read, and DEC-128 refuses it.
+            const literal = /\(\s*"([^"]*)"/.exec(attribute.text);
+            if (literal !== null && found[simple] === undefined)
+                found[simple] = literal[1];
+        }
+    }
+    return found;
+}
+function attributesOf(node) {
+    const names = [];
+    for (let index = 0; index < node.childCount; index += 1) {
+        const child = node.child(index);
+        if (child?.type !== "attribute_list")
+            continue;
+        for (let inner = 0; inner < child.namedChildCount; inner += 1) {
+            const attribute = child.namedChild(inner);
+            if (attribute?.type !== "attribute")
+                continue;
+            const name = attribute.childForFieldName("name")?.text.trim();
+            if (name === undefined)
+                continue;
+            const bare = name.replace(/<[^>]*>/g, "");
+            names.push(bare.slice(bare.lastIndexOf(".") + 1));
+        }
+    }
+    return names;
+}
+function describeReceiver(node) {
+    if (node === null || node === undefined)
+        return { written: undefined };
+    switch (node.type) {
+        case "identifier":
+        case "predefined_type":
+            return { written: node.text.trim() };
+        case "this_expression":
+            return { written: "this" };
+        case "base_expression":
+            return { written: "base" };
+        case "generic_name":
+            return { written: node.namedChild(0)?.text.trim() };
+        case "qualified_name":
+            return { written: node.text.trim() };
+        case "parenthesized_expression":
+            return describeReceiver(node.namedChild(0));
+        case "object_creation_expression": {
+            // `new Order(x).Total()` — the type is at the site.
+            const named = typeName(node.childForFieldName("type"));
+            return typeof named === "string" ? { written: undefined, type: named } : { written: undefined, opaque: true };
+        }
+        case "cast_expression": {
+            // `((IRepository)x).FindById()` — also written at the site.
+            const named = typeName(node.childForFieldName("type"));
+            return typeof named === "string" ? { written: undefined, type: named } : { written: undefined, opaque: true };
+        }
+        case "conditional_access_expression": {
+            // `x?.y.z()` and `a?[0].F()`. The null-conditional changes only whether the
+            // chain is evaluated, never what it denotes: `x?.y` names exactly what
+            // `x.y` names. Unwrapping it here is what lets the ordinary member-access
+            // machinery below do the work; falling through to `default` made every
+            // such receiver opaque, and before the flag above existed, implicit.
+            const object = describeReceiver(node.namedChild(0));
+            const binding = node.namedChild(1);
+            if (binding?.type !== "member_binding_expression") {
+                // `a?[0]` is an indexer. The element type is not written at the site.
+                return { written: undefined, opaque: true };
+            }
+            const member = binding.namedChild(0);
+            const memberName = (member?.type === "generic_name" ? member.namedChild(0)?.text : member?.text)?.trim();
+            if (memberName === undefined || object.written === undefined)
+                return { written: undefined, opaque: true };
+            return {
+                written: `${object.written}.${memberName}`,
+                property: { of: object.written, name: memberName },
+            };
+        }
+        case "member_access_expression": {
+            // `this._repository.FindById()` — the type is on the member declaration,
+            // but `Shop.Orders.Money.Format()` is a *namespace* path, not a member
+            // chain. Both are `member_access_expression`, and telling them apart needs
+            // the resolver, so the whole written path is handed over and the resolver
+            // tries it as a qualified name first.
+            const object = describeReceiver(node.childForFieldName("expression"));
+            const member = node.childForFieldName("name");
+            if (member === null)
+                return { written: undefined, opaque: true };
+            const memberName = member.type === "generic_name" ? member.namedChild(0)?.text : member.text;
+            if (memberName === undefined || object.written === undefined) {
+                // The object could not be written down, so neither can the member path.
+                // Opaque rather than absent — see `Receiver.opaque`.
+                return object.type === undefined && object.call === undefined
+                    ? { written: undefined, opaque: true }
+                    : { written: undefined };
+            }
+            return {
+                written: `${object.written}.${memberName.trim()}`,
+                property: { of: object.written, name: memberName.trim() },
+            };
+        }
+        case "invocation_expression": {
+            const call = callSignature(node);
+            return call === undefined ? { written: undefined, opaque: true } : { written: undefined, call };
+        }
+        default:
+            // A binary expression, a literal, a lambda, a `switch` expression — a
+            // receiver is written and this reader cannot say what it denotes.
+            return { written: undefined, opaque: true };
+    }
+}
+/** The `(receiver, name)` an invocation names, when both are written. */
+function callSignature(node) {
+    const callee = node.childForFieldName("function");
+    if (callee === null)
+        return undefined;
+    if (callee.type === "identifier")
+        return { receiver: undefined, name: callee.text.trim() };
+    if (callee.type === "generic_name") {
+        const bare = callee.namedChild(0)?.text.trim();
+        return bare === undefined ? undefined : { receiver: undefined, name: bare };
+    }
+    if (callee.type === "member_access_expression") {
+        const member = callee.childForFieldName("name");
+        if (member === null)
+            return undefined;
+        const name = (member.type === "generic_name" ? member.namedChild(0)?.text : member.text)?.trim();
+        if (name === undefined)
+            return undefined;
+        const receiver = describeReceiver(callee.childForFieldName("expression"));
+        if (receiver.written === undefined)
+            return undefined;
+        return { receiver: receiver.written, name };
+    }
+    return undefined;
+}
+/**
+ * The first argument of an invocation, only when it is a bare string literal.
+ *
+ * Mirrors Java's `firstStringArgumentOf` exactly: `argument_list`'s first
+ * named child is an `argument`, whose own first named child is the value —
+ * `string_literal` when the call site wrote one, an `identifier` or anything
+ * else otherwise. `"abc"` -> `abc`; a concatenation or interpolated string
+ * (`$"..."`, `interpolated_string_expression`) returns `undefined` rather than
+ * the fragment it can see, the same refusal-not-guess DEC-127 already applies
+ * to Java's read of the identical shape.
+ */
+function firstStringArgumentOf(invocation) {
+    const args = invocation.childForFieldName("arguments");
+    if (args === null)
+        return undefined;
+    const first = args.namedChild(0)?.namedChild(0);
+    if (first === null || first === undefined || first.type !== "string_literal")
+        return undefined;
+    return first.text.slice(1, -1);
+}
+/**
+ * The first argument's raw text, whatever shape it is. Mirrors Java's
+ * `firstArgumentTextOf`. See {@link CsRef.firstArgumentText}.
+ */
+function firstArgumentTextOf(invocation) {
+    const args = invocation.childForFieldName("arguments");
+    if (args === null)
+        return undefined;
+    const first = args.namedChild(0)?.namedChild(0);
+    return first === null || first === undefined ? undefined : first.text;
+}
+function pushInvocation(scope, node) {
+    const callee = node.childForFieldName("function");
+    if (callee === null)
+        return;
+    if (callee.type === "identifier" || callee.type === "generic_name") {
+        const name = (callee.type === "generic_name" ? callee.namedChild(0)?.text : callee.text)?.trim();
+        if (name === undefined)
+            return;
+        scope.refs.push({
+            kind: "call",
+            name,
+            receiver: undefined,
+            line: node.startPosition.row + 1,
+            raw: node.text.slice(0, 200),
+        });
+        return;
+    }
+    if (callee.type === "member_access_expression" || callee.type === "conditional_access_expression") {
+        const holder = callee.type === "member_access_expression" ? callee : callee.namedChild(0);
+        const member = callee.type === "member_access_expression"
+            ? callee.childForFieldName("name")
+            : callee.namedChild(1)?.namedChild(0);
+        if (holder === null || member === null || member === undefined)
+            return;
+        const name = (member.type === "generic_name" ? member.namedChild(0)?.text : member.text)?.trim();
+        if (name === undefined)
+            return;
+        const receiver = describeReceiver(callee.type === "member_access_expression" ? callee.childForFieldName("expression") : holder);
+        // A receiver was written and could not be read. Disclosing that is the whole
+        // difference between a gap and a wrong answer: falling through with
+        // `receiver: undefined` makes `emitCall` treat it as an implicit `self`.
+        if (receiver.opaque === true) {
+            scope.refs.push({
+                kind: "dynamic",
+                name: callee.text.slice(0, 60),
+                receiver: undefined,
+                line: node.startPosition.row + 1,
+                raw: node.text.slice(0, 200),
+            });
+            return;
+        }
+        const literal = firstStringArgumentOf(node);
+        const argumentText = firstArgumentTextOf(node);
+        scope.refs.push({
+            kind: "call",
+            name,
+            receiver: receiver.written,
+            ...(receiver.type === undefined ? {} : { receiverType: receiver.type }),
+            ...(receiver.property === undefined ? {} : { receiverProperty: receiver.property }),
+            ...(receiver.call === undefined ? {} : { receiverCall: receiver.call }),
+            line: node.startPosition.row + 1,
+            raw: node.text.slice(0, 200),
+            // Spread rather than assigned — `exactOptionalPropertyTypes` distinguishes
+            // absent from present-and-undefined, and the distinction is the point:
+            // absent means "not a call worth reading further," present-and-undefined
+            // would wrongly mean "a call whose first argument is nothing."
+            ...(literal === undefined ? {} : { firstStringArgument: literal }),
+            ...(argumentText === undefined ? {} : { firstArgumentText: argumentText }),
+        });
+        return;
+    }
+    // `handler(payload)` where `handler` is a delegate field, `_map[key](x)`,
+    // `((Func<int,int>)f)(x)`. The target is a value; which method it holds is a
+    // runtime fact. Golden pattern 12.
+    scope.refs.push({
+        kind: "dynamic",
+        name: callee.text.slice(0, 60),
+        receiver: undefined,
+        line: node.startPosition.row + 1,
+        raw: node.text.slice(0, 200),
+    });
+}
+/**
+ * A `variable_declarator`'s own initialiser, whether or not the declaration's
+ * type was written explicitly — `recordDeclarator` only needs this for `var`,
+ * but a field's own inline initialiser (`private readonly HttpClient _client
+ * = factory.CreateClient();`) matters for D-FIX-3's client-base extractor
+ * (DEC-164) even when the field's type is written explicitly, so this is a
+ * standalone reader rather than folded into `recordDeclarator`'s own `var`
+ * branch.
+ */
+function initialiserOf(declarator) {
+    let initialiser;
+    for (let inner = 0; inner < declarator.namedChildCount; inner += 1) {
+        const child = declarator.namedChild(inner);
+        if (child !== null && child.type !== "bracketed_argument_list")
+            initialiser = child;
+    }
+    return initialiser;
+}
+/** `var x = new Order();` and `var x = Build();` — bind the local's type. */
+function recordDeclarator(scope, declaration) {
+    const written = typeName(declaration.childForFieldName("type"));
+    for (let index = 0; index < declaration.namedChildCount; index += 1) {
+        const declarator = declaration.namedChild(index);
+        if (declarator?.type !== "variable_declarator")
+            continue;
+        const name = declarator.childForFieldName("name")?.text.trim();
+        if (name === undefined)
+            continue;
+        if (typeof written === "string") {
+            scope.locals.set(name, written);
+            continue;
+        }
+        // `var` — the type is in the initialiser, which is still source.
+        const initialiser = initialiserOf(declarator);
+        if (initialiser === undefined) {
+            scope.locals.set(name, written ?? null);
+            continue;
+        }
+        if (initialiser.type === "object_creation_expression") {
+            const created = typeName(initialiser.childForFieldName("type"));
+            scope.locals.set(name, typeof created === "string" ? created : null);
+            continue;
+        }
+        if (initialiser.type === "invocation_expression") {
+            const call = callSignature(initialiser);
+            if (call !== undefined) {
+                scope.pending.set(name, call);
+                continue;
+            }
+        }
+        scope.locals.set(name, null);
+    }
+}
+function readParameters(node, scope, members) {
+    if (node === null || node === undefined)
+        return;
+    for (let index = 0; index < node.namedChildCount; index += 1) {
+        const parameter = node.namedChild(index);
+        if (parameter?.type !== "parameter")
+            continue;
+        const name = parameter.childForFieldName("name")?.text.trim();
+        const declared = typeName(parameter.childForFieldName("type"));
+        if (name !== undefined) {
+            scope.locals.set(name, declared ?? null);
+            scope.parameterNames.add(name);
+        }
+        if (typeof declared === "string") {
+            scope.refs.push({
+                kind: "type",
+                name: declared,
+                receiver: undefined,
+                line: parameter.startPosition.row + 1,
+                raw: parameter.text.slice(0, 160),
+            });
+        }
+        // A primary constructor on a `class`/`record` declares members, and this is
+        // the only place their types are written.
+        if (members !== undefined && name !== undefined)
+            members.set(name, declared ?? null);
+    }
+}
+function walkBody(node, scope) {
+    const stack = [node];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined)
+            continue;
+        switch (current.type) {
+            case "variable_declaration":
+                recordDeclarator(scope, current);
+                break;
+            case "invocation_expression":
+                pushInvocation(scope, current);
+                break;
+            case "assignment_expression": {
+                // `Client = factory.CreateClient(...)` and `this.Client = ...` — only
+                // D-FIX-3's client-base extractor (DEC-164) reads this, and only from
+                // a `.ctor`'s own scope (extract.ts's choice, not this reader's). The
+                // invocation itself is walked normally regardless (it is still a
+                // child of this node) and produces its own `CsRef`; this case exists
+                // purely to remember *which name the result was bound to*.
+                const left = current.childForFieldName("left");
+                const right = current.childForFieldName("right");
+                if (left !== null && right !== null && right.type === "invocation_expression") {
+                    let bound;
+                    if (left.type === "identifier")
+                        bound = left.text.trim();
+                    else if (left.type === "member_access_expression") {
+                        const receiver = left.childForFieldName("expression")?.text.trim();
+                        if (receiver === "this")
+                            bound = left.childForFieldName("name")?.text.trim();
+                    }
+                    if (bound !== undefined) {
+                        const call = callSignature(right);
+                        if (call !== undefined)
+                            scope.propertyAssignments.set(bound, call);
+                    }
+                }
+                break;
+            }
+            case "object_creation_expression": {
+                const created = typeName(current.childForFieldName("type"));
+                if (typeof created === "string") {
+                    scope.refs.push({
+                        kind: "new",
+                        name: created,
+                        receiver: undefined,
+                        line: current.startPosition.row + 1,
+                        raw: current.text.slice(0, 200),
+                    });
+                }
+                break;
+            }
+            case "declaration_pattern": {
+                // `if (item is Folder folder)` and `case Folder folder:` — a pattern
+                // that BINDS a local whose type is written immediately before it. Every
+                // call through that local was previously disclosed as an untyped
+                // receiver, which was honest but wasteful: the type is right there.
+                // jellyfin's `MetadataService.GetChildrenForMetadataUpdates` is the
+                // canonical shape, and it is idiomatic modern C# rather than a corner.
+                const declared = typeName(current.namedChild(0));
+                const bound = current.namedChild(1)?.text.trim();
+                if (bound !== undefined)
+                    scope.locals.set(bound, typeof declared === "string" ? declared : null);
+                if (typeof declared === "string") {
+                    scope.refs.push({
+                        kind: "type",
+                        name: declared,
+                        receiver: undefined,
+                        line: current.startPosition.row + 1,
+                        raw: current.text.slice(0, 120),
+                    });
+                }
+                break;
+            }
+            case "catch_declaration": {
+                const caught = typeName(current.childForFieldName("type") ?? current.namedChild(0));
+                const bound = current.childForFieldName("name")?.text.trim();
+                if (bound !== undefined)
+                    scope.locals.set(bound, typeof caught === "string" ? caught : null);
+                if (typeof caught === "string") {
+                    scope.refs.push({
+                        kind: "type",
+                        name: caught,
+                        receiver: undefined,
+                        line: current.startPosition.row + 1,
+                        raw: current.text.slice(0, 120),
+                    });
+                }
+                break;
+            }
+            case "member_access_expression": {
+                // `Status.Pending`, `Order.Empty` — a type referenced as a value, which
+                // is golden pattern 13. Only recorded when the holder is a bare name;
+                // the resolver decides whether that name is a type or a variable, and
+                // declines when it is neither.
+                const holder = current.childForFieldName("expression");
+                if (holder !== null && (holder.type === "identifier" || holder.type === "qualified_name")) {
+                    scope.refs.push({
+                        kind: "type",
+                        name: holder.text.trim(),
+                        receiver: undefined,
+                        speculative: true,
+                        line: current.startPosition.row + 1,
+                        raw: current.text.slice(0, 120),
+                    });
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        for (let index = 0; index < current.namedChildCount; index += 1) {
+            const child = current.namedChild(index);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+}
+function readFunction(node, ownerPath, name) {
+    const scope = { refs: [], locals: new Map(), pending: new Map(), parameterNames: new Set(), propertyAssignments: new Map() };
+    readParameters(node.childForFieldName("parameters"), scope);
+    const returns = typeName(node.childForFieldName("returns"));
+    if (typeof returns === "string") {
+        scope.refs.push({
+            kind: "type",
+            name: returns,
+            receiver: undefined,
+            line: node.startPosition.row + 1,
+            raw: node.text.slice(0, 120),
+        });
+    }
+    const body = node.childForFieldName("body");
+    if (body !== null)
+        walkBody(body, scope);
+    return {
+        name,
+        ownerPath,
+        isStatic: hasModifier(node, "static"),
+        isAbstract: hasModifier(node, "abstract"),
+        attributes: attributesOf(node),
+        attributeArguments: attributeArgumentsOf(node),
+        returns,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        scope,
+    };
+}
+/** The base list, **in written order** — DEC-084 reads position as evidence. */
+function baseListOf(node) {
+    const names = [];
+    const written = [];
+    for (let index = 0; index < node.namedChildCount; index += 1) {
+        const child = node.namedChild(index);
+        if (child?.type !== "base_list")
+            continue;
+        for (let inner = 0; inner < child.namedChildCount; inner += 1) {
+            const entry = child.namedChild(inner);
+            if (entry === null || entry.type === "argument_list")
+                continue;
+            const source = entry.type === "primary_constructor_base_type"
+                ? (entry.childForFieldName("type") ?? entry.namedChild(0))
+                : entry;
+            const named = typeName(source);
+            if (typeof named === "string") {
+                names.push(named);
+                written.push(source?.text.trim() ?? named);
+            }
+        }
+    }
+    return { names, written };
+}
+const FORMS = {
+    class_declaration: "class",
+    interface_declaration: "interface",
+    struct_declaration: "struct",
+    record_declaration: "record",
+    record_struct_declaration: "record",
+    enum_declaration: "enum",
+};
+export function readFile(root, file, hasError) {
+    let namespaceName = "";
+    const usings = [];
+    const types = [];
+    const funcs = [];
+    const readUsing = (node) => {
+        const alias = node.childForFieldName("name")?.text.trim();
+        let target;
+        for (let index = 0; index < node.namedChildCount; index += 1) {
+            const child = node.namedChild(index);
+            if (child === null)
+                continue;
+            if (child.type === "identifier" && child.text.trim() === alias)
+                continue;
+            if (child.type === "qualified_name" || child.type === "identifier" || child.type === "generic_name") {
+                target = child.text.trim();
+            }
+        }
+        if (target === undefined)
+            return;
+        usings.push({
+            target,
+            alias,
+            isStatic: /\busing\s+static\b/.test(node.text),
+            isGlobal: /^\s*global\b/.test(node.text),
+            line: node.startPosition.row + 1,
+        });
+    };
+    const readType = (node, form, enclosing) => {
+        const name = node.childForFieldName("name")?.text.trim();
+        if (name === undefined)
+            return;
+        const path = [...enclosing, name];
+        const members = new Map();
+        const properties = [];
+        const typeRefs = [];
+        const memberProvenance = new Map();
+        // A primary constructor's parameters are members, and their types are
+        // written nowhere else: `record OrderRecord(string Id, Status Status)`.
+        const primary = node.childForFieldName("parameters");
+        if (primary !== null) {
+            const holder = { refs: typeRefs, locals: new Map(), pending: new Map(), parameterNames: new Set(), propertyAssignments: new Map() };
+            readParameters(primary, holder, members);
+        }
+        for (let index = 0; index < node.namedChildCount; index += 1) {
+            const child = node.namedChild(index);
+            if (child?.type === "parameter_list") {
+                const holder = { refs: typeRefs, locals: new Map(), pending: new Map(), parameterNames: new Set(), propertyAssignments: new Map() };
+                readParameters(child, holder, members);
+            }
+        }
+        const body = node.childForFieldName("body");
+        if (body !== null) {
+            for (let index = 0; index < body.namedChildCount; index += 1) {
+                const member = body.namedChild(index);
+                if (member === null)
+                    continue;
+                const nested = FORMS[member.type];
+                if (nested !== undefined) {
+                    readType(member, nested, path);
+                    continue;
+                }
+                if (member.type === "method_declaration") {
+                    const method = member.childForFieldName("name")?.text.trim();
+                    if (method !== undefined)
+                        funcs.push(readFunction(member, path, method));
+                    continue;
+                }
+                if (member.type === "constructor_declaration") {
+                    funcs.push(readFunction(member, path, ".ctor"));
+                    continue;
+                }
+                if (member.type === "property_declaration") {
+                    const property = member.childForFieldName("name")?.text.trim();
+                    const declared = typeName(member.childForFieldName("type"));
+                    if (property !== undefined)
+                        members.set(property, declared ?? null);
+                    if (property !== undefined) {
+                        const accessorList = member.childForFieldName("accessors");
+                        properties.push({
+                            name: property,
+                            // Raw text, because `string` and `string?` share a base name and
+                            // have opposite nullability. See {@link CsProperty}.
+                            written: member.childForFieldName("type")?.text.trim() ?? "",
+                            declared,
+                            isPublic: hasModifier(member, "public"),
+                            // An expression-bodied property (`=> x`) is a getter with no
+                            // accessor list, so both forms count.
+                            hasGetter: member.childForFieldName("value") !== null ||
+                                (accessorList?.text.includes("get") ?? false),
+                            attributes: attributesOf(member),
+                            line: member.startPosition.row + 1,
+                        });
+                    }
+                    if (typeof declared === "string") {
+                        typeRefs.push({
+                            kind: "type",
+                            name: declared,
+                            receiver: undefined,
+                            line: member.startPosition.row + 1,
+                            raw: member.text.slice(0, 160),
+                        });
+                    }
+                    // A property with a body is a function as well as a member.
+                    const accessors = member.childForFieldName("accessors");
+                    if (accessors !== null) {
+                        const holder = { refs: typeRefs, locals: new Map(), pending: new Map(), parameterNames: new Set(), propertyAssignments: new Map() };
+                        walkBody(accessors, holder);
+                    }
+                    const arrow = member.childForFieldName("value");
+                    if (arrow !== null) {
+                        const holder = { refs: typeRefs, locals: new Map(), pending: new Map(), parameterNames: new Set(), propertyAssignments: new Map() };
+                        walkBody(arrow, holder);
+                    }
+                    continue;
+                }
+                if (member.type === "field_declaration") {
+                    for (let inner = 0; inner < member.namedChildCount; inner += 1) {
+                        const declaration = member.namedChild(inner);
+                        if (declaration?.type !== "variable_declaration")
+                            continue;
+                        const declared = typeName(declaration.childForFieldName("type"));
+                        for (let each = 0; each < declaration.namedChildCount; each += 1) {
+                            const declarator = declaration.namedChild(each);
+                            if (declarator?.type !== "variable_declarator")
+                                continue;
+                            const field = declarator.childForFieldName("name")?.text.trim();
+                            if (field !== undefined)
+                                members.set(field, declared ?? null);
+                            // D-FIX-3's client-base extractor (DEC-164): a field's own
+                            // inline initialiser, when it is a traceable invocation.
+                            // `CleanArchitecture`'s `private readonly HttpClient _client =
+                            // factory.CreateClient();` is the measured shape.
+                            if (field !== undefined) {
+                                const initialiser = initialiserOf(declarator);
+                                if (initialiser?.type === "invocation_expression") {
+                                    const call = callSignature(initialiser);
+                                    if (call !== undefined)
+                                        memberProvenance.set(field, call);
+                                }
+                            }
+                        }
+                        if (typeof declared === "string") {
+                            typeRefs.push({
+                                kind: "type",
+                                name: declared,
+                                receiver: undefined,
+                                line: member.startPosition.row + 1,
+                                raw: member.text.slice(0, 160),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        const { names: baseList, written: baseListWritten } = baseListOf(node);
+        for (const supertype of baseList) {
+            typeRefs.push({
+                kind: "type",
+                name: supertype,
+                receiver: undefined,
+                line: node.startPosition.row + 1,
+                raw: supertype,
+            });
+        }
+        types.push({
+            name,
+            path,
+            form,
+            isPartial: hasModifier(node, "partial"),
+            isAbstract: hasModifier(node, "abstract"),
+            baseList,
+            baseListWritten,
+            members,
+            properties,
+            attributes: attributesOf(node),
+            attributeArguments: attributeArgumentsOf(node),
+            startLine: node.startPosition.row + 1,
+            endLine: node.endPosition.row + 1,
+            typeRefs,
+            memberProvenance,
+        });
+    };
+    const walk = (node, enclosing) => {
+        for (let index = 0; index < node.namedChildCount; index += 1) {
+            const child = node.namedChild(index);
+            if (child === null)
+                continue;
+            if (child.type === "using_directive") {
+                readUsing(child);
+                continue;
+            }
+            if (child.type === "file_scoped_namespace_declaration") {
+                // `namespace Shop.Orders;` — no body. Everything after it in the file is
+                // inside it, so the remaining siblings are walked with it in force. This
+                // is the modern default and permits exactly one namespace per file.
+                const name = child.childForFieldName("name")?.text.trim();
+                const nested = name === undefined ? enclosing : enclosing === "" ? name : `${enclosing}.${name}`;
+                if (namespaceName === "" && nested !== "")
+                    namespaceName = nested;
+                for (let after = index + 1; after < node.namedChildCount; after += 1) {
+                    const sibling = node.namedChild(after);
+                    if (sibling === null)
+                        continue;
+                    const form = FORMS[sibling.type];
+                    if (form !== undefined)
+                        readType(sibling, form, []);
+                    else if (sibling.type === "using_directive")
+                        readUsing(sibling);
+                }
+                return;
+            }
+            if (child.type === "namespace_declaration") {
+                // Block form. A file may legally declare several, and this reader takes
+                // the *first* — recorded as a known simplification rather than left as a
+                // silent one. Types after a second `namespace` block would be given a
+                // namespace they do not have.
+                const name = child.childForFieldName("name")?.text.trim();
+                const nested = name === undefined ? enclosing : enclosing === "" ? name : `${enclosing}.${name}`;
+                if (namespaceName === "" && nested !== "")
+                    namespaceName = nested;
+                const body = child.childForFieldName("body");
+                if (body !== null)
+                    walk(body, nested);
+                continue;
+            }
+            const form = FORMS[child.type];
+            if (form !== undefined) {
+                readType(child, form, []);
+                continue;
+            }
+            if (child.type === "preproc_if" || child.type === "declaration_list" || child.type === "global_statement") {
+                walk(child, enclosing);
+            }
+        }
+    };
+    walk(root, "");
+    return { file, namespace: namespaceName, usings, types, funcs, hasError, assembly: "" };
+}
+//# sourceMappingURL=parse.js.map