@descryy/adapter-csharp 0.1.0 → 0.3.0

package/dist/parse.d.ts

@@ -1,31 +1,21 @@
 /**
  * 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.
+ * Hand-written walk, as in Java/Go/Rust/PHP: containment is what a resolver
+ * needs, and a query's match set discards exactly that.
  *
- * ## What C# changes
+ * What C# changes:
+ * - A type may be declared in several files (`partial class`) — DEC-083
+ *   settles identity, this reader only collects the parts.
+ * - `using` imports a namespace, not one type (unlike PHP's `use`), so a bare
+ *   name is resolved outward through enclosing namespaces then imports —
+ *   found in two places is an ambiguity to disclose, not a tie to break.
+ * - The base list doesn't say which entry is the class. DEC-084: at most one
+ *   base class, required first, so later entries are interfaces
+ *   unconditionally and only the first ever needs resolving. `IFoo` isn't read.
  *
- * 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.
+ * Nested types are ordinary here (unlike PHP), so a type carries its nesting
+ * path, not a single name.
  */
 import type { Node } from "@descryy/adapter-treesitter";
 export interface CsRef {
@@ -51,31 +41,25 @@ export interface CsRef {
         readonly name: string;
     };
     /**
-     * The name *might* be a type, and might equally be a variable.
-     *
-     * `Status.Pending` and `order.Total` are the same node shape, and only the
-     * resolver knows whether `Status` names a type or `order` names a local. A
-     * speculative reference that turns out to be a value is not an unresolved
-     * reference — it is not a type reference at all — so it is dropped silently
-     * instead of filling the ledger with entries no reader could act on.
+     * The name might be a type, might be a variable — `Status.Pending` and
+     * `order.Total` are the same node shape, only the resolver knows which.
+     * A speculative ref resolving to a value isn't unresolved, it's not a type
+     * reference at all, so it's dropped silently rather than ledgered.
      */
     readonly speculative?: boolean;
     readonly line: number;
     readonly raw: string;
     /**
-     * The call's first argument, only when it is a bare string literal —
-     * mirrors Java's `JavaRef.firstStringArgument` exactly, for the identical
-     * reason: a `binary_expression` or interpolated first argument returns
-     * `undefined` rather than a fragment, because the written prefix is not the
-     * value at run time. See {@link firstStringArgumentOf}.
+     * The call's first argument, only when a bare string literal — mirrors
+     * Java's `JavaRef.firstStringArgument`: a binary/interpolated expression
+     * returns `undefined`, since the written prefix isn't the runtime value.
+     * See {@link firstStringArgumentOf}.
      */
     readonly firstStringArgument?: string;
     /**
-     * The first argument's raw source text, captured whether or not it is a
-     * literal — mirrors Java's `JavaRef.firstArgumentText` exactly: DEC-242's
-     * `blockedBy`/`refusalClass` classification needs to see *what* blocked
-     * resolution when {@link firstStringArgument} is absent, not just that it
-     * was absent.
+     * The first argument's raw text regardless of shape — mirrors Java's
+     * `JavaRef.firstArgumentText`: DEC-242 needs to see what blocked resolution
+     * when {@link firstStringArgument} is absent, not just that it was.
      */
     readonly firstArgumentText?: string;
 }
@@ -88,23 +72,19 @@ export interface CsScope {
     readonly locals: Map<string, string | null>;
     readonly pending: Map<string, PendingType>;
     /**
-     * Names declared in the enclosing method's own parameter list — a subset of
-     * {@link locals}'s keys, kept separately because DEC-242's `varies-per-call`
-     * classification needs *parameter*, not *local*: a call argument that is a
-     * bare parameter name is a caller-supplied value with no fixed answer to
-     * state; a local variable might still be assigned from a constant.
+     * Names from the enclosing method's parameter list, a subset of
+     * {@link locals}'s keys kept separately: DEC-242's `varies-per-call` needs
+     * *parameter*, not *local* — a bare parameter name is caller-supplied with
+     * no fixed answer, a local might still be a constant.
      */
     readonly parameterNames: Set<string>;
     /**
-     * `X = expr;` and `this.X = expr;` where `expr` is a traceable invocation —
-     * `PendingType`'s own `{receiver, name}` shape, reused rather than duplicated.
-     * Only consulted for a `.ctor`'s own scope, by D-FIX-3's client-base
-     * extractor (DEC-164): `public HttpClient Client { get; }` assigned in the
-     * constructor from `factory.CreateClient()` is the shape eShopOnWeb's whole
-     * `USES_API` population goes through, and a property has no initialiser of
-     * its own to read the way a field does — the constructor body is the only
-     * place the assignment is written. Harmless elsewhere; nothing outside a
-     * `.ctor` walk reads this map.
+     * `X = expr;` / `this.X = expr;` where `expr` is a traceable invocation,
+     * reusing `PendingType`'s shape. Consulted only for a `.ctor`'s scope, by
+     * the client-base extractor (DEC-164): a property assigned in the
+     * constructor from `factory.CreateClient()` (eShopOnWeb's whole `USES_API`
+     * population) has no initialiser of its own — the ctor body is the only
+     * place the assignment is written.
      */
     readonly propertyAssignments: Map<string, PendingType>;
 }
