@descryy/adapter-java 0.1.0

package/dist/parse.js

@@ -0,0 +1,765 @@
+/**
+ * One Java compilation unit, read into the shape the resolver wants.
+ *
+ * The walk is hand-written rather than expressed as tree-sitter queries. A query
+ * returns matches; what this needs is *containment* — which class a method
+ * belongs to, which method a call sits in, which type a field was declared with —
+ * and containment is exactly what a match set discards. The TypeScript and Python
+ * extractors are both shaped this way for the same reason.
+ */
+/** Annotations that mark a method as a test case, across JUnit 4, 5 and TestNG. */
+const TEST_ANNOTATIONS = new Set([
+    "Test",
+    "ParameterizedTest",
+    "RepeatedTest",
+    "TestFactory",
+    "TestTemplate",
+]);
+const TYPE_DECLARATIONS = {
+    class_declaration: "class",
+    interface_declaration: "interface",
+    enum_declaration: "enum",
+    record_declaration: "record",
+    annotation_type_declaration: "annotation",
+};
+const ABSENT = { kind: "absent" };
+const UNREADABLE = { kind: "unreadable" };
+/** The primitive type nodes. An array of primitives is a reference type. */
+const PRIMITIVE_NODES = new Set(["integral_type", "floating_point_type", "boolean_type", "void_type"]);
+/**
+ * Read a type node, stripped of everything that is not identity.
+ *
+ * `List<String>` is a use of `List`; `Owner[]` is a use of `Owner`; `a.b.C` is a
+ * use of `C` qualified by a package. Generic arguments are deliberately *not*
+ * followed here — the caller walks them separately when it wants them, so that a
+ * field of type `Map<String, Owner>` can record a dependency on `Owner` without
+ * `Map` and `Owner` being confused for one another.
+ *
+ * A caller wanting a name for an edge asks for `kind === "named"` and gets the
+ * same behaviour it always had. A caller wanting to know *why* there is no name
+ * can now find out. See {@link TypeRead}.
+ */
+export function readTypeName(node) {
+    if (node === null)
+        return ABSENT;
+    if (PRIMITIVE_NODES.has(node.type))
+        return { kind: "primitive", name: node.text };
+    switch (node.type) {
+        case "type_identifier":
+            return { kind: "named", name: node.text };
+        case "generic_type":
+        case "array_type":
+        case "annotated_type": {
+            // An array or an annotated wrapper around a primitive is still a reference
+            // type — `int[]` is nullable — so a `primitive` inner read does not
+            // propagate outward. Only a name does.
+            for (let i = 0; i < node.namedChildCount; i += 1) {
+                const found = readTypeName(node.namedChild(i));
+                if (found.kind === "named")
+                    return found;
+            }
+            return UNREADABLE;
+        }
+        case "scoped_type_identifier": {
+            // Two different shapes wear the same node type, and the qualifier's own
+            // node type is what separates them:
+            //
+            //   com.example.Order      qualifier is `identifier`/`scoped_identifier`
+            //                          — a package. The identity is `Order`.
+            //   DiskLruCache.Snapshot  qualifier is `type_identifier` — an enclosing
+            //                          type. The identity is the whole path, because
+            //                          `Snapshot` alone is a different question.
+            //
+            // Returning the last segment for both is what typed a local declared
+            // `DiskLruCache.Snapshot` as `Snapshot`, so every `snapshot.getSource()`
+            // was refused with "declares no such member" — true of the type it asked
+            // about, and it asked about the wrong one. Lane E found the same defect in
+            // `adapter-kotlin` from the opposite end (the *outermost* segment).
+            const segments = [];
+            for (let i = 0; i < node.namedChildCount; i += 1) {
+                const child = node.namedChild(i);
+                if (child?.type === "type_identifier")
+                    segments.push(child.text);
+            }
+            if (segments.length === 0)
+                return UNREADABLE;
+            return { kind: "named", name: segments.join(".") };
+        }
+        default:
+            return UNREADABLE;
+    }
+}
+/** The declared name where one exists, for callers that only want an edge target. */
+function namedOnly(node) {
+    const read = readTypeName(node);
+    return read.kind === "named" ? read.name : undefined;
+}
+/**
+ * Every type name mentioned inside a type node, generic arguments included.
+ *
+ * `var` is excluded because it is not one. The grammar gives it `type_identifier`
+ * like any other, so it arrived in the ledger 479 times on one repository as a
+ * type that could not be found — a reference the source never made, filed against
+ * recall as though the adapter had missed something.
+ *
+ * ## A scoped name is one name, not its segments
+ *
+ * This used to recurse through `scoped_type_identifier` and push each segment,
+ * so `DiskLruCache.Snapshot` arrived as `DiskLruCache` **and** `Snapshot`. Both
+ * failure directions were reproduced on a synthetic:
+ *
+ * - the tail resolving to an unrelated top-level `Snapshot` in the same package
+ *   — `scopesFor` step 3 decides, so nothing else gets a turn. **A wrong edge.**
+ * - the tail resolving to nothing, losing the reference to the real nested type
+ *   and disclosing it as *"no declaration for this simple name"* — true of
+ *   `Snapshot`, and the source never wrote `Snapshot`.
+ *
+ * Measured before the change: 28 references across the four Java corpora hit the
+ * second case (`mall`'s `Criteria` ×19, `shopizer`'s `Category` ×4). The first
+ * was unwitnessed in 2,946 files — it needs a package declaring a top-level type
+ * whose name matches a nested one, which real code avoids. Proven on a
+ * synthetic, unwitnessed in the corpora; `bench/nested-type-capture.mjs`.
+ *
+ * Lane E found the mirror of this in `adapter-kotlin`, where `typeNameOf`
+ * returned the *outermost* segment instead. Same dropped qualifier, opposite
+ * end.
+ */
+function allTypeNames(node, out) {
+    if (node === null)
+        return;
+    if (node.type === "scoped_type_identifier") {
+        // The whole path as written. Not the segments — `A.B` is a reference to one
+        // type, and its qualifier is what tells `B` apart from every other `B`.
+        //
+        // Built from the *direct* `type_identifier` children rather than `node.text`
+        // so that `A<B>.C` yields `A.C` and not the literal source with its generic
+        // arguments in it. Anything else under the node — a generic argument list on
+        // an outer segment — is still walked, so `B` is not lost.
+        const segments = [];
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const child = node.namedChild(i);
+            if (child === null)
+                continue;
+            if (child.type === "type_identifier")
+                segments.push(child.text);
+            else
+                allTypeNames(child, out);
+        }
+        if (segments.length > 0)
+            out.push(segments.join("."));
+        return;
+    }
+    if (node.type === "type_identifier" && node.text !== "var")
+        out.push(node.text);
+    for (let i = 0; i < node.namedChildCount; i += 1)
+        allTypeNames(node.namedChild(i), out);
+}
+/**
+ * The first argument of a call, only when it is a bare string literal.
+ *
+ * A `binary_expression` first argument — `base + "/orders"` — returns
+ * `undefined` rather than its left operand. The written prefix is not the path
+ * at run time, and DEC-127 refuses an assembled path rather than reporting the
+ * fragment it can see. See {@link JavaRef.firstStringArgument}.
+ */
+function firstStringArgumentOf(invocation) {
+    const args = invocation.childForFieldName("arguments");
+    if (args === null)
+        return undefined;
+    const first = args.namedChild(0);
+    if (first === null || first.type !== "string_literal")
+        return undefined;
+    // `"abc"` -> `abc`. A text block or an escaped quote is left as written; the
+    // caller only ever compares it against a path shape, and a path with an
+    // escape in it is not one this reader claims.
+    return first.text.slice(1, -1);
+}
+/**
+ * The first argument's raw text, whatever shape it is. See
+ * {@link JavaRef.firstArgumentText}.
+ */
+function firstArgumentTextOf(invocation) {
+    const args = invocation.childForFieldName("arguments");
+    if (args === null)
+        return undefined;
+    const first = args.namedChild(0);
+    return first === null ? undefined : first.text;
+}
+function childOfType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i += 1) {
+        const child = node.namedChild(i);
+        if (child !== null && child.type === type)
+            return child;
+    }
+    return null;
+}
+/**
+ * Every string literal an argument declares, quotes stripped.
+ *
+ * Handles the single form `"/x"` and the array form `{"/a", "/b"}`, because
+ * Java's annotation syntax treats them as the same thing and Spring code uses
+ * both freely. Anything that is not a literal contributes nothing — see
+ * {@link JavaAnnotation.values}.
+ */
+function literals(node) {
+    if (node === null)
+        return [];
+    if (node.type === "string_literal")
+        return [node.text.slice(1, -1)];
+    // Annotation arrays are `element_value_array_initializer`, NOT the
+    // `array_initializer` used for ordinary Java array literals. Reading the wrong
+    // one silently returns nothing — which is how the array form survived a
+    // typecheck, a lint, 158 tests and a green control run while emitting no route
+    // for 140 of shopizer's 356 mappings.
+    if (node.type !== "element_value_array_initializer" && node.type !== "array_initializer") {
+        return [];
+    }
+    const out = [];
+    for (let i = 0; i < node.namedChildCount; i += 1) {
+        const element = node.namedChild(i);
+        if (element !== null && element.type === "string_literal") {
+            out.push(element.text.slice(1, -1));
+        }
+    }
+    return out;
+}
+/**
+ * Every annotation on a declaration, with its arguments.
+ *
+ * Replaces the boolean-only read that `isTest` used: the same walk now produces
+ * the whole list, and `isTest` is derived from it. One traversal, one notion of
+ * what an annotation is, and no second place to keep in step.
+ */
+/**
+ * Keyword modifiers on a declaration, annotations excluded.
+ *
+ * The `modifiers` node holds both — `private static final` sit beside
+ * `@Column(...)` as siblings — so the annotation reader walks the named
+ * children and this one walks all of them, taking what is left.
+ */
+function readModifiers(node) {
+    const modifiers = childOfType(node, "modifiers");
+    if (modifiers === null)
+        return [];
+    const out = [];
+    for (let i = 0; i < modifiers.childCount; i += 1) {
+        const child = modifiers.child(i);
+        if (child === null || child.isNamed)
+            continue;
+        out.push(child.text);
+    }
+    return out;
+}
+function readAnnotations(node) {
+    const modifiers = childOfType(node, "modifiers");
+    if (modifiers === null)
+        return [];
+    const out = [];
+    for (let i = 0; i < modifiers.namedChildCount; i += 1) {
+        const annotation = modifiers.namedChild(i);
+        if (annotation === null)
+            continue;
+        if (annotation.type !== "marker_annotation" && annotation.type !== "annotation")
+            continue;
+        const nameNode = annotation.childForFieldName("name");
+        if (nameNode === null)
+            continue;
+        const qualified = nameNode.text;
+        const named = new Map();
+        const rawArguments = [];
+        const values = [];
+        const args = annotation.childForFieldName("arguments");
+        if (args !== null) {
+            for (let a = 0; a < args.namedChildCount; a += 1) {
+                const arg = args.namedChild(a);
+                if (arg === null)
+                    continue;
+                rawArguments.push(arg.text);
+                if (arg.type === "element_value_pair") {
+                    const key = arg.childForFieldName("key");
+                    const found = literals(arg.childForFieldName("value"));
+                    if (key !== null && found.length > 0)
+                        named.set(key.text, found);
+                    continue;
+                }
+                // The unnamed argument. Only literals are taken: a constant reference or
+                // a concatenation is a path this adapter cannot read, and DEC-127
+                // refuses it rather than recording the expression as a template.
+                values.push(...literals(arg));
+            }
+        }
+        out.push({
+            // `@Test` and `@org.junit.Test` are the same annotation written two ways.
+            name: qualified.slice(qualified.lastIndexOf(".") + 1),
+            qualified,
+            line: annotation.startPosition.row + 1,
+            values,
+            named,
+            rawArguments,
+        });
+    }
+    return out;
+}
+/** Does this declaration carry `@Test` or one of its siblings? */
+function isTestAnnotated(annotations) {
+    return annotations.some((each) => TEST_ANNOTATIONS.has(each.name));
+}
+/**
+ * The name a call's receiver is written as, or `(computed)` when it is not a
+ * name at all.
+ *
+ * `object.text` is the receiver's *whole source text*, so a chained call put
+ * `config.get("airbyte")` into the ledger's target column — 18.9% of one
+ * repository's Java entries carried a target that was an expression rather than
+ * a name, and the column is indexed and later compared as a name. This is the
+ * same defect the TypeScript adapter carried, found the same way, in the same
+ * week: a raw target taken from a node's text instead of from its structure.
+ *
+ * `(computed)` is deliberately a string rather than `undefined`. `undefined`
+ * means *unqualified*, which resolves against the enclosing class — conflating
+ * the two would turn every chained call into a claim about `this`.
+ *
+ * A `method_invocation` object — `client.get().uri(...)` — is peeled the same
+ * way `field_access` already is, encoded as `<base>.<name>()` (the literal
+ * `()`, regardless of the real call's own arguments — this is a receiver
+ * label, not a copy of the source). This exists for exactly one consumer,
+ * `client.ts`'s WebClient/RestClient builder-chain reader (ledger row
+ * D-FIX-3's `.get().uri(...)` case): the fluent client's verb lives on the
+ * call *before* `uri`, not on `uri` itself, so the chain must survive past
+ * this function or that verb is unrecoverable. It does not create any new
+ * false resolution elsewhere — `receiverTarget` in `extract.ts` already
+ * refuses any dotted receiver as `untypedReceiver`, so a `CALLS`/`TESTS` edge
+ * from a chain never fires; it previously refused the same call under the
+ * `(computed)` label, and now refuses it under a more legible one. A base
+ * that itself resolves to `(computed)` (e.g. `new Foo.Builder().x()` — the
+ * `object_creation_expression` case, not `method_invocation`) still returns
+ * `(computed)` unchanged, so the OkHttp/`java.net.http` builder refusal this
+ * file's header documents is untouched.
+ */
+function receiverName(node) {
+    if (node.type === "identifier")
+        return node.text;
+    if (node.type === "this")
+        return "this";
+    if (node.type === "field_access") {
+        const object = node.childForFieldName("object");
+        const field = node.childForFieldName("field");
+        if (object !== null && field !== null) {
+            const base = receiverName(object);
+            return base === "(computed)" ? "(computed)" : `${base}.${field.text}`;
+        }
+    }
+    if (node.type === "method_invocation") {
+        const object = node.childForFieldName("object");
+        const name = node.childForFieldName("name");
+        if (object !== null && name !== null) {
+            const base = receiverName(object);
+            return base === "(computed)" ? "(computed)" : `${base}.${name.text}()`;
+        }
+    }
+    return "(computed)";
+}
+/** Record a declared name, poisoning it when the same name gets two types. */
+function declare(table, name, type) {
+    const value = type ?? null;
+    if (!table.has(name)) {
+        table.set(name, value);
+        return;
+    }
+    if (table.get(name) !== value)
+        table.set(name, null);
+}
+/**
+ * The name a `package_declaration` declares, ignoring any annotations on it.
+ *
+ * Returns `undefined` rather than `""` when no identifier is found, so the
+ * caller keeps whatever it had instead of silently adopting the default
+ * package — an unreadable declaration and an absent one are different facts.
+ */
+function packageIdentifier(declaration) {
+    for (let i = 0; i < declaration.namedChildCount; i += 1) {
+        const child = declaration.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === "identifier" || child.type === "scoped_identifier")
+            return child.text;
+    }
+    return undefined;
+}
+export function readUnit(root, file, hasError) {
+    const unit = {
+        file,
+        packageName: "",
+        identityPackage: "",
+        singleTypeImports: new Map(),
+        staticMemberImports: new Map(),
+        wildcardImports: [],
+        importLines: [],
+        types: [],
+        hasError,
+    };
+    let packageName = "";
+    for (let i = 0; i < root.namedChildCount; i += 1) {
+        const statement = root.namedChild(i);
+        if (statement === null)
+            continue;
+        if (statement.type === "package_declaration") {
+            // Read by node type, not by position. A package declaration may be
+            // annotated — `@NonNullApi package dev.morphia.query;` — and the
+            // annotation is `namedChild(0)`, so a positional read returns
+            // `"@NonNullApi"` as the package name. Every annotated `package-info.java`
+            // in a repository carries the *same* annotation, so all of them then share
+            // one identity package and one MODULE id: on `morphia`, 29 files collapsed
+            // to 1 node and 28 declarations were lost. The audit reported it as
+            // `cross-file-other`, which is the column that column exists for.
+            packageName = packageIdentifier(statement) ?? packageName;
+            continue;
+        }
+        if (statement.type === "import_declaration") {
+            const wildcard = childOfType(statement, "asterisk") !== null;
+            const name = statement.namedChild(0);
+            if (name === null)
+                continue;
+            const fqn = name.text;
+            const line = statement.startPosition.row + 1;
+            unit.importLines.push({ fqn, wildcard, line });
+            if (wildcard) {
+                unit.wildcardImports.push(fqn);
+                continue;
+            }
+            // A static import names a member, not a type: `a.b.C.method` binds
+            // `method`, and treating it as a type import would bind the simple name
+            // `method` to a class that does not exist. Only the declaring type is kept.
+            const isStatic = statement.children.some((child) => child?.type === "static");
+            const segments = fqn.split(".");
+            const owner = isStatic ? segments.slice(0, -1).join(".") : fqn;
+            const simple = owner.slice(owner.lastIndexOf(".") + 1);
+            if (simple !== "")
+                unit.singleTypeImports.set(simple, owner);
+            if (isStatic) {
+                const member = segments[segments.length - 1];
+                if (member !== undefined && member !== "")
+                    unit.staticMemberImports.set(member, owner);
+            }
+            continue;
+        }
+        const kind = TYPE_DECLARATIONS[statement.type];
+        if (kind !== undefined)
+            readType(statement, kind, packageName, unit.types);
+    }
+    return { ...unit, packageName };
+}
+function readType(node, kind, prefix, into) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode === null)
+        return;
+    const simpleName = nameNode.text;
+    const fqn = prefix === "" ? simpleName : `${prefix}.${simpleName}`;
+    const type = {
+        simpleName,
+        fqn,
+        kind,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        extendsNames: [],
+        implementsNames: [],
+        annotations: readAnnotations(node),
+        methods: [],
+        fields: new Map(),
+        fieldDeclarations: [],
+        typeRefs: [],
+    };
+    const superclass = childOfType(node, "superclass");
+    if (superclass !== null) {
+        const name = namedOnly(superclass.namedChild(0));
+        if (name !== undefined)
+            type.extendsNames.push(name);
+    }
+    // An interface's `extends` is a list and is an interface relationship, not a
+    // class one — the vocabulary has both edges and the corpus tests them apart.
+    const extendsInterfaces = childOfType(node, "extends_interfaces");
+    const superInterfaces = childOfType(node, "super_interfaces");
+    for (const clause of [extendsInterfaces, superInterfaces]) {
+        if (clause === null)
+            continue;
+        const list = childOfType(clause, "type_list");
+        if (list === null)
+            continue;
+        for (let i = 0; i < list.namedChildCount; i += 1) {
+            const name = namedOnly(list.namedChild(i));
+            if (name === undefined)
+                continue;
+            if (clause === extendsInterfaces)
+                type.extendsNames.push(name);
+            else
+                type.implementsNames.push(name);
+        }
+    }
+    // A record's components are its fields *and* its accessor methods. Java
+    // declares both implicitly, so a codebase that uses records — which is most
+    // modern Java — has a call graph full of `config.region()` calls with nothing
+    // to point at. Four of fourteen recall misses on `airbyte` were exactly this.
+    if (kind === "record") {
+        const parameters = node.childForFieldName("parameters");
+        for (let i = 0; parameters !== null && i < parameters.namedChildCount; i += 1) {
+            const component = parameters.namedChild(i);
+            if (component === null || component.type !== "formal_parameter")
+                continue;
+            const name = component.childForFieldName("name");
+            const declared = namedOnly(component.childForFieldName("type"));
+            if (name === null)
+                continue;
+            declare(type.fields, name.text, declared);
+            // The accessor is declared by the component and has the component's span:
+            // there is no separate source for it, and inventing one would be a lie
+            // about where the reader should look.
+            type.methods.push({
+                name: name.text,
+                fqn: `${fqn}.${name.text}`,
+                startLine: component.startPosition.row + 1,
+                endLine: component.endPosition.row + 1,
+                isTest: false,
+                // A record component's accessor is synthesised, so it carries no
+                // annotations of its own — the component's annotations belong to the
+                // field, not to the generated getter.
+                annotations: [],
+                returnType: readTypeName(component.childForFieldName("type")),
+                refs: [],
+                locals: new Map(),
+                parameterNames: new Set(),
+            });
+            const names = [];
+            allTypeNames(component.childForFieldName("type"), names);
+            for (const each of names) {
+                type.typeRefs.push({
+                    kind: "type",
+                    name: each,
+                    receiver: undefined,
+                    line: component.startPosition.row + 1,
+                    raw: component.text.slice(0, 120),
+                });
+            }
+        }
+    }
+    const body = node.childForFieldName("body");
+    if (body !== null)
+        readBody(body, type, fqn, into);
+    into.push(type);
+}
+function readBody(body, type, fqn, into) {
+    for (let i = 0; i < body.namedChildCount; i += 1) {
+        const member = body.namedChild(i);
+        if (member === null)
+            continue;
+        // An enum's members do not sit directly in its body: the constants do, and
+        // everything else is wrapped in `enum_body_declarations`. Without this an
+        // enum contributed constants and no methods at all, so a static factory like
+        // `IdType.findByBsonType(…)` had nothing to resolve to.
+        if (member.type === "enum_body_declarations") {
+            readBody(member, type, fqn, into);
+            continue;
+        }
+        const nested = TYPE_DECLARATIONS[member.type];
+        if (nested !== undefined) {
+            readType(member, nested, fqn, into);
+            continue;
+        }
+        if (member.type === "field_declaration") {
+            const typeNode = member.childForFieldName("type");
+            // One read, and the caller asks it two different questions: what name does
+            // an edge point at, and can this field hold null. They have different
+            // answers for `long`, which is the whole point of {@link TypeRead}.
+            const read = readTypeName(typeNode);
+            const declared = read.kind === "named" ? read.name : undefined;
+            // Annotations sit on the declaration, so `int a, b;` gives both the same
+            // set — which is what Java means by it.
+            const fieldAnnotations = readAnnotations(member);
+            const fieldModifiers = readModifiers(member);
+            for (let d = 0; d < member.namedChildCount; d += 1) {
+                const declarator = member.namedChild(d);
+                if (declarator === null || declarator.type !== "variable_declarator")
+                    continue;
+                const name = declarator.childForFieldName("name");
+                if (name === null)
+                    continue;
+                declare(type.fields, name.text, declared);
+                type.fieldDeclarations.push({
+                    name: name.text,
+                    // A primitive has no declaration to point an edge at, so `declaredType`
+                    // is `undefined` here and `primitive` is `true` — the two facts the old
+                    // single sentinel could not tell apart.
+                    declaredType: declared,
+                    primitive: read.kind === "primitive",
+                    line: member.startPosition.row + 1,
+                    annotations: fieldAnnotations,
+                    modifiers: fieldModifiers,
+                });
+            }
+            const names = [];
+            allTypeNames(typeNode, names);
+            for (const name of names) {
+                type.typeRefs.push({
+                    kind: "type",
+                    name,
+                    receiver: undefined,
+                    line: member.startPosition.row + 1,
+                    raw: typeNode?.text.slice(0, 120) ?? name,
+                });
+            }
+            continue;
+        }
+        if (member.type === "method_declaration" || member.type === "constructor_declaration") {
+            readMethod(member, type, fqn);
+        }
+    }
+}
+function readMethod(node, type, ownerFqn) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode === null)
+        return;
+    // A constructor is named after its class, so `OrderService` would name both the
+    // CLASS and a FUNCTION in one file — two nodes a corpus role binds on `(file,
+    // name)` cannot be told apart, and the harness correctly refuses to guess.
+    // `<init>` is what the JVM itself calls a constructor and can collide with
+    // nothing, because it is not a legal Java identifier.
+    const name = node.type === "constructor_declaration" ? "<init>" : nameNode.text;
+    const annotations = readAnnotations(node);
+    const method = {
+        name,
+        fqn: `${ownerFqn}.${name}`,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        isTest: isTestAnnotated(annotations),
+        annotations,
+        returnType: readTypeName(node.childForFieldName("type")),
+        refs: [],
+        locals: new Map(),
+        parameterNames: new Set(),
+    };
+    const parameters = node.childForFieldName("parameters");
+    if (parameters !== null) {
+        for (let i = 0; i < parameters.namedChildCount; i += 1) {
+            const parameter = parameters.namedChild(i);
+            if (parameter === null)
+                continue;
+            if (parameter.type !== "formal_parameter" && parameter.type !== "spread_parameter")
+                continue;
+            const name = parameter.childForFieldName("name");
+            const declared = namedOnly(parameter.childForFieldName("type"));
+            if (name !== null) {
+                declare(method.locals, name.text, declared);
+                method.parameterNames.add(name.text);
+            }
+            const names = [];
+            allTypeNames(parameter.childForFieldName("type"), names);
+            for (const each of names) {
+                method.refs.push({
+                    kind: "type",
+                    name: each,
+                    receiver: undefined,
+                    line: parameter.startPosition.row + 1,
+                    raw: parameter.text.slice(0, 120),
+                });
+            }
+        }
+    }
+    const returned = namedOnly(node.childForFieldName("type"));
+    if (returned !== undefined) {
+        method.refs.push({
+            kind: "type",
+            name: returned,
+            receiver: undefined,
+            line: method.startLine,
+            raw: returned,
+        });
+    }
+    const body = node.childForFieldName("body");
+    if (body !== null)
+        walkBody(body, method);
+    type.methods.push(method);
+}
+function walkBody(node, method) {
+    if (node.type === "local_variable_declaration") {
+        const typeNode = node.childForFieldName("type");
+        // `var` is inference, and inference without a type checker is a guess.
+        const declared = typeNode?.type === "type_identifier" && typeNode.text === "var"
+            ? undefined
+            : namedOnly(typeNode);
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const declarator = node.namedChild(i);
+            if (declarator === null || declarator.type !== "variable_declarator")
+                continue;
+            const name = declarator.childForFieldName("name");
+            if (name !== null)
+                declare(method.locals, name.text, declared);
+        }
+        const names = [];
+        allTypeNames(typeNode, names);
+        for (const name of names) {
+            method.refs.push({
+                kind: "type",
+                name,
+                receiver: undefined,
+                line: node.startPosition.row + 1,
+                raw: typeNode?.text.slice(0, 120) ?? name,
+            });
+        }
+    }
+    if (node.type === "method_invocation") {
+        const nameNode = node.childForFieldName("name");
+        const object = node.childForFieldName("object");
+        if (nameNode !== null) {
+            const receiver = object === null ? undefined : receiverName(object);
+            const literal = firstStringArgumentOf(node);
+            const argumentText = firstArgumentTextOf(node);
+            method.refs.push({
+                kind: "call",
+                name: nameNode.text,
+                receiver,
+                line: node.startPosition.row + 1,
+                raw: receiver === undefined ? nameNode.text : `${receiver}.${nameNode.text}`,
+                // Spread rather than assigned, because `exactOptionalPropertyTypes`
+                // distinguishes an absent property from one present and undefined, and
+                // that distinction is the point: absent means "not a call", present and
+                // undefined would mean "a call whose first argument is nothing".
+                ...(literal === undefined ? {} : { firstStringArgument: literal }),
+                ...(argumentText === undefined ? {} : { firstArgumentText: argumentText }),
+            });
+        }
+    }
+    // `Status.PENDING` — an enum constant or a static field, which is a dependency
+    // on the declaring type. Without this the corpus's class-used-as-value pattern
+    // has nothing to find, because an enum constant is not a call and not a
+    // declared type.
+    if (node.type === "field_access") {
+        const object = node.childForFieldName("object");
+        const field = node.childForFieldName("field");
+        if (object !== null && object.type === "identifier" && field !== null) {
+            method.refs.push({
+                kind: "member",
+                name: object.text,
+                receiver: undefined,
+                line: node.startPosition.row + 1,
+                raw: `${object.text}.${field.text}`,
+            });
+        }
+    }
+    if (node.type === "object_creation_expression") {
+        const created = namedOnly(node.childForFieldName("type"));
+        if (created !== undefined) {
+            method.refs.push({
+                kind: "type",
+                name: created,
+                receiver: undefined,
+                line: node.startPosition.row + 1,
+                raw: `new ${created}`,
+            });
+        }
+    }
+    for (let i = 0; i < node.namedChildCount; i += 1) {
+        const child = node.namedChild(i);
+        if (child !== null)
+            walkBody(child, method);
+    }
+}
+//# sourceMappingURL=parse.js.map