docsgov 0.1.0

package/dist/codeq/resolvers/go.test.js

@@ -0,0 +1,143 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ParseFailedError } from "../errors.js";
+import { loadGrammar } from "../treesitter.js";
+import { createGoResolver } from "./go.js";
+// These tests port the behaviour-encoding cases from internal/codeq/go_lang_test.go.
+//
+// WHY: The facet queries (symbol/member/param) and collectGoParamTypes are
+// hand-authored tree-sitter patterns + a parameter walk. A malformed query, a
+// wrong capture name, or a broken param walk would make the resolver silently
+// return false for every lookup — so the code-guard would report "symbol absent"
+// even when it exists, giving false positives on every future guard run. The
+// parse-failure path must THROW ParseFailedError (not return false) so callers
+// distinguish "could not check" from "genuinely missing".
+//
+// The Go test uses a DefaultResolver over an fs.FS; here the per-language
+// resolver is sync and takes the source string directly (the I/O split recorded
+// in resolver.ts). File-not-found is the dispatch layer's concern, NOT the
+// resolver's, so the ErrFileNotFound case from go_lang_test.go is intentionally
+// not ported here.
+// CodeRef requires non-optional Symbol/Member/Param strings; this fills the
+// empties so each test states only the facets it exercises.
+function ref(partial) {
+    return {
+        Symbol: "",
+        Member: "",
+        Param: "",
+        ...partial,
+    };
+}
+describe("go resolver", () => {
+    let resolver;
+    // The grammar loads in milliseconds; no env-gating needed.
+    beforeAll(async () => {
+        const go = await loadGrammar("go");
+        resolver = createGoResolver(go);
+    });
+    // Helper: resolve against an inline source sample. `path` only feeds the
+    // ParseFailedError message; it is not used for I/O.
+    const resolve = (source, r) => resolver.resolve(source, r.Path, r);
+    // --- Symbols: func / type / var / const (TestGoResolverSymbols) ---
+    describe("top-level symbols", () => {
+        const src = "package pkg\n" +
+            "func Bar(){}\n" +
+            "type Baz struct{}\n" +
+            "var Qux = 1\n" +
+            "const Quux = 2\n";
+        // WHY: if the resolver misses a declaration KIND (e.g. var or const), a ref
+        // to it is silently reported absent even though it exists. Lock all four.
+        it.each(["Bar", "Baz", "Qux", "Quux"])("finds top-level declaration %s", (sym) => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: sym }))).toBe(true);
+        });
+        it("returns false (not an error) for an absent symbol", () => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: "Absent" }))).toBe(false);
+        });
+    });
+    // --- Members and params (TestGoResolverFacets) ---
+    describe("members and params", () => {
+        const src = "package pkg\n" +
+            "type Baz struct { Field int }\n" +
+            "func (b Baz) Method(x int, y string) error { return nil }\n";
+        it("resolves a struct field as a member", () => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: "Baz", Member: "Field" }))).toBe(true);
+        });
+        it("resolves a value-receiver method as a member", () => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: "Baz", Member: "Method" }))).toBe(true);
+        });
+        it("returns false for an absent member", () => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: "Baz", Member: "NoSuch" }))).toBe(false);
+        });
+        it.each(["x", "y"])("resolves parameter %s of a method", (p) => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: "Method", Param: p }))).toBe(true);
+        });
+        it("returns false for an absent parameter", () => {
+            expect(resolve(src, ref({ Path: "pkg/foo.go", Symbol: "Method", Param: "z" }))).toBe(false);
+        });
+    });
+    // --- Pointer-receiver members do NOT resolve (preserve Go behaviour) ---
+    // WHY: the member query binds the receiver type via (type_identifier), which
+    // matches only a value receiver "(b Baz)". A pointer receiver "(b *Baz)"
+    // parses as (pointer_type ...) and is intentionally NOT matched. This is a
+    // load-bearing limitation recorded in the port memory; lock it so a future
+    // query "fix" that starts matching pointer receivers fails loudly.
+    it("does NOT resolve a pointer-receiver method as a member", () => {
+        const src = "package pkg\n" +
+            "type Baz struct{}\n" +
+            "func (b *Baz) PtrMethod() {}\n";
+        expect(resolve(src, ref({ Path: "pkg/p.go", Symbol: "Baz", Member: "PtrMethod" }))).toBe(false);
+    });
+    // --- Parse failure throws ParseFailedError (TestGoResolverFacets bad.go) ---
+    it("throws ParseFailedError on invalid Go source", () => {
+        const bad = "package pkg\nfunc {{{INVALID";
+        expect(() => resolve(bad, ref({ Path: "pkg/bad.go", Symbol: "X" }))).toThrow(ParseFailedError);
+    });
+    // --- Signature overload disambiguation (TestGoResolver_Signature) ---
+    describe("signature disambiguation", () => {
+        const src = "package pkg\n" +
+            "type Request struct{}\n" +
+            "type Ctl struct{}\n" +
+            'func (c Ctl) Get(names []string, id int, req Request) string { return "" }\n';
+        it("matches a member with the correct param-type signature", () => {
+            expect(resolve(src, ref({
+                Path: "pkg/c.go",
+                Symbol: "Ctl",
+                Member: "Get",
+                Signature: ["[]string", "int", "Request"],
+            }))).toBe(true);
+        });
+        it("does NOT match a member with a wrong signature", () => {
+            expect(resolve(src, ref({
+                Path: "pkg/c.go",
+                Symbol: "Ctl",
+                Member: "Get",
+                Signature: ["int"],
+            }))).toBe(false);
+        });
+    });
+    // --- Signature edge cases (TestGoResolver_SignatureEdgeCases) ---
+    // WHY: collectGoParamTypes must handle variadic_parameter_declaration nodes
+    // (xs ...string → []string) or the effective arity is wrong; grouped params
+    // (a, b int) must expand per name count; a zero-arg method must match the
+    // empty (zero-arg) signature.
+    describe("signature edge cases", () => {
+        const src = "package pkg\n" +
+            "type Ctl struct{}\n" +
+            'func (c Ctl) Var(a int, xs ...string) string { return "" }\n' +
+            'func (c Ctl) G(a, b int, s string) string { return "" }\n' +
+            'func (c Ctl) Zero() string { return "" }\n';
+        const resolveSig = (member, sig) => resolve(src, ref({ Path: "pkg/e.go", Symbol: "Ctl", Member: member, Signature: sig }));
+        it("variadic: (int, []string) matches; collapsed (int) does not", () => {
+            expect(resolveSig("Var", ["int", "[]string"])).toBe(true);
+            // Arity is 2; the collapsed form that drops the variadic must not match.
+            expect(resolveSig("Var", ["int"])).toBe(false);
+        });
+        it("grouped: (int, int, string) matches; collapsed (int, string) does not", () => {
+            expect(resolveSig("G", ["int", "int", "string"])).toBe(true);
+            // Arity is 3; treating (a, b int) as one type must not match.
+            expect(resolveSig("G", ["int", "string"])).toBe(false);
+        });
+        it("zero-arg: empty signature matches a no-param method", () => {
+            expect(resolveSig("Zero", [])).toBe(true);
+        });
+    });
+});