@@ -124,19 +104,17 @@ export interface CsFunc {
     readonly scope: CsScope;
 }
 /**
- * A property declaration, kept alongside the `members` name→type map.
- *
- * The map answers "what type is this name" for receiver typing. EF Core needs
- * four things it cannot carry: the **attributes** (`[Key]`, `[Required]`,
- * `[NotMapped]`), the **line**, whether the property is **public with a getter**
- * — DEC-128 §3's definition of a persistent member — and the type **as written**.
+ * A property declaration, kept alongside the `members` name->type map, which
+ * answers "what type is this name" for receiver typing. EF Core needs four
+ * things the map can't carry: attributes (`[Key]`, `[Required]`, `[NotMapped]`),
+ * line, public-with-getter (DEC-128 §3's persistent-member test), and the
+ * type as written.
  *
- * `written` is the raw source text, not the base name, and that is load-bearing.
- * `string` and `string?` have the same base name and opposite nullability, and
- * `int?` is nullable regardless of the NRT context while `string?` is meaningful
- * only under it. A reader that keeps only the base name cannot tell any of those
- * apart. Counted across the corpora before choosing this shape: `string` 786 /
- * `string?` 508 / `int?` 332 / `int` 218 in `jellyfin` alone.
+ * `written` is raw source text, not the base name: `string`/`string?` share a
+ * base name but opposite nullability, and `int?` is nullable regardless of
+ * NRT context while `string?` is meaningful only under it. Counted across
+ * corpora before choosing this shape: `string` 786 / `string?` 508 / `int?`
+ * 332 / `int` 218 in jellyfin alone.
  */
 export interface CsProperty {
     readonly name: string;
@@ -159,18 +137,11 @@ export interface CsType {
     /** The base list **in written order**. DEC-084 reads position as evidence. */
     readonly baseList: string[];
     /**
-     * The same entries **as written**, generic arguments intact.
-     *
-     * `baseList` goes through `typeName`, which drops generic arguments on purpose
-     * — `List<Order>` names `List`, and identity is what the resolver wants. A
-     * framework extractor wants the opposite: `IEntityTypeConfiguration<Order>`
-     * *is* the mapping declaration and `Order` is the whole fact, so the collapsed
-     * form is empty of the thing EF Core is stating.
-     *
-     * Both are right and both are kept. This is the second construct where a
-     * language-level normalisation and a framework-level reading want different
-     * halves of the same node — the first was a property's written type, where
-     * `string` and `string?` share a base name and have opposite nullability.
+     * The same entries as written, generic arguments intact. `baseList` drops
+     * generics via `typeName` (`List<Order>` -> `List`, identity for the
+     * resolver), but `IEntityTypeConfiguration<Order>`'s `Order` argument *is*
+     * the mapping fact a framework extractor needs — the collapsed form is
+     * empty of it. Both kept, same split as a property's written type.
      */
     readonly baseListWritten: string[];
     /** Property and field names -> declared type, `null` when ambiguous. */
@@ -184,13 +155,11 @@ export interface CsType {
     readonly endLine: number;
     readonly typeRefs: CsRef[];
     /**
-     * A field's own inline initialiser, when it is a traceable invocation —
-     * `private readonly HttpClient _client = factory.CreateClient();`. Same
-     * `PendingType` shape and same one reader (D-FIX-3's client-base extractor,
-     * DEC-164) as `CsScope.propertyAssignments`; kept separate because a field
-     * initialiser is read here, at the declaration, and a property's is read
-     * from its `.ctor`'s body — two different places in the source for the
-     * same fact.
+     * A field's own inline initialiser when it's a traceable invocation
+     * (`private readonly HttpClient _client = factory.CreateClient();`). Same
+     * shape and reader as `CsScope.propertyAssignments`, kept separate because
+     * a field initialiser is read at the declaration, a property's from its
+     * `.ctor` body — different places in the source for the same fact.
      */
     readonly memberProvenance: Map<string, PendingType>;
 }
@@ -201,14 +170,10 @@ export interface CsUsing {
     readonly alias: string | undefined;
     readonly isStatic: boolean;
     /**
-     * `global using …` — in force for **every file in the project**, not just
-     * this one.
-     *
-     * Modern C# leans on this heavily: .NET 6 onwards emits a generated file of
-     * implicit global usings for every project, and an alias declared this way is
-     * the language's one construct that binds a name here to a type declared
-     * elsewhere without creating a second symbol. Treating it as file-local would
-     * make every name it introduces unresolvable everywhere else.
+     * `global using …` — in force for every file in the project, not just this
+     * one. Modern C# (.NET 6+ implicit global usings) leans on this heavily;
+     * treating it as file-local would make every name it introduces
+     * unresolvable elsewhere.
      */
     readonly isGlobal: boolean;
     readonly line: number;
@@ -225,15 +190,10 @@ export interface CsFile {
     readonly assembly: string;
 }
 /**
- * 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.
+ * The type a type expression names. `undefined` = none (predefined/`var`/absent),
+ * `null` = named but ambiguous, `string` = the type, generics dropped
+ * (`List<Order>` -> `List`; `Order` is recorded as its own reference —
+ * collapsing both would attribute the collection's methods to its element).
  */
 export declare function typeName(node: Node | null | undefined): string | null | undefined;
 export declare function readFile(root: Node, file: string, hasError: boolean): CsFile;

package/dist/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"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"}

package/dist/parse.js

@@ -1,31 +1,21 @@
 /**
  * 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.
+ * Hand-written walk, as in Java/Go/Rust/PHP: containment is what a resolver
+ * needs, and a query's match set discards exactly that.
  *
- * ## What C# changes
+ * What C# changes:
+ * - A type may be declared in several files (`partial class`) — DEC-083
+ *   settles identity, this reader only collects the parts.
+ * - `using` imports a namespace, not one type (unlike PHP's `use`), so a bare
+ *   name is resolved outward through enclosing namespaces then imports —
+ *   found in two places is an ambiguity to disclose, not a tie to break.
+ * - The base list doesn't say which entry is the class. DEC-084: at most one
+ *   base class, required first, so later entries are interfaces
+ *   unconditionally and only the first ever needs resolving. `IFoo` isn't read.
  *
- * 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.
+ * Nested types are ordinary here (unlike PHP), so a type carries its nesting
+ * path, not a single name.
  */
 /** Keywords that name no user type. `var` is handled separately. */
 const PREDEFINED = new Set([
@@ -34,15 +24,10 @@ const PREDEFINED = new Set([
     "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.
+ * The type a type expression names. `undefined` = none (predefined/`var`/absent),
+ * `null` = named but ambiguous, `string` = the type, generics dropped
+ * (`List<Order>` -> `List`; `Order` is recorded as its own reference —
+ * collapsing both would attribute the collection's methods to its element).
  */
 export function typeName(node) {
     if (node === null || node === undefined)
@@ -93,18 +78,12 @@ function hasModifier(node, keyword) {
     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.
+ * `[Fact]`, `[Theory]`, `[Xunit.Fact]` -> the last segment, and its arguments.
+ * 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 dropped argument *is* the route. Third instance of
+ * identity-normalises/fidelity-preserves in this adapter (after a property's
+ * written type and a base list's generic argument).
  */
 function attributeArgumentsOf(node) {
     const found = {};
@@ -178,11 +157,9 @@ function describeReceiver(node) {
             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.
+            // `x?.y.z()` / `a?[0].F()`: null-conditional changes only whether the
+            // chain evaluates, not what it denotes (`x?.y` names what `x.y` names).
+            // Unwrapping here reuses the member-access machinery below.
             const object = describeReceiver(node.namedChild(0));
             const binding = node.namedChild(1);
             if (binding?.type !== "member_binding_expression") {
@@ -199,11 +176,10 @@ function describeReceiver(node) {
             };
         }
         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.
+            // `this._repository.FindById()` (type on the member decl) vs.
+            // `Shop.Orders.Money.Format()` (a namespace path) are both this node
+            // type — telling them apart needs the resolver, so the whole written
+            // path is handed over and tried as a qualified name first.
             const object = describeReceiver(node.childForFieldName("expression"));
             const member = node.childForFieldName("name");
             if (member === null)
@@ -257,15 +233,10 @@ function callSignature(node) {
     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.
+ * The first argument of an invocation, only when a bare string literal.
+ * Mirrors Java's `firstStringArgumentOf`: `"abc"` -> `abc`; a concatenation
+ * or interpolated string (`$"..."`) returns `undefined` rather than a
+ * fragment — DEC-127's refusal-not-guess, same as Java's identical shape.
  */
 function firstStringArgumentOf(invocation) {
     const args = invocation.childForFieldName("arguments");
@@ -339,10 +310,9 @@ function pushInvocation(scope, node) {
             ...(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."
+            // Spread, not assigned: `exactOptionalPropertyTypes` distinguishes
+            // absent ("not worth reading further") from present-and-undefined
+            // ("a call whose first argument is nothing").
             ...(literal === undefined ? {} : { firstStringArgument: literal }),
             ...(argumentText === undefined ? {} : { firstArgumentText: argumentText }),
         });
@@ -360,13 +330,10 @@ function pushInvocation(scope, node) {
     });
 }
 /**
- * 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.
+ * A `variable_declarator`'s initialiser, whether or not its type was written
+ * explicitly. `recordDeclarator` only needs this for `var`, but a field's
+ * inline initialiser matters to the client-base extractor (DEC-164) even
+ * with an explicit type, hence a standalone reader.
  */
 function initialiserOf(declarator) {
     let initialiser;
@@ -454,12 +421,11 @@ function walkBody(node, scope) {
                 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*.
+                // `Client = factory.CreateClient(...)` / `this.Client = ...`: only
+                // the client-base extractor (DEC-164) reads this, only from a
+                // `.ctor`'s scope. The invocation is walked normally regardless and
+                // produces its own `CsRef`; this exists only 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") {
@@ -493,12 +459,10 @@ function walkBody(node, scope) {
                 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.
+                // `if (item is Folder folder)` / `case Folder folder:` binds a local
+                // whose type is written right there — previously disclosed as an
+                // untyped receiver, honest but wasteful. Idiomatic modern C#
+                // (jellyfin's `MetadataService.GetChildrenForMetadataUpdates`), not a corner.
                 const declared = typeName(current.namedChild(0));
                 const bound = current.namedChild(1)?.text.trim();
                 if (bound !== undefined)
@@ -531,10 +495,9 @@ function walkBody(node, scope) {
                 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.
+                // `Status.Pending`, `Order.Empty` — a type referenced as a value
+                // (golden pattern 13). Recorded only when the holder is a bare name;
+                // the resolver decides type vs. variable, declining if neither.
                 const holder = current.childForFieldName("expression");
                 if (holder !== null && (holder.type === "identifier" || holder.type === "qualified_name")) {
                     scope.refs.push({
@@ -748,10 +711,8 @@ export function readFile(root, file, hasError) {
                             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.
+                            // Client-base extractor (DEC-164): a field's inline initialiser
+                            // when traceable — CleanArchitecture's measured shape.
                             if (field !== undefined) {
                                 const initialiser = initialiserOf(declarator);
                                 if (initialiser?.type === "invocation_expression") {
@@ -812,9 +773,8 @@ export function readFile(root, file, hasError) {
                 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.
+                // `namespace Shop.Orders;` — no body; remaining siblings are inside
+                // it. Modern default, 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 !== "")
@@ -832,10 +792,9 @@ export function readFile(root, file, hasError) {
                 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.
+                // Block form. A file may legally declare several; this reader takes
+                // the first (disclosed simplification) — types after a second block
+                // would be given a namespace they don't have.
                 const name = child.childForFieldName("name")?.text.trim();
                 const nested = name === undefined ? enclosing : enclosing === "" ? name : `${enclosing}.${name}`;
                 if (namespaceName === "" && nested !== "")