@descryy/adapter-go 0.1.0

package/dist/parse.js

@@ -0,0 +1,890 @@
+/**
+ * One Go file, read into the shape the resolver wants.
+ *
+ * Hand-written walk, as in Java and for the same reason: containment is what a
+ * resolver needs and a query's match set is exactly what discards it.
+ *
+ * ## What Go changes, and what it does not
+ *
+ * The harness is untouched — the same `parserFor` / `parseText` / node cursor.
+ * What is new is a rule set, and Go's rules are genuinely different from Java's
+ * rather than a translation of them:
+ *
+ *   - The importable unit is the **package**, not the file. Files in one package
+ *     share a namespace with no qualification at all, so an unqualified name
+ *     resolves across files that never mention each other.
+ *   - A method is attached by a *receiver*, not by nesting: `func (o *Order)
+ *     Describe()` declares a method on `Order` from anywhere in the package.
+ *   - There is no inheritance. Embedding is the nearest thing and it is
+ *     explicit; interface satisfaction is structural and invisible without a
+ *     type checker, so it is not claimed at all.
+ */
+import { readGoRoutes } from "./routes.js";
+import { readGoClientCalls } from "./client.js";
+import { readGrpcMethodConsts, readGrpcRegistrations } from "./grpc.js";
+/** The `//go:build` line, which must appear before the package clause. */
+export function buildConstraintOf(text) {
+    for (const raw of text.split("\n", 40)) {
+        const line = raw.trim();
+        if (line.startsWith("//go:build"))
+            return line.slice("//go:build".length).trim();
+        if (line.startsWith("package "))
+            return undefined;
+    }
+    return undefined;
+}
+/**
+ * Go's universe block: predeclared types, constants and functions.
+ *
+ * These are not declarations any package makes, so a reference to one is not a
+ * candidate edge and filing it is not disclosure but noise. On `prometheus` they
+ * were roughly 28,000 ledger entries claiming "no declaration for this name in
+ * the package" about `string`, `int64` and `len` — a reason that is not merely
+ * unhelpful but false.
+ *
+ * The grammar cannot help here: unlike Java, where `int` is an `integral_type`,
+ * Go spells every one of these as an ordinary `type_identifier`.
+ */
+const UNIVERSE = new Set([
+    "bool", "byte", "complex64", "complex128", "error", "float32", "float64",
+    "int", "int8", "int16", "int32", "int64", "rune", "string",
+    "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "any", "comparable",
+    "true", "false", "iota", "nil",
+    "append", "cap", "clear", "close", "complex", "copy", "delete", "imag", "len",
+    "make", "max", "min", "new", "panic", "print", "println", "real", "recover",
+]);
+export function isUniverse(name) {
+    return UNIVERSE.has(name);
+}
+/** `*T`, `[]T`, `map[K]T`, `chan T` — the name underneath. */
+export function baseTypeName(node) {
+    if (node === null)
+        return undefined;
+    switch (node.type) {
+        case "type_identifier":
+            return UNIVERSE.has(node.text) ? undefined : node.text;
+        case "qualified_type": {
+            // `pkg.Type` — the package qualifier matters, so both parts are kept and
+            // the resolver splits them.
+            return node.text;
+        }
+        case "pointer_type":
+        case "slice_type":
+        case "array_type":
+        case "channel_type":
+        case "parenthesized_type":
+        case "variadic_parameter_declaration":
+            return baseTypeName(node.namedChild(0));
+        case "map_type":
+            // The value type is the dependency worth recording; the key is usually a
+            // primitive and recording both would need two refs for one written type.
+            return baseTypeName(node.childForFieldName("value") ?? node.namedChild(1));
+        case "generic_type":
+            return baseTypeName(node.childForFieldName("type") ?? node.namedChild(0));
+        default:
+            return undefined;
+    }
+}
+/** Every type name inside a type node, generic arguments and map keys included. */
+function allTypeNames(node, out, skip) {
+    if (node === null)
+        return;
+    if (node.type === "qualified_type") {
+        // The qualified name and *nothing underneath it*. Recursing into it also
+        // yielded the bare `type_identifier`, so `http.ResponseWriter` asked about
+        // `ResponseWriter` as well — and gin declares one, so the parameter type of
+        // a `http.Handler` implementation resolved to gin's own interface. A false
+        // claim, and the kind that corrupts every layer above the graph.
+        out.push(node.text);
+        return;
+    }
+    if (node.type === "type_identifier" && !UNIVERSE.has(node.text) && skip?.has(node.text) !== true) {
+        out.push(node.text);
+    }
+    for (let i = 0; i < node.namedChildCount; i += 1)
+        allTypeNames(node.namedChild(i), out, skip);
+}
+/**
+ * Type parameter names declared by a function or type.
+ *
+ * `T` was the ninth most common ledger target on `prometheus` with 2,215
+ * entries. A type parameter is a binding, not a reference to a declaration, and
+ * demanding an edge for it is the same mistake TypeScript made with `infer`.
+ */
+function typeParametersOf(node) {
+    const names = new Set();
+    const list = node.childForFieldName("type_parameters");
+    if (list === null)
+        return names;
+    for (let i = 0; i < list.namedChildCount; i += 1) {
+        const declaration = list.namedChild(i);
+        if (declaration === null)
+            continue;
+        for (let n = 0; n < declaration.namedChildCount; n += 1) {
+            const child = declaration.namedChild(n);
+            if (child !== null && child.type === "identifier")
+                names.add(child.text);
+        }
+    }
+    return names;
+}
+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 receiver is written as, or `(computed)` when it is not a name. */
+function receiverName(node) {
+    if (node.type === "identifier" || node.type === "package_identifier" || node.type === "field_identifier") {
+        return node.text;
+    }
+    if (node.type === "selector_expression") {
+        const operand = node.childForFieldName("operand");
+        const field = node.childForFieldName("field");
+        if (operand !== null && field !== null) {
+            const base = receiverName(operand);
+            return base === "(computed)" ? "(computed)" : `${base}.${field.text}`;
+        }
+    }
+    // `(*x).f`, `x[0].f`, `f().g` — nothing wrote a name here.
+    return "(computed)";
+}
+/**
+ * The receiver's type where the site writes it down.
+ *
+ * Two forms, both unambiguous: a type assertion states the type outright, and a
+ * parenthesised composite literal is a value of exactly the type it names. Both
+ * previously became `(computed)`, and both are common — `p.(*listPostings).Len()`
+ * on prometheus, `(IndentedJSON{data}).Render(w)` on gin.
+ */
+function receiverTypeAtSite(node) {
+    if (node.type === "parenthesized_expression") {
+        const inner = node.namedChild(0);
+        return inner === null ? undefined : receiverTypeAtSite(inner);
+    }
+    if (node.type === "type_assertion_expression") {
+        return baseTypeName(node.childForFieldName("type"));
+    }
+    if (node.type === "composite_literal") {
+        return baseTypeName(node.childForFieldName("type"));
+    }
+    if (node.type === "unary_expression" && node.text.startsWith("&")) {
+        const inner = node.namedChild(0);
+        return inner === null ? undefined : receiverTypeAtSite(inner);
+    }
+    return undefined;
+}
+/** `xs[i]` -> `xs`. Only a plain name is followed; `f()[i]` writes no type. */
+function indexedReceiver(node) {
+    const current = node.type === "parenthesized_expression" ? node.namedChild(0) : node;
+    if (current === null || current.type !== "index_expression")
+        return undefined;
+    const operand = current.childForFieldName("operand");
+    return operand !== null && operand.type === "identifier" ? operand.text : undefined;
+}
+/** The call whose result is the receiver: `engine().RunUnix(file)`. */
+function receiverCallOf(node) {
+    const current = node.type === "parenthesized_expression" ? node.namedChild(0) : node;
+    if (current === null || current.type !== "call_expression")
+        return undefined;
+    const callee = current.childForFieldName("function");
+    if (callee === null)
+        return undefined;
+    if (callee.type === "identifier")
+        return { receiver: undefined, name: callee.text };
+    if (callee.type === "selector_expression") {
+        const operand = callee.childForFieldName("operand");
+        const field = callee.childForFieldName("field");
+        if (operand === null || field === null || operand.type !== "identifier")
+            return undefined;
+        return { receiver: operand.text, name: field.text };
+    }
+    return undefined;
+}
+export function readFile(root, file, hasError) {
+    const cut = file.lastIndexOf("/");
+    const unit = {
+        file,
+        packageName: "",
+        directory: cut === -1 ? "" : file.slice(0, cut),
+        imports: new Map(),
+        importPaths: [],
+        types: [],
+        funcs: [],
+        aliases: [],
+        packageVars: new Map(),
+        routes: [],
+        routeRefusals: [],
+        grpcMethodConsts: [],
+        grpcRegistrations: [],
+        hasError,
+        importPath: "",
+        buildConstraint: undefined,
+    };
+    let packageName = "";
+    for (let i = 0; i < root.namedChildCount; i += 1) {
+        const statement = root.namedChild(i);
+        if (statement === null)
+            continue;
+        if (statement.type === "package_clause") {
+            packageName = statement.namedChild(0)?.text ?? "";
+            continue;
+        }
+        if (statement.type === "import_declaration") {
+            readImports(statement, unit);
+            continue;
+        }
+        if (statement.type === "type_declaration") {
+            for (let s = 0; s < statement.namedChildCount; s += 1) {
+                const spec = statement.namedChild(s);
+                if (spec === null || (spec.type !== "type_spec" && spec.type !== "type_alias"))
+                    continue;
+                readType(spec, unit);
+            }
+            continue;
+        }
+        if (statement.type === "var_declaration" || statement.type === "const_declaration") {
+            readAliases(statement, unit);
+            readPackageVars(statement, unit);
+            continue;
+        }
+        if (statement.type === "function_declaration" || statement.type === "method_declaration") {
+            readFunc(statement, unit, file);
+        }
+    }
+    // After the loop, because provenance is decided by the import table and the
+    // import declaration may sit anywhere above the call that uses it.
+    const read = readGoRoutes(root, unit);
+    unit.routes.push(...read.declarations);
+    unit.routeRefusals.push(...read.refusals);
+    unit.grpcMethodConsts.push(...readGrpcMethodConsts(root));
+    unit.grpcRegistrations.push(...readGrpcRegistrations(root));
+    return { ...unit, packageName };
+}
+/**
+ * An unaliased import's likely binding name: the last path segment, unless
+ * that segment is a bare major-version marker (`v2`, `v3`, …), in which case
+ * the segment before it — Go's semantic-import-versioning convention keeps the
+ * package's own name there, not in the version segment.
+ */
+function defaultImportAlias(path) {
+    const segments = path.split("/");
+    const last = segments[segments.length - 1] ?? path;
+    if (segments.length > 1 && /^v[0-9]+$/.test(last)) {
+        return segments[segments.length - 2] ?? last;
+    }
+    return last;
+}
+function readImports(node, unit) {
+    const specs = [];
+    const collect = (current) => {
+        if (current.type === "import_spec") {
+            specs.push(current);
+            return;
+        }
+        for (let i = 0; i < current.namedChildCount; i += 1) {
+            const child = current.namedChild(i);
+            if (child !== null)
+                collect(child);
+        }
+    };
+    collect(node);
+    for (const spec of specs) {
+        const pathNode = spec.childForFieldName("path");
+        if (pathNode === null)
+            continue;
+        const path = pathNode.text.replace(/^["`]|["`]$/g, "");
+        unit.importPaths.push({ path, line: spec.startPosition.row + 1 });
+        const alias = spec.childForFieldName("name")?.text;
+        // `_ "…"` is a blank import for side effects and binds no name; `. "…"` dumps
+        // the package into this file's scope, which cannot be told apart from a
+        // package-local name without reading the imported package, so neither binds
+        // an alias here.
+        if (alias === "_" || alias === ".")
+            continue;
+        // No alias: the binding is the package's declared name, which is *usually*
+        // but not always the last path segment. The one named, common exception is
+        // Go's own semantic-import-versioning convention (go.dev/blog/v2-go-modules):
+        // a `/v2`+ suffix is a major-version marker, not part of the package's own
+        // name — `go-chi/chi/v5` still declares `package chi`, not `package v5` — so
+        // that segment is skipped in favour of the one before it. Anything else the
+        // last segment gets wrong is disclosed by the reference failing to resolve
+        // rather than by a further guess.
+        unit.imports.set(alias ?? defaultImportAlias(path), path);
+    }
+}
+/**
+ * Package-level `var X = Y` / `var X = pkg.Y` bindings.
+ *
+ * Deliberately narrow. One name, one value, and that value a bare name or a
+ * qualified name — nothing else. A call, a literal, a composite or a
+ * multi-assignment is a value being computed, not a name being bound, and
+ * treating it as a binding would put a guessed target in the graph.
+ */
+/**
+ * Package-level values whose type is written down.
+ *
+ * Two forms, both unambiguous: an explicit type, and a composite literal, which
+ * is a value of exactly the type it names. Anything else — a call result, an
+ * expression — is left out, because guessing there is the thing the precision
+ * rule forbids and the ledger already says so.
+ */
+function readPackageVars(node, unit) {
+    for (let i = 0; i < node.namedChildCount; i += 1) {
+        const spec = node.namedChild(i);
+        if (spec === null)
+            continue;
+        if (spec.type !== "var_spec" && spec.type !== "const_spec")
+            continue;
+        const names = [];
+        for (let n = 0; n < spec.namedChildCount; n += 1) {
+            const child = spec.namedChild(n);
+            if (child !== null && child.type === "identifier")
+                names.push(child);
+        }
+        if (names.length !== 1)
+            continue;
+        const name = names[0];
+        if (name === undefined)
+            continue;
+        const declared = baseTypeName(spec.childForFieldName("type"));
+        if (declared !== undefined) {
+            unit.packageVars.set(name.text, declared);
+            continue;
+        }
+        const values = spec.childForFieldName("value");
+        if (values === null || values.namedChildCount !== 1)
+            continue;
+        const value = values.namedChild(0);
+        const written = value === null ? undefined : receiverTypeAtSite(value);
+        if (written !== undefined)
+            unit.packageVars.set(name.text, written);
+    }
+}
+function readAliases(node, unit) {
+    for (let i = 0; i < node.namedChildCount; i += 1) {
+        const spec = node.namedChild(i);
+        if (spec === null)
+            continue;
+        if (spec.type !== "var_spec" && spec.type !== "const_spec")
+            continue;
+        const names = [];
+        for (let n = 0; n < spec.namedChildCount; n += 1) {
+            const child = spec.namedChild(n);
+            if (child !== null && child.type === "identifier")
+                names.push(child);
+        }
+        const name = names[0];
+        if (names.length !== 1 || name === undefined)
+            continue;
+        const values = spec.childForFieldName("value");
+        if (values === null || values.namedChildCount !== 1)
+            continue;
+        const value = values.namedChild(0);
+        if (value === null)
+            continue;
+        if (value.type === "identifier") {
+            unit.aliases.push({ name: name.text, target: value.text, line: spec.startPosition.row + 1 });
+            continue;
+        }
+        if (value.type === "selector_expression") {
+            const operand = value.childForFieldName("operand");
+            const field = value.childForFieldName("field");
+            if (operand === null || field === null || operand.type !== "identifier")
+                continue;
+            unit.aliases.push({
+                name: name.text,
+                target: `${operand.text}.${field.text}`,
+                line: spec.startPosition.row + 1,
+            });
+        }
+    }
+}
+function readType(spec, unit) {
+    const nameNode = spec.childForFieldName("name");
+    if (nameNode === null)
+        return;
+    const typeNode = spec.childForFieldName("type");
+    const form = typeNode?.type === "struct_type" ? "struct" : typeNode?.type === "interface_type" ? "interface" : "alias";
+    const params = typeParametersOf(spec);
+    const type = {
+        name: nameNode.text,
+        form,
+        startLine: spec.startPosition.row + 1,
+        endLine: spec.endPosition.row + 1,
+        embeds: [],
+        fields: new Map(),
+        typeRefs: [],
+    };
+    if (typeNode?.type === "struct_type") {
+        const fields = typeNode.namedChild(0);
+        for (let i = 0; fields !== null && i < fields.namedChildCount; i += 1) {
+            const field = fields.namedChild(i);
+            if (field === null || field.type !== "field_declaration")
+                continue;
+            const fieldType = field.childForFieldName("type");
+            const declared = baseTypeName(fieldType);
+            const names = [];
+            for (let n = 0; n < field.namedChildCount; n += 1) {
+                const child = field.namedChild(n);
+                if (child !== null && child.type === "field_identifier")
+                    names.push(child);
+            }
+            if (names.length === 0) {
+                // An embedded field: `Base` with no name of its own. Go's only explicit
+                // type-to-type relationship, and the closest thing it has to inheritance.
+                const embedded = baseTypeName(fieldType) ?? field.text.replace(/^\*/, "").trim();
+                if (embedded !== "")
+                    type.embeds.push(embedded);
+            }
+            for (const name of names)
+                declare(type.fields, name.text, declared);
+            const written = [];
+            allTypeNames(fieldType, written, params);
+            for (const each of written) {
+                type.typeRefs.push({
+                    kind: "type",
+                    name: each,
+                    receiver: undefined,
+                    line: field.startPosition.row + 1,
+                    raw: fieldType?.text.slice(0, 120) ?? each,
+                });
+            }
+        }
+    }
+    if (typeNode?.type === "interface_type") {
+        // An embedded interface is written exactly like an embedded struct field.
+        for (let i = 0; i < typeNode.namedChildCount; i += 1) {
+            const member = typeNode.namedChild(i);
+            if (member === null)
+                continue;
+            if (member.type === "type_identifier" || member.type === "qualified_type") {
+                type.embeds.push(member.text);
+            }
+        }
+    }
+    if (form === "alias" && typeNode !== null) {
+        const written = [];
+        allTypeNames(typeNode, written, params);
+        for (const each of written) {
+            type.typeRefs.push({
+                kind: "type",
+                name: each,
+                receiver: undefined,
+                line: spec.startPosition.row + 1,
+                raw: typeNode.text.slice(0, 120),
+            });
+        }
+    }
+    unit.types.push(type);
+}
+/** `func TestXxx(t *testing.T)` in a `_test.go` file — the whole convention. */
+function isTestFunc(name, file) {
+    return file.endsWith("_test.go") && /^(Test|Benchmark|Fuzz|Example)[^a-z]?/.test(name);
+}
+/** The types whose `Run` method declares a subtest. */
+const TEST_RECEIVERS = new Set(["testing.T", "testing.B", "testing.F"]);
+function readFunc(node, unit, file) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode === null)
+        return;
+    let receiver;
+    const receiverList = node.childForFieldName("receiver");
+    if (receiverList !== null) {
+        const declaration = receiverList.namedChild(0);
+        receiver = baseTypeName(declaration?.childForFieldName("type") ?? null);
+    }
+    const params = typeParametersOf(node);
+    const name = nameNode.text;
+    const fn = {
+        name,
+        key: receiver === undefined ? name : `${receiver}.${name}`,
+        receiver,
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        isTest: receiver === undefined && isTestFunc(name, file),
+        refs: [],
+        locals: new Map(),
+        pending: new Map(),
+        parameterNames: new Set(),
+        subtests: [],
+        results: resultTypes(node.childForFieldName("result")),
+    };
+    if (receiverList !== null) {
+        const declaration = receiverList.namedChild(0);
+        const receiverName_ = declaration?.childForFieldName("name");
+        if (receiverName_ !== null && receiverName_ !== undefined && receiver !== undefined) {
+            declare(fn.locals, receiverName_.text, receiver);
+        }
+    }
+    const parameters = node.childForFieldName("parameters");
+    if (parameters !== null)
+        collectParameters(parameters, fn, params, true);
+    const result = node.childForFieldName("result");
+    if (result !== null) {
+        if (result.type === "parameter_list")
+            collectParameters(result, fn, params);
+        const written = [];
+        allTypeNames(result, written, params);
+        for (const each of written) {
+            fn.refs.push({ kind: "type", name: each, receiver: undefined, line: fn.startLine, raw: result.text.slice(0, 120) });
+        }
+    }
+    let clientCalls = [];
+    let clientRefusals = [];
+    const body = node.childForFieldName("body");
+    if (body !== null) {
+        walkBody(body, fn, {
+            params,
+            subtests: fn.subtests,
+            suite: fn.isTest ? [name] : [],
+            inTest: fn.isTest,
+        });
+        // After `walkBody`, so `fn.locals` already has every parameter and every
+        // `:=`/`var` declaration this function makes — including a `*http.Client`
+        // constructed partway through the body, not just one declared as a parameter.
+        const client = readGoClientCalls(body, unit, fn.locals, fn.isTest, fn.parameterNames);
+        clientCalls = client.calls;
+        clientRefusals = client.refusals;
+    }
+    unit.funcs.push({ ...fn, clientCalls, clientRefusals });
+}
+/**
+ * The declared result types of a function, in order.
+ *
+ * Go allows `(a, b Foo)` — one type, two results — so a declaration contributes
+ * as many entries as it names, and position is what `x, err := f()` binds by.
+ */
+function resultTypes(result) {
+    if (result === null)
+        return [];
+    if (result.type !== "parameter_list")
+        return [baseTypeName(result)];
+    const out = [];
+    for (let i = 0; i < result.namedChildCount; i += 1) {
+        const parameter = result.namedChild(i);
+        if (parameter === null)
+            continue;
+        if (parameter.type !== "parameter_declaration" && parameter.type !== "variadic_parameter_declaration")
+            continue;
+        const written = baseTypeName(parameter.childForFieldName("type"));
+        let named = 0;
+        for (let n = 0; n < parameter.namedChildCount; n += 1) {
+            if (parameter.namedChild(n)?.type === "identifier")
+                named += 1;
+        }
+        for (let k = 0; k < Math.max(1, named); k += 1)
+            out.push(written);
+    }
+    return out;
+}
+function collectParameters(list, fn, params, isInputParameterList = false) {
+    for (let i = 0; i < list.namedChildCount; i += 1) {
+        const parameter = list.namedChild(i);
+        if (parameter === null)
+            continue;
+        if (parameter.type !== "parameter_declaration" && parameter.type !== "variadic_parameter_declaration")
+            continue;
+        const typeNode = parameter.childForFieldName("type");
+        const declared = baseTypeName(typeNode);
+        const nameNode = parameter.childForFieldName("name");
+        if (nameNode !== null) {
+            declare(fn.locals, nameNode.text, declared);
+            // Only the true input parameter list, never a named-return parameter
+            // list (Go's grammar uses the same node shape for both) — a named
+            // return starts at its zero value and may be reassigned, so it is not
+            // the caller-supplied, never-fixed value DEC-242's varies-per-call means.
+            if (isInputParameterList)
+                fn.parameterNames.add(nameNode.text);
+        }
+        const written = [];
+        allTypeNames(typeNode, written, params);
+        for (const each of written) {
+            fn.refs.push({
+                kind: "type",
+                name: each,
+                receiver: undefined,
+                line: parameter.startPosition.row + 1,
+                raw: typeNode?.text.slice(0, 120) ?? each,
+            });
+        }
+    }
+}
+/** The text of a string literal, or `undefined` when it is not one. */
+function literalText(node) {
+    if (node === null)
+        return undefined;
+    if (node.type !== "interpreted_string_literal" && node.type !== "raw_string_literal")
+        return undefined;
+    return node.text.slice(1, -1);
+}
+/**
+ * `t.Run("name", func(t *testing.T) { … })`, when that is what this call is.
+ *
+ * Every condition is evidence written in the source: the receiver's type is a
+ * declared parameter type, the name is a literal, and the body is a closure
+ * right there. A call named `Run` on anything else, or with a computed name, is
+ * not a subtest declaration and produces nothing.
+ */
+function subtestOf(node, scope, ctx) {
+    if (!ctx.inTest)
+        return undefined;
+    const callee = node.childForFieldName("function");
+    if (callee === null || callee.type !== "selector_expression")
+        return undefined;
+    if (callee.childForFieldName("field")?.text !== "Run")
+        return undefined;
+    const operand = callee.childForFieldName("operand");
+    if (operand === null || operand.type !== "identifier")
+        return undefined;
+    const receiverType = scope.locals.get(operand.text);
+    if (receiverType === undefined || receiverType === null || !TEST_RECEIVERS.has(receiverType))
+        return undefined;
+    const args = node.childForFieldName("arguments");
+    if (args === null || args.namedChildCount !== 2)
+        return undefined;
+    const name = literalText(args.namedChild(0));
+    const closure = args.namedChild(1);
+    if (name === undefined || closure === null || closure.type !== "func_literal")
+        return undefined;
+    const body = closure.childForFieldName("body");
+    if (body === null)
+        return undefined;
+    const subtest = {
+        name,
+        suite: [...ctx.suite],
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        refs: [],
+        // A closure sees the names around it, so the enclosing scope's types carry
+        // in. Its own parameters are collected below and shadow them.
+        locals: new Map(scope.locals),
+        pending: new Map(scope.pending),
+        parameterNames: new Set(scope.parameterNames),
+    };
+    const parameters = closure.childForFieldName("parameters");
+    if (parameters !== null)
+        collectParameters(parameters, subtest, ctx.params, true);
+    return { subtest, body };
+}
+function walkBody(node, fn, ctx) {
+    const params = ctx.params;
+    // A subtest declaration, not a call. Taken before the generic call handling so
+    // that `t.Run` is neither emitted as an edge nor filed as an unresolved one —
+    // it was never a candidate edge, it was a declaration.
+    if (node.type === "call_expression") {
+        const found = subtestOf(node, fn, ctx);
+        if (found !== undefined) {
+            ctx.subtests.push(found.subtest);
+            walkBody(found.body, found.subtest, {
+                ...ctx,
+                suite: [...ctx.suite, found.subtest.name],
+            });
+            return;
+        }
+    }
+    /**
+     * A closure's parameters are written down exactly like a function's.
+     *
+     * `router.Use(func(c *Context) { c.Next() })` is the commonest shape in Go —
+     * every HTTP handler, every `sort.Slice`, every goroutine — and leaving these
+     * out of `locals` made the receiver untypeable at each of them. Five of gin's
+     * nine measured recall misses were this one omission.
+     *
+     * The closure's names go into the enclosing function's table rather than a
+     * scope of their own, because a closure has no node to attribute references
+     * to. That flattening is safe in the direction that matters: `declare()`
+     * degrades a name declared twice with different types to `null`, so a genuine
+     * shadow produces a *dropped* edge and never a wrong one.
+     */
+    if (node.type === "func_literal") {
+        const parameters = node.childForFieldName("parameters");
+        if (parameters !== null)
+            collectParameters(parameters, fn, params, true);
+    }
+    // `var x T` and `x := expr` — only the first writes a type down.
+    if (node.type === "var_declaration" || node.type === "const_declaration") {
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const spec = node.namedChild(i);
+            if (spec === null)
+                continue;
+            const typeNode = spec.childForFieldName("type");
+            const declared = baseTypeName(typeNode);
+            for (let n = 0; n < spec.namedChildCount; n += 1) {
+                const child = spec.namedChild(n);
+                if (child !== null && child.type === "identifier")
+                    declare(fn.locals, child.text, declared);
+            }
+            const written = [];
+            allTypeNames(typeNode, written, params);
+            for (const each of written) {
+                fn.refs.push({
+                    kind: "type",
+                    name: each,
+                    receiver: undefined,
+                    line: spec.startPosition.row + 1,
+                    raw: typeNode?.text.slice(0, 120) ?? each,
+                });
+            }
+        }
+    }
+    // `o := &Order{…}` — a short declaration whose right-hand side is a composite
+    // literal is the one inferred form whose type *is* written down.
+    if (node.type === "short_var_declaration") {
+        const left = node.childForFieldName("left");
+        const right = node.childForFieldName("right");
+        const literal = findCompositeType(right);
+        if (left !== null && left.namedChildCount === 1 && literal !== undefined) {
+            const name = left.namedChild(0);
+            if (name !== null && name.type === "identifier")
+                declare(fn.locals, name.text, literal);
+        }
+        else if (left !== null) {
+            // `x, err := f(…)` — the type is written down, in the callee's signature
+            // rather than here. Recorded as a pending binding and resolved once every
+            // package is known; parsing is per file and the callee may be elsewhere.
+            const call = calledOnce(right);
+            for (let i = 0; i < left.namedChildCount; i += 1) {
+                const name = left.namedChild(i);
+                if (name === null || name.type !== "identifier")
+                    continue;
+                declare(fn.locals, name.text, undefined);
+                if (call === undefined || name.text === "_")
+                    continue;
+                const existing = fn.pending.get(name.text);
+                const binding = { ...call, index: i };
+                if (existing === undefined)
+                    fn.pending.set(name.text, binding);
+                else if (existing.name !== binding.name || existing.receiver !== binding.receiver || existing.index !== i) {
+                    // Declared twice from different calls: ambiguous, so neither.
+                    fn.pending.delete(name.text);
+                }
+            }
+        }
+    }
+    // `for _, tc := range cases` binds names with no written type. Left out of
+    // `locals` they looked like package-level identifiers, and `tc` alone became
+    // 1,184 ledger entries on prometheus.
+    if (node.type === "range_clause") {
+        const left = node.childForFieldName("left");
+        for (let i = 0; left !== null && i < left.namedChildCount; i += 1) {
+            const name = left.namedChild(i);
+            if (name !== null && name.type === "identifier")
+                declare(fn.locals, name.text, undefined);
+        }
+    }
+    if (node.type === "composite_literal") {
+        const written = baseTypeName(node.childForFieldName("type"));
+        if (written !== undefined) {
+            fn.refs.push({
+                kind: "type",
+                name: written,
+                receiver: undefined,
+                line: node.startPosition.row + 1,
+                raw: written,
+            });
+        }
+    }
+    if (node.type === "call_expression") {
+        const callee = node.childForFieldName("function");
+        if (callee !== null) {
+            if (callee.type === "selector_expression") {
+                const operand = callee.childForFieldName("operand");
+                const field = callee.childForFieldName("field");
+                if (operand !== null && field !== null) {
+                    const receiver = receiverName(operand);
+                    const written = receiverTypeAtSite(operand);
+                    const call = written === undefined ? receiverCallOf(operand) : undefined;
+                    const indexed = written === undefined && call === undefined ? indexedReceiver(operand) : undefined;
+                    fn.refs.push({
+                        kind: "call",
+                        name: field.text,
+                        receiver,
+                        ...(written === undefined ? {} : { receiverType: written }),
+                        ...(call === undefined ? {} : { receiverCall: call }),
+                        ...(indexed === undefined ? {} : { receiverIndex: indexed }),
+                        line: node.startPosition.row + 1,
+                        raw: `${receiver}.${field.text}`,
+                    });
+                }
+            }
+            else if (callee.type === "identifier") {
+                fn.refs.push({
+                    kind: "call",
+                    name: callee.text,
+                    receiver: undefined,
+                    line: node.startPosition.row + 1,
+                    raw: callee.text,
+                });
+            }
+        }
+    }
+    // `pkg.Const` / `Type.Member` outside a call — a dependency on the qualifier.
+    if (node.type === "selector_expression" && node.parent?.type !== "call_expression") {
+        const operand = node.childForFieldName("operand");
+        const field = node.childForFieldName("field");
+        if (operand !== null && field !== null && operand.type === "identifier") {
+            // The *qualified* name, so `model.LabelValue` can resolve to the type in
+            // the imported package rather than being asked about as the bare word
+            // `model`, which named nothing and produced 1,694 entries on prometheus.
+            fn.refs.push({
+                kind: "member",
+                name: `${operand.text}.${field.text}`,
+                receiver: operand.text,
+                line: node.startPosition.row + 1,
+                raw: `${operand.text}.${field.text}`,
+            });
+        }
+    }
+    for (let i = 0; i < node.namedChildCount; i += 1) {
+        const child = node.namedChild(i);
+        if (child !== null)
+            walkBody(child, fn, ctx);
+    }
+}
+/**
+ * The single call on the right of `:=`, as a name the extractor can resolve.
+ *
+ * Only a lone call counts. `a, b := f(), g()` binds two different results and
+ * `a := f() + 1` binds an expression, so neither is a result binding.
+ */
+function calledOnce(right) {
+    if (right === null || right.namedChildCount !== 1)
+        return undefined;
+    const call = right.namedChild(0);
+    if (call === null || call.type !== "call_expression")
+        return undefined;
+    const callee = call.childForFieldName("function");
+    if (callee === null)
+        return undefined;
+    if (callee.type === "identifier")
+        return { receiver: undefined, name: callee.text };
+    if (callee.type === "selector_expression") {
+        const operand = callee.childForFieldName("operand");
+        const field = callee.childForFieldName("field");
+        if (operand === null || field === null || operand.type !== "identifier")
+            return undefined;
+        return { receiver: operand.text, name: field.text };
+    }
+    return undefined;
+}
+/** The type of a composite literal on the right of `:=`, when there is one. */
+function findCompositeType(node) {
+    if (node === null)
+        return undefined;
+    if (node.type === "composite_literal")
+        return baseTypeName(node.childForFieldName("type"));
+    if (node.type === "unary_expression" || node.type === "expression_list") {
+        for (let i = 0; i < node.namedChildCount; i += 1) {
+            const found = findCompositeType(node.namedChild(i));
+            if (found !== undefined)
+                return found;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=parse.js.map