package/dist/codeq/resolvers/java.js

@@ -0,0 +1,349 @@
+// java.ts ports internal/codeq/java_lang.go: the per-language Resolver for Java
+// source. It is the largest grammar's resolver — it disambiguates method and
+// constructor overloads by parameter type (the Signature facet of a CodeRef).
+//
+// Faithful port of one *_lang.go Resolve body MINUS the cache.Read +
+// ErrFileNotFound prelude (the dispatch layer owns file I/O — see resolver.ts).
+// The dispatch precedence in resolve() mirrors the Go Resolve switch EXACTLY:
+//
+//   Member && Param  -> findMemberParam
+//   Member           -> findMember
+//   Signature && Param -> findConstructorParam   (bare class + sig + param)
+//   Signature        -> findConstructor          (bare class + sig)
+//   Param            -> findParam
+//   default          -> findSymbol
+//
+// Constructor dispatch: when Member is empty and Signature is non-nil, the ref
+// denotes a constructor overload (#Class(sig)) rather than the type itself.
+// #Class(sig)@params.name selects a parameter of that constructor overload.
+// #Class with no signature still resolves the type via findSymbol.
+import { ParseFailedError } from "../errors.js";
+import { signaturesMatch } from "../signature.js";
+import { collectCapture, collectOwned, refKind, suggestFromExtractors, } from "../suggest.js";
+import { Parser, compileQuery, nodeText, parseTree, runQuery, } from "../treesitter.js";
+import { CONSTRUCTOR_DECL, MEMBER, MEMBER_DECL, PARAM, SYMBOL, } from "./java_queries.js";
+/**
+ * createJavaResolver builds the Java Resolver from an already-loaded Java
+ * Language. It compiles and caches the grammar's queries eagerly (the analogue
+ * of Go's package-level mustJavaQuery vars / newJavaResolver). compileQuery
+ * throws on a bad query — surfacing a hard-coded-query programming error at
+ * construction time, exactly as Go's mustJavaQuery panics.
+ */
+export function createJavaResolver(language) {
+    const symbolQuery = compileQuery(language, SYMBOL);
+    const memberQuery = compileQuery(language, MEMBER);
+    const memberDeclQuery = compileQuery(language, MEMBER_DECL);
+    const paramQuery = compileQuery(language, PARAM);
+    const constructorDeclQuery = compileQuery(language, CONSTRUCTOR_DECL);
+    return new JavaResolver(language, symbolQuery, memberQuery, memberDeclQuery, paramQuery, constructorDeclQuery);
+}
+class JavaResolver {
+    language;
+    symbolQuery;
+    memberQuery;
+    memberDeclQuery;
+    paramQuery;
+    constructorDeclQuery;
+    constructor(language, symbolQuery, memberQuery, memberDeclQuery, paramQuery, constructorDeclQuery) {
+        this.language = language;
+        this.symbolQuery = symbolQuery;
+        this.memberQuery = memberQuery;
+        this.memberDeclQuery = memberDeclQuery;
+        this.paramQuery = paramQuery;
+        this.constructorDeclQuery = constructorDeclQuery;
+    }
+    /**
+     * resolve parses `source` and dispatches on ref facets exactly as Go's
+     * javaResolver.Resolve switch does. Throws ParseFailedError(path) when the
+     * parse tree has ERROR nodes (Go's ErrParseFailed). `path` is carried only to
+     * build that error — not used for I/O.
+     */
+    resolve(source, path, ref) {
+        // Per-call parser — cheap to create, must not be shared (mirrors Go's
+        // per-call sitter.NewParser()).
+        const parser = new Parser();
+        parser.setLanguage(this.language);
+        const root = parseTree(parser, source);
+        // Invalid Java produces ERROR nodes, not a parse() throw.
+        if (root.hasError) {
+            throw new ParseFailedError(path);
+        }
+        const hasSig = ref.Signature !== undefined;
+        if (ref.Member !== "" && ref.Param !== "") {
+            return this.findMemberParam(root, ref.Symbol, ref.Member, ref.Param, ref.Signature);
+        }
+        if (ref.Member !== "") {
+            return this.findMember(root, ref.Symbol, ref.Member, ref.Signature);
+        }
+        if (hasSig && ref.Param !== "") {
+            // bare class symbol + signature + param → a parameter of a constructor overload
+            return this.findConstructorParam(root, ref.Symbol, ref.Param, ref.Signature);
+        }
+        if (hasSig) {
+            // bare class symbol + signature → a constructor overload (not the type)
+            return this.findConstructor(root, ref.Symbol, ref.Signature);
+        }
+        if (ref.Param !== "") {
+            return this.findParam(root, ref.Symbol, ref.Param);
+        }
+        return this.findSymbol(root, ref.Symbol);
+    }
+    /**
+     * suggest lists same-kind candidate names for a not-found ref (best-effort).
+     * A parse error yields no candidates rather than throwing — suggestions never
+     * gate a violation. Members come from the flat MEMBER query (fields, methods,
+     * enum constants); params from the PARAM query keyed by method name (matching
+     * findParam, which ignores the owning class for a bare Param ref).
+     */
+    suggest(source, _path, ref) {
+        const parser = new Parser();
+        parser.setLanguage(this.language);
+        const root = parseTree(parser, source);
+        if (root.hasError) {
+            return { kind: refKind(ref), candidates: [] };
+        }
+        return suggestFromExtractors(root, ref, {
+            symbolNames: (r) => collectCapture(r, this.symbolQuery, "name"),
+            memberNames: (r, owner) => collectOwned(r, this.memberQuery, owner, "owner", "name"),
+            paramNames: (r, fn) => collectOwned(r, this.paramQuery, fn, "fn", "param"),
+        });
+    }
+    /**
+     * findSymbol searches for a type declaration (class/interface/enum/record)
+     * with the given name. The query is unanchored, so nested types resolve too.
+     */
+    findSymbol(root, name) {
+        for (const m of runQuery(root, this.symbolQuery)) {
+            const n = m.captures["name"];
+            if (n !== undefined && nodeText(n) === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * findMember searches for a field, method, or enum constant named `member` on
+     * the type named `symbol`. When `sig` is given, only method overloads whose
+     * parameter types satisfy signaturesMatch are considered; fields/enum
+     * constants are matched by name only (and only via the name-only path, since
+     * they have no signature).
+     */
+    findMember(root, symbol, member, sig) {
+        if (sig === undefined) {
+            // Name-only: the flat member query (fields, methods, enum constants).
+            for (const m of runQuery(root, this.memberQuery)) {
+                const owner = textOf(m.captures["owner"]);
+                const name = textOf(m.captures["name"]);
+                if (owner === symbol && name === member) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        // Signature-filtered: iterate method declarations and check param types.
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (owner === symbol &&
+                mname === member &&
+                mdecl !== undefined &&
+                signaturesMatch(sig, collectParamTypes(mdecl))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * findMemberParam searches for a parameter named `paramName` on a method named
+     * `member` of the type named `symbol`. When `sig` is given, only the overload
+     * whose parameter types satisfy signaturesMatch is considered.
+     */
+    findMemberParam(root, symbol, member, paramName, sig) {
+        if (sig === undefined) {
+            // Name-only: any overload with the matching param name.
+            for (const m of runQuery(root, this.paramQuery)) {
+                const owner = textOf(m.captures["owner"]);
+                const fn = textOf(m.captures["fn"]);
+                const param = textOf(m.captures["param"]);
+                if (owner === symbol && fn === member && param === paramName) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        // Signature-filtered: find the specific overload, then look for the param.
+        for (const m of runQuery(root, this.memberDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const mname = textOf(m.captures["mname"]);
+            const mdecl = m.captures["mdecl"];
+            if (owner !== symbol || mname !== member || mdecl === undefined) {
+                continue;
+            }
+            if (!signaturesMatch(sig, collectParamTypes(mdecl))) {
+                continue;
+            }
+            // Correct overload — now check for the param name.
+            if (paramExistsInMethod(mdecl, paramName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * findConstructor searches for a constructor of the type named `symbol` whose
+     * parameter types satisfy signaturesMatch(sig, declared types). Reuses
+     * collectParamTypes (declaration-kind-agnostic) on the constructor_declaration
+     * node captured by the constructor-decl query.
+     */
+    findConstructor(root, symbol, sig) {
+        for (const m of runQuery(root, this.constructorDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const cdecl = m.captures["cdecl"];
+            if (owner === symbol &&
+                cdecl !== undefined &&
+                signaturesMatch(sig, collectParamTypes(cdecl))) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * findConstructorParam searches for a parameter named `paramName` in a
+     * constructor of the type named `symbol` whose parameter types satisfy
+     * signaturesMatch(sig, declared types).
+     */
+    findConstructorParam(root, symbol, paramName, sig) {
+        for (const m of runQuery(root, this.constructorDeclQuery)) {
+            const owner = textOf(m.captures["owner"]);
+            const cdecl = m.captures["cdecl"];
+            if (owner !== symbol || cdecl === undefined) {
+                continue;
+            }
+            if (!signaturesMatch(sig, collectParamTypes(cdecl))) {
+                continue;
+            }
+            if (paramExistsInMethod(cdecl, paramName)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * findParam searches for a parameter named `paramName` on any method named
+     * `symbol` (the rare case where only Param is set without Member). Signature
+     * is ignored here, mirroring Go's findParam (which takes but discards sig).
+     */
+    findParam(root, symbol, paramName) {
+        for (const m of runQuery(root, this.paramQuery)) {
+            const fn = textOf(m.captures["fn"]);
+            const param = textOf(m.captures["param"]);
+            if (fn === symbol && param === paramName) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+/** textOf returns nodeText(n) or "" when the capture is absent (mirrors Go's
+ * zero-value string for a missing capture). */
+function textOf(n) {
+    return n === undefined ? "" : nodeText(n);
+}
+/**
+ * spreadParamType returns the type node text for a spread_parameter (varargs)
+ * node. The grammar is:
+ *   spread_parameter: [modifiers] _type "..." variable_declarator
+ * — the type sits immediately before the anonymous "..." token. Using child(0)
+ * is fragile because an optional leading modifiers node shifts the index;
+ * instead we scan for the "..." sibling and take its predecessor.
+ */
+function spreadParamType(sp) {
+    for (let i = 1; i < sp.childCount; i++) {
+        if (sp.child(i)?.type === "...") {
+            const prev = sp.child(i - 1);
+            return prev === null ? "" : nodeText(prev);
+        }
+    }
+    return "";
+}
+/**
+ * collectParamTypes walks a method or constructor declaration node's
+ * formal_parameters and returns the declared parameter types in document order.
+ * formal_parameter nodes use the named "type" field (safe even with modifiers);
+ * spread_parameter (varargs) nodes are handled by spreadParamType — the "[]"
+ * suffix is appended so normalizeType can unify them with array declarations
+ * (T...≡T[]).
+ */
+function collectParamTypes(methodDecl) {
+    const formalParams = formalParametersOf(methodDecl);
+    if (formalParams === null) {
+        return [];
+    }
+    const types = [];
+    for (let i = 0; i < formalParams.childCount; i++) {
+        const c = formalParams.child(i);
+        if (c === null) {
+            continue;
+        }
+        if (c.type === "formal_parameter") {
+            const tn = c.childForFieldName("type");
+            if (tn !== null) {
+                types.push(nodeText(tn));
+            }
+        }
+        else if (c.type === "spread_parameter") {
+            const t = spreadParamType(c);
+            if (t !== "") {
+                types.push(t + "[]");
+            }
+        }
+    }
+    return types;
+}
+/**
+ * paramExistsInMethod reports whether a formal_parameter named `paramName`
+ * exists in a method or constructor declaration node's formal_parameters list.
+ */
+function paramExistsInMethod(methodDecl, paramName) {
+    const formalParams = formalParametersOf(methodDecl);
+    if (formalParams === null) {
+        return false;
+    }
+    for (let i = 0; i < formalParams.childCount; i++) {
+        const c = formalParams.child(i);
+        if (c === null) {
+            continue;
+        }
+        if (c.type === "formal_parameter") {
+            const nn = c.childForFieldName("name");
+            if (nn !== null && nodeText(nn) === paramName) {
+                return true;
+            }
+        }
+        else if (c.type === "spread_parameter") {
+            // spread_parameter: last child is variable_declarator containing name.
+            if (c.childCount > 0) {
+                const vd = c.child(c.childCount - 1);
+                if (vd !== null && vd.type === "variable_declarator" && vd.childCount > 0) {
+                    const nameNode = vd.child(0);
+                    if (nameNode !== null && nodeText(nameNode) === paramName) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+/** formalParametersOf returns the first formal_parameters child of a method or
+ * constructor declaration, or null when absent (mirrors Go's scan + nil). */
+function formalParametersOf(decl) {
+    for (let i = 0; i < decl.childCount; i++) {
+        const c = decl.child(i);
+        if (c !== null && c.type === "formal_parameters") {
+            return c;
+        }
+    }
+    return null;
+}

package/dist/codeq/resolvers/java.test.js

@@ -0,0 +1,138 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ParseFailedError } from "../errors.js";
+import { loadGrammar } from "../treesitter.js";
+import { createJavaResolver } from "./java.js";
+// WHY: the Java resolver is the largest grammar's resolver and the only one that
+// disambiguates overloads by parameter type. These tests port the
+// behavior-encoding cases from internal/codeq/java_lang_test.go so the TS port
+// resolves identically: symbol/member/param existence, the ParseFailedError
+// trigger, overload disambiguation by Signature (including varargs-with-modifier
+// T...≡T[]), constructor overloads (#Class(sig) vs the bare type), and nested
+// enum constants. The grammar loads in ms, so no env-gating is needed.
+// Mirrors the Go test fixture (internal/codeq/java_lang_test.go `javaSrc`): a
+// class C with overloaded constructors and an overloaded `get` method (including
+// a varargs overload with a `final` modifier), plus a nested enum.
+const JAVA_SRC = `package com.example;
+public class C {
+    public C() {}
+    public C(Integer id) {}
+    public C(String[] names, AbRequest req) {}
+    public String get() { return ""; }
+    public String get(Integer id) { return ""; }
+    public String get(String[] names, Integer id, AbRequest req) { return ""; }
+    public String get(final String... tags) { return ""; }
+    public enum Status { PENDING, COMPLETED, CANCELLED }
+}
+`;
+let resolver;
+const PATH = "C.java";
+// A {{code:…}} CodeRef defaults: Signature undefined = name-only (no overload
+// filter); Member/Param "" = facet absent. This builder keeps each case to the
+// facets it exercises, matching the Go `code.CodeRef{…}` struct literals.
+function ref(partial) {
+    return {
+        Path: PATH,
+        Symbol: "",
+        Member: "",
+        Param: "",
+        ...partial,
+    };
+}
+beforeAll(async () => {
+    const language = await loadGrammar("java");
+    resolver = createJavaResolver(language);
+});
+describe("java resolver — symbol/member/param", () => {
+    // Each case states what facet combination it pins and why it must (not) resolve.
+    it.each([
+        ["class type resolves", { Symbol: "C" }, true],
+        ["method member resolves", { Symbol: "C", Member: "get" }, true],
+        ["absent member does not resolve", { Symbol: "C", Member: "nope" }, false],
+        [
+            "named param of a method resolves",
+            { Symbol: "C", Member: "get", Param: "id" },
+            true,
+        ],
+        [
+            "absent param does not resolve",
+            { Symbol: "C", Member: "get", Param: "zzz" },
+            false,
+        ],
+    ])("%s", (_name, partial, want) => {
+        expect(resolver.resolve(JAVA_SRC, PATH, ref(partial))).toBe(want);
+    });
+});
+describe("java resolver — parse failure", () => {
+    it("throws ParseFailedError on source with ERROR nodes", () => {
+        // WHY: invalid Java yields ERROR nodes (not a parse() throw); the resolver
+        // maps rootNode.hasError → ParseFailedError carrying the path. This is the
+        // ErrParseFailed contract the dispatch layer propagates.
+        expect(() => resolver.resolve("class {{{", "bad.java", ref({ Symbol: "X" }))).toThrow(ParseFailedError);
+    });
+});
+describe("java resolver — method overload disambiguation by signature", () => {
+    // Member="get" + Signature selects a specific overload by parameter types.
+    // Signature [] means the zero-arg overload "()"; undefined would be name-only.
+    const mref = (sig, param) => ref({ Symbol: "C", Member: "get", Signature: sig, Param: param });
+    it.each([
+        ["3-arg overload matches", ["String[]", "Integer", "AbRequest"], "", true],
+        ["zero-arg overload matches", [], "", true],
+        ["no overload with these types", ["String[]", "String[]"], "", false],
+        [
+            "param of the specific overload resolves",
+            ["String[]", "Integer", "AbRequest"],
+            "req",
+            true,
+        ],
+        ["param absent in the selected overload", ["Integer"], "req", false],
+        // WHY: a spread_parameter with a leading modifier ("final String... tags")
+        // puts modifiers at child(0); the type must be located as the child before
+        // the "..." token, then normalized T...≡T[] to match "String[]".
+        ["varargs overload matches String[]", ["String[]"], "", true],
+        ["varargs param tags resolves", ["String[]"], "tags", true],
+    ])("%s", (_name, sig, param, want) => {
+        expect(resolver.resolve(JAVA_SRC, PATH, mref(sig, param))).toBe(want);
+    });
+});
+describe("java resolver — constructor overloads", () => {
+    // Bare class Symbol + Signature (no Member) denotes a constructor overload
+    // #C(sig), distinct from the type itself.
+    const cref = (sig, param) => ref({ Symbol: "C", Signature: sig, Param: param });
+    it.each([
+        ["no-arg constructor", [], "", true],
+        ["1-arg constructor", ["Integer"], "", true],
+        ["2-arg constructor", ["String[]", "AbRequest"], "", true],
+        ["no constructor with these types", ["String[]"], "", false],
+        [
+            "param of a constructor overload resolves",
+            ["String[]", "AbRequest"],
+            "req",
+            true,
+        ],
+        ["param absent in the constructor", ["Integer"], "zzz", false],
+    ])("%s", (_name, sig, param, want) => {
+        expect(resolver.resolve(JAVA_SRC, PATH, cref(sig, param))).toBe(want);
+    });
+    it("bare class name with no signature still resolves the TYPE", () => {
+        // Regression from Go: #C (no signature) must hit findSymbol, not the
+        // constructor path — the type resolves even when no constructor matches.
+        expect(resolver.resolve(JAVA_SRC, PATH, ref({ Symbol: "C" }))).toBe(true);
+    });
+});
+describe("java resolver — nested enum and its constants", () => {
+    it.each([
+        ["nested enum type resolves", { Symbol: "Status" }, true],
+        [
+            "enum constant resolves",
+            { Symbol: "Status", Member: "COMPLETED" },
+            true,
+        ],
+        [
+            "absent enum constant does not resolve",
+            { Symbol: "Status", Member: "SHIPPED" },
+            false,
+        ],
+    ])("%s", (_name, partial, want) => {
+        expect(resolver.resolve(JAVA_SRC, PATH, ref(partial))).toBe(want);
+    });
+});