ucn 5.5.1 → 5.5.3

package/languages/java.js

@@ -18,6 +18,7 @@ const {
     visitNameNodes,
     sameNode,
     parseErrorRegions,
+    hasParameterizedQualifier,
 } = require('./utils');
 const { PARSE_OPTIONS, safeParse } = require('./index');
 
@@ -25,6 +26,50 @@ function parseTree(parser, code) {
     return safeParse(parser, code, undefined, PARSE_OPTIONS);
 }
 
+const ANNOTATION_BEFORE_DOTS = /@\s*[A-Za-z_$][\w$.]*(?:\s*\((?:[^()]|\([^()]*\))*\))?\s*\.\.\./;
+// An annotation (with optional arguments) written right before `...`.
+const VARARGS_ANNOTATION = /@\s*[A-Za-z_$][\w$]*(?:\s*\.\s*[A-Za-z_$][\w$]*)*(?:\s*\((?:[^()]|\([^()]*\))*\))?\s*(?=\.\.\.)/g;
+
+/**
+ * Recovery of a grammar gap (fix #428): tree-sitter-java does not parse a
+ * type annotation between a variable arity parameter's type and its `...`
+ * (`Object @Nullable ... args`, JLS 8.4.1), and drops the parameter. Inside
+ * each parse error of a parameter list, such annotations are blanked (same
+ * offsets) and the source reparsed; the recovered tree is kept only when it
+ * has fewer errors. Annotations carry no call or type facts the index reads
+ * there.
+ */
+function recoverTypeAnnotatedVarargs(tree, source, reparse) {
+    // Only a source spelling an annotation right before `...` can hold the
+    // gap: one text test before any tree walk.
+    if (!source.includes('...') || !ANNOTATION_BEFORE_DOTS.test(source)) return null;
+    const ranges = [];
+    for (const error of tree.rootNode.descendantsOfType('ERROR')) {
+        let inParameters = false;
+        for (let node = error.parent; node && !inParameters; node = node.parent) {
+            if (node.type === 'formal_parameters') inParameters = true;
+            if (node.type === 'class_body' || node.type === 'program') break;
+        }
+        if (!inParameters) continue;
+        const text = source.slice(error.startIndex, error.endIndex);
+        for (const match of text.matchAll(VARARGS_ANNOTATION)) {
+            ranges.push([error.startIndex + match.index, error.startIndex + match.index + match[0].length]);
+        }
+    }
+    if (ranges.length === 0) return null;
+    let blanked = '';
+    let at = 0;
+    for (const [start, end] of ranges.sort((a, b) => a[0] - b[0])) {
+        if (start < at) continue;
+        blanked += source.slice(at, start) + source.slice(start, end).replace(/[^\n]/g, ' ');
+        at = end;
+    }
+    blanked += source.slice(at);
+    const recovered = reparse(blanked);
+    const errors = root => root.descendantsOfType('ERROR').length + (root.hasError ? 1 : 0);
+    return recovered && errors(recovered.rootNode) < errors(tree.rootNode) ? recovered : null;
+}
+
 /**
  * Extract Java parameters
  */
@@ -35,7 +80,8 @@ function extractJavaParams(paramsNode) {
     // the shared utils.extractParams already had it).
     if (!paramsNode) return '...';
     const text = nodeTextWithoutComments(paramsNode);
-    let params = text.replace(/^\(|\)$/g, '').trim();
+    // A recovered variable arity annotation leaves blanks before `...`.
+    let params = text.replace(/^\(|\)$/g, '').trim().replace(/ {2,}(?=\.\.\.)/g, ' ');
     return params;
 }
 
@@ -240,7 +286,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
         const paramsNode = node.childForFieldName('parameters');
 
         if (nameNode) {
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
             const annotationsWithArgs = extractAnnotationsWithArgs(node);
@@ -256,6 +302,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 paramsStructured: parseStructuredParams(paramsNode, 'java'),
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 modifiers,
                 ...(returnType && { returnType }),
@@ -285,7 +332,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
         const paramsNode = node.childForFieldName('parameters');
 
         if (nameNode) {
-            const { startLine, endLine, indent } = nodeToLocation(node, lines);
+            const { startLine, endLine, indent, sourceSpan } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
             const annotationsWithArgs = extractAnnotationsWithArgs(node);
@@ -298,6 +345,7 @@ function _processFunction(node, functions, processedRanges, lines, code) {
                 paramsStructured: parseStructuredParams(paramsNode, 'java'),
                 startLine,
                 endLine,
+                sourceSpan,
                 indent,
                 modifiers,
                 isConstructor: true,
@@ -372,6 +420,65 @@ const JAVA_TYPE_DECLARATIONS = new Set([
     'class_declaration', 'interface_declaration', 'enum_declaration', 'record_declaration',
     'annotation_type_declaration',
 ]);
+// Type declarations that declare constructors.
+const JAVA_CONSTRUCTOR_OWNER_TYPES = new Set(['class_declaration', 'enum_declaration', 'record_declaration']);
+
+// A parameter type's erasure, read from its AST: type arguments and
+// annotations dropped, array dimensions kept (`T...` is `T[]`).
+function javaErasedType(typeNode) {
+    if (!typeNode) return null;
+    switch (typeNode.type) {
+        case 'generic_type':
+            return javaErasedType(typeNode.namedChildren.find(child =>
+                child.type === 'type_identifier' || child.type === 'scoped_type_identifier'));
+        case 'annotated_type':
+            return javaErasedType(typeNode.namedChildren.find(child =>
+                child.type !== 'marker_annotation' && child.type !== 'annotation'));
+        case 'array_type': {
+            const element = javaErasedType(typeNode.childForFieldName('element'));
+            const dimensions = typeNode.childForFieldName('dimensions');
+            const count = dimensions ? dimensions.children.filter(child => child.type === '[').length : 1;
+            return element && `${element}${'[]'.repeat(count)}`;
+        }
+        case 'scoped_type_identifier':
+            return typeNode.namedChildren.map(javaErasedType).join('.');
+        default:
+            return typeNode.text;
+    }
+}
+
+function javaErasedParameters(paramsNode) {
+    const erased = [];
+    for (const param of paramsNode?.namedChildren || []) {
+        if (param.type !== 'formal_parameter' && param.type !== 'spread_parameter') continue;
+        const typeNode = param.childForFieldName('type') || param.namedChildren.find(child =>
+            child.type !== 'modifiers' && child.type !== 'variable_declarator' && child.type !== 'identifier');
+        const type = javaErasedType(typeNode);
+        if (!type) return null;
+        // `int b[]` writes its dimensions after the name.
+        const dimensions = param.childForFieldName('dimensions');
+        const trailing = dimensions ? '[]'.repeat(dimensions.children.filter(child => child.type === '[').length) : '';
+        erased.push(`${type}${trailing}${param.type === 'spread_parameter' ? '[]' : ''}`);
+    }
+    return erased;
+}
+
+// Does a record's body declare its canonical constructor (JLS 8.10.4)?
+// A compact constructor is canonical; so is a constructor whose parameter
+// types are the component types. An undecidable spelling counts as not
+// canonical: the implicit candidate then shares its signature, which
+// leaves the choice between them open rather than closed.
+function recordDeclaresCanonical(recordNode, paramsNode) {
+    const components = javaErasedParameters(paramsNode);
+    for (const child of recordNode.childForFieldName('body')?.namedChildren || []) {
+        if (child.type === 'compact_constructor_declaration') return true;
+        if (child.type !== 'constructor_declaration' || !components) continue;
+        const declared = javaErasedParameters(child.childForFieldName('parameters'));
+        if (declared && declared.length === components.length &&
+            declared.every((type, at) => type === components[at])) return true;
+    }
+    return false;
+}
 
 function _processClass(node, classes, processedRanges, lines, code) {
     // Only type declarations are processed below: every other node returns
@@ -386,7 +493,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const members = extractClassMembers(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
@@ -405,6 +512,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 // The name's own line when annotations precede it (fix #389).
                 ...(nameNode.startPosition.row + 1 !== startLine && { nameLine: nameNode.startPosition.row + 1 }),
                 type: 'class',
@@ -435,7 +543,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
             const annotationsWithArgs = extractAnnotationsWithArgs(node);
@@ -447,6 +555,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 // The name's own line when annotations precede it (fix #389).
                 ...(nameNode.startPosition.row + 1 !== startLine && { nameLine: nameNode.startPosition.row + 1 }),
                 type: 'interface',
@@ -473,7 +582,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
             const annotationsWithArgs = extractAnnotationsWithArgs(node);
@@ -486,6 +595,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 // The name's own line when annotations precede it (fix #389).
                 ...(nameNode.startPosition.row + 1 !== startLine && { nameLine: nameNode.startPosition.row + 1 }),
                 type: 'enum',
@@ -510,7 +620,7 @@ function _processClass(node, classes, processedRanges, lines, code) {
 
         const nameNode = node.childForFieldName('name');
         if (nameNode) {
-            const { startLine, endLine } = nodeToLocation(node, lines);
+            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
             const modifiers = extractModifiers(node);
             const annotations = extractAnnotations(node);
             const annotationsWithArgs = extractAnnotationsWithArgs(node);
@@ -546,11 +656,18 @@ function _processClass(node, classes, processedRanges, lines, code) {
                 name: nameNode.text,
                 startLine,
                 endLine,
+                sourceSpan,
                 // The name's own line when annotations precede it (fix #389).
                 ...(nameNode.startPosition.row + 1 !== startLine && { nameLine: nameNode.startPosition.row + 1 }),
                 type: 'record',
                 members,
                 modifiers,
+                // The implicit canonical constructor: a constructor the
+                // header declares with no body declaration, like a C#
+                // primary constructor (fix #419).
+                ...(paramsNode && !recordDeclaresCanonical(node, paramsNode) && {
+                    primaryParams: parseStructuredParams(paramsNode, 'java'),
+                }),
                 ...localScope,
                 ...(enclosingTypeName(node) && { enclosingType: enclosingTypeName(node) }),
                 ...(docstring && { docstring }),
@@ -672,12 +789,13 @@ function extractEnumConstants(enumNode, codeOrLines) {
         if (child.type === 'enum_constant') {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const argsNode = child.childForFieldName('arguments');
                 constants.push({
                     name: nameNode.text,
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'constant',
                     // JLS: enum constants are implicitly public static final
                     // (fix #251 — api omitted them for lack of a modifier).
@@ -699,7 +817,7 @@ function extractEnumConstants(enumNode, codeOrLines) {
                         const nameNode = member.childForFieldName('name');
                         const paramsNode = member.childForFieldName('parameters');
                         if (nameNode) {
-                            const { startLine, endLine } = nodeToLocation(member, code);
+                            const { startLine, endLine, sourceSpan } = nodeToLocation(member, code);
                             const modifiers = extractModifiers(member);
                             const returnType = extractReturnType(member);
                             // The name's own line and annotations, as for class
@@ -714,6 +832,7 @@ function extractEnumConstants(enumNode, codeOrLines) {
                                 paramsStructured: parseStructuredParams(paramsNode, 'java'),
                                 startLine,
                                 endLine,
+                                sourceSpan,
                                 memberType: modifiers.includes('static') ? 'static' : 'method',
                                 modifiers,
                                 isMethod: true,
@@ -723,11 +842,14 @@ function extractEnumConstants(enumNode, codeOrLines) {
                                 ...(memberGenerics && { generics: memberGenerics })
                             });
                         }
+                    } else if (member.type === 'field_declaration') {
+                        // Fields after the constants (fix #430).
+                        constants.push(...javaFieldMembers(member, code));
                     } else if (member.type === 'constructor_declaration') {
                         const nameNode = member.childForFieldName('name');
                         const paramsNode = member.childForFieldName('parameters');
                         if (nameNode) {
-                            const { startLine, endLine } = nodeToLocation(member, code);
+                            const { startLine, endLine, sourceSpan } = nodeToLocation(member, code);
                             const modifiers = extractModifiers(member);
                             constants.push({
                                 name: nameNode.text,
@@ -738,7 +860,9 @@ function extractEnumConstants(enumNode, codeOrLines) {
                                 paramsStructured: parseStructuredParams(paramsNode, 'java'),
                                 startLine,
                                 endLine,
+                                sourceSpan,
                                 memberType: 'constructor',
+                                isConstructor: true,
                                 modifiers,
                                 isMethod: true
                             });
@@ -752,6 +876,48 @@ function extractEnumConstants(enumNode, codeOrLines) {
     return constants;
 }
 
+/**
+ * The field members a field or constant declaration declares. Interface and
+ * annotation type constants (`constant_declaration`, implicitly public static
+ * final; fix #389) are fields like class fields.
+ */
+function javaFieldMembers(child, code) {
+    const members = [];
+    const typeNode = child.childForFieldName('type');
+    const fieldTypeText = typeNode ? typeNode.text : null;
+    // Visibility travels with the member (fix #251 — public
+    // instance fields were invisible to api/fileExports because
+    // the member had no modifiers for the #240 discipline to read;
+    // the #241 Rust-field twin).
+    const fieldModifiers = extractModifiers(child);
+    if (child.type === 'constant_declaration') {
+        for (const implicit of ['public', 'static', 'final']) {
+            if (!fieldModifiers.includes(implicit)) fieldModifiers.push(implicit);
+        }
+    }
+    for (let j = 0; j < child.namedChildCount; j++) {
+        const decl = child.namedChild(j);
+        if (decl.type !== 'variable_declarator') continue;
+        const nameNode = decl.childForFieldName('name');
+        if (!nameNode || !fieldTypeText) continue;
+        const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
+        // fix #390: an annotation on its own line starts the
+        // declaration; the name's line is where edits go.
+        const nameLine = nameNode.startPosition.row + 1;
+        members.push({
+            name: nameNode.text,
+            startLine,
+            endLine,
+            sourceSpan,
+            ...(nameLine !== startLine && { nameLine }),
+            memberType: 'field',
+            ...(fieldModifiers.length > 0 && { modifiers: [...fieldModifiers] }),
+            fieldType: fieldTypeText
+        });
+    }
+    return members;
+}
+
 /**
  * Extract class members (methods, constructors)
  */
@@ -774,7 +940,7 @@ function extractClassMembers(classNode, codeOrLines) {
             const paramsNode = child.childForFieldName('parameters');
 
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 const modifiers = extractModifiers(child);
                 const annotationsWithArgs = extractAnnotationsWithArgs(child);
                 // Interface methods are implicitly public and abstract in Java
@@ -802,6 +968,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     paramsStructured: parseStructuredParams(paramsNode, 'java'),
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType,
                     modifiers,
                     isMethod: true,  // Mark as method for context() lookups
@@ -822,7 +989,7 @@ function extractClassMembers(classNode, codeOrLines) {
         if (child.type === 'annotation_type_element_declaration') {
             const nameNode = child.childForFieldName('name');
             if (nameNode) {
-                const { startLine, endLine } = nodeToLocation(child, code);
+                const { startLine, endLine, sourceSpan } = nodeToLocation(child, code);
                 // Elements take no keyword modifiers besides public/abstract;
                 // `default` here introduces the default value.
                 const modifiers = extractModifiers(child).filter(modifier =>
@@ -838,6 +1005,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     paramsStructured: [],
                     startLine,
                     endLine,
+                    sourceSpan,
                     memberType: 'abstract',
                     modifiers,
                     isMethod: true,
@@ -848,53 +1016,36 @@ function extractClassMembers(classNode, codeOrLines) {
             }
         }
 
-        // Constructor declarations: intentionally NOT emitted as separate class
-        // members. The class itself is the symbol; `new Foo(...)` calls resolve
-        // to the class via `isConstructor: true` on the call. Emitting the
-        // constructor as a member would create duplicate `find Foo` results
-        // (one for class, one for constructor), forcing users to disambiguate.
-        // Constructor signature info (params, line) remains accessible by reading
-        // the class body when needed (e.g. via verify's AST walk).
+        if (child.type === 'constructor_declaration' || child.type === 'compact_constructor_declaration') {
+            const nameNode = child.childForFieldName('name');
+            const paramsNode = child.childForFieldName('parameters') ||
+                (child.type === 'compact_constructor_declaration' && classNode.childForFieldName('parameters'));
+            if (nameNode) {
+                const { startLine, endLine, indent, sourceSpan } = nodeToLocation(child, code);
+                const nameLine = nameNode.startPosition.row + 1;
+                const annotationsWithArgs = extractAnnotationsWithArgs(child);
+                const generics = extractGenerics(child);
+                members.push({
+                    name: nameNode.text,
+                    params: extractJavaParams(paramsNode),
+                    paramsStructured: parseStructuredParams(paramsNode, 'java'),
+                    startLine, endLine, sourceSpan, indent,
+                    memberType: 'constructor',
+                    isMethod: true,
+                    isConstructor: true,
+                    modifiers: extractModifiers(child),
+                    ...(nameLine !== startLine && { nameLine }),
+                    ...(annotationsWithArgs.length > 0 && { annotationsWithArgs }),
+                    ...(generics && { generics }),
+                    docstring: extractJavaDocstring(code, startLine),
+                });
+            }
+        }
 
         // Field declarations: declared types drive receiver disambiguation
         // (fix #202) — Rust/Go already emit field members with fieldType.
-        // Interface and annotation type constants (`constant_declaration`,
-        // implicitly public static final; fix #389) are fields like class
-        // fields.
         if (child.type === 'field_declaration' || child.type === 'constant_declaration') {
-            const typeNode = child.childForFieldName('type');
-            const fieldTypeText = typeNode ? typeNode.text : null;
-            // Visibility travels with the member (fix #251 — public
-            // instance fields were invisible to api/fileExports because
-            // the member had no modifiers for the #240 discipline to read;
-            // the #241 Rust-field twin).
-            const fieldModifiers = extractModifiers(child);
-            if (child.type === 'constant_declaration') {
-                for (const implicit of ['public', 'static', 'final']) {
-                    if (!fieldModifiers.includes(implicit)) fieldModifiers.push(implicit);
-                }
-            }
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const decl = child.namedChild(j);
-                if (decl.type === 'variable_declarator') {
-                    const nameNode = decl.childForFieldName('name');
-                    if (nameNode && fieldTypeText) {
-                        const { startLine, endLine } = nodeToLocation(child, code);
-                        // fix #390: an annotation on its own line starts the
-                        // declaration; the name's line is where edits go.
-                        const nameLine = nameNode.startPosition.row + 1;
-                        members.push({
-                            name: nameNode.text,
-                            startLine,
-                            endLine,
-                            ...(nameLine !== startLine && { nameLine }),
-                            memberType: 'field',
-                            ...(fieldModifiers.length > 0 && { modifiers: fieldModifiers }),
-                            fieldType: fieldTypeText
-                        });
-                    }
-                }
-            }
+            members.push(...javaFieldMembers(child, code));
         }
     }
 
@@ -920,8 +1071,8 @@ function _processState(node, objects, lines, code) {
                     if (nameNode && valueNode) {
                         const name = nameNode.text;
                         if (_statePattern.test(name)) {
-                            const { startLine, endLine } = nodeToLocation(node, lines);
-                            objects.push({ name, startLine, endLine, modifiers });
+                            const { startLine, endLine, sourceSpan } = nodeToLocation(node, lines);
+                            objects.push({ name, startLine, endLine, sourceSpan, modifiers });
                         }
                     }
                 }
@@ -993,6 +1144,7 @@ function parse(code, parser) {
         classes,
         stateObjects,
         ...(tree.rootNode.hasError && { parseRecovery: true, parseErrorRegions: parseErrorRegions(tree.rootNode) }),
+        typeParameterNames: require('./utils').declaredTypeParameterNames(tree),
         imports: [],
         exports: []
     };
@@ -1099,7 +1251,7 @@ function findCallsInCode(code, parser) {
 
     // Helper to check if a node creates a function scope
     const isFunctionNode = (node) => {
-        return ['method_declaration', 'constructor_declaration', 'lambda_expression'].includes(node.type);
+        return ['method_declaration', 'constructor_declaration', 'compact_constructor_declaration', 'lambda_expression'].includes(node.type);
     };
     const JAVA_TYPE_DECLARATIONS = new Set([
         'class_declaration', 'interface_declaration',
@@ -1185,6 +1337,52 @@ function findCallsInCode(code, parser) {
     };
     const extractReceiverTypeQualifier = (typeNode) =>
         extractTypeQualifier(typeNode) || extractTypePackage(typeNode);
+    // Pattern variables (fix #425, the Go type-switch rule): `x instanceof
+    // Sq s`, `case Sq s ->` and record components `case Pt(Sq a, ..)` bind a
+    // local of the written type wherever its scope reaches (JLS 6.3.1,
+    // decided by patternBindingReach). Collected once per file by name.
+    let patternBindings = null;
+    // Patterns occur only after `instanceof` and in `case` labels.
+    const mayHavePatterns = /\binstanceof\b|\bcase\b/.test(code);
+    const patternTypeAt = (refNode) => {
+        if (!mayHavePatterns) return null;
+        if (!patternBindings) {
+            patternBindings = new Map();
+            for (const n of tree.rootNode.descendantsOfType(['type_pattern', 'instanceof_expression',
+                'record_pattern_component'])) {
+                let nameNode;
+                let typeNode;
+                if (n.type === 'instanceof_expression') {
+                    nameNode = n.childForFieldName('name');
+                    typeNode = n.childForFieldName('right');
+                } else {
+                    const kids = n.namedChildren.filter(kid => !kid.type.includes('comment'));
+                    nameNode = kids.length === 2 ? kids[1] : null;
+                    typeNode = kids.length === 2 ? kids[0] : null;
+                }
+                if (nameNode?.type !== 'identifier' || !typeNode || typeNode.text === 'var') continue;
+                if (!patternBindings.has(nameNode.text)) patternBindings.set(nameNode.text, []);
+                patternBindings.get(nameNode.text).push({ nameNode, typeNode });
+            }
+        }
+        const list = refNode?.type === 'identifier' ? patternBindings.get(refNode.text) : null;
+        if (!list) return null;
+        for (let i = list.length - 1; i >= 0; i--) {
+            const { nameNode, typeNode } = list[i];
+            if (patternBindingReach(nameNode, refNode) !== 'in') continue;
+            const type = extractTypeName(typeNode);
+            if (!type) return null;
+            return {
+                type,
+                qualifier: extractReceiverTypeQualifier(typeNode) || undefined,
+                evidence: {
+                    receiverTypeSource: 'annotation',
+                    receiverTypeEvidence: { ...typeOrigin('annotation', typeNode), name: refNode.text, type },
+                },
+            };
+        }
+        return null;
+    };
     const qualifyTypeName = (text) => {
         const raw = String(text || '').trim()
             .replace(/^\?\s+extends\s+/, '')
@@ -1193,7 +1391,9 @@ function findCallsInCode(code, parser) {
         if (!base) return null;
         if (base.includes('.')) return base;
         if (importedTypeNames.has(base)) return importedTypeNames.get(base);
-        if (['Class', 'Enum', 'Object', 'String', 'Throwable'].includes(base)) {
+        // String and Class can name project types. Preserve those spellings
+        // for query-time lookup in the file and lexical owner that wrote them.
+        if (['Enum', 'Object', 'Throwable'].includes(base)) {
             return `java.lang.${base}`;
         }
         return base;
@@ -1338,7 +1538,7 @@ function findCallsInCode(code, parser) {
             const nameNode = node.childForFieldName('name');
             return nameNode?.text || '<anonymous>';
         }
-        if (node.type === 'constructor_declaration') {
+        if (node.type === 'constructor_declaration' || node.type === 'compact_constructor_declaration') {
             const nameNode = node.childForFieldName('name');
             return nameNode?.text || '<constructor>';
         }
@@ -1519,7 +1719,8 @@ function findCallsInCode(code, parser) {
         let ownerNode = node.childForFieldName('object');
         if (!ownerNode) {
             const owner = findEnclosingClassName(node);
-            return owner ? { owner, methods: [method] } : null;
+            return owner ? { owner, written: owner, site: typeOrigin('call', node),
+                arities: [getCallArgCount(node)], methods: [method] } : null;
         }
         while (ownerNode?.type === 'parenthesized_expression' &&
             ownerNode.namedChildCount === 1) {
@@ -1528,7 +1729,8 @@ function findCallsInCode(code, parser) {
         if (ownerNode?.type === 'method_invocation') {
             const parent = methodCallPathOf(ownerNode);
             return parent
-                ? { owner: parent.owner, methods: [...parent.methods, method] }
+                ? { ...parent, methods: [...parent.methods, method],
+                    arities: [...parent.arities, getCallArgCount(node)] }
                 : null;
         }
         let ownerType = null;
@@ -1542,7 +1744,8 @@ function findCallsInCode(code, parser) {
             ownerType = ownerNode.childForFieldName('type')?.text;
         }
         return ownerType
-            ? { owner: qualifyTypeName(ownerType), methods: [method] }
+            ? { owner: qualifyTypeName(ownerType), written: ownerType,
+                site: typeOrigin('call', node), arities: [getCallArgCount(node)], methods: [method] }
             : null;
     };
     const argKindOf = (arg) => {
@@ -1631,7 +1834,7 @@ function findCallsInCode(code, parser) {
                 if (!methodNode) return 'expr';
                 if (!ownerNode) {
                     const owner = findEnclosingClassName(arg);
-                    return owner ? `call:${owner}:${methodNode.text}` : 'expr';
+                    return owner ? methodResultKind(owner, methodNode.text, arg) : 'expr';
                 }
                 let normalizedOwner = ownerNode;
                 while (normalizedOwner?.type === 'parenthesized_expression' &&
@@ -1642,7 +1845,9 @@ function findCallsInCode(code, parser) {
                 let ownerRawType = null;
                 if (normalizedOwner?.type === 'identifier') {
                     ownerType = getReceiverType(normalizedOwner.text) ||
-                        (/^[A-Z]/.test(normalizedOwner.text) ? normalizedOwner.text : null);
+                        (!isDeclaredLocal(normalizedOwner.text) &&
+                         !hasEnclosingField(arg, normalizedOwner.text) &&
+                         /^[A-Z]/.test(normalizedOwner.text) ? normalizedOwner.text : null);
                     ownerRawType = getReceiverRawType(normalizedOwner.text);
                 } else if (normalizedOwner?.type === 'cast_expression') {
                     const typeNode = normalizedOwner.childForFieldName('type');
@@ -1670,40 +1875,19 @@ function findCallsInCode(code, parser) {
                         }
                     }
                 }
-                // Generic container access has a source-declared result type:
-                // List<T>.get(i) -> T, Map<K,V>.get(k) -> V. Wildcard
-                // `? extends T` is safe in value position; `? super T` is not.
-                if (methodNode.text === 'get' && ownerRawType?.includes('<')) {
-                    const generic = ownerRawType.slice(
-                        ownerRawType.indexOf('<') + 1,
-                        ownerRawType.lastIndexOf('>'));
-                    const args = [];
-                    let start = 0;
-                    let depth = 0;
-                    for (let i = 0; i <= generic.length; i++) {
-                        const ch = generic[i];
-                        if (ch === '<') depth++;
-                        else if (ch === '>') depth--;
-                        else if ((ch === ',' || i === generic.length) && depth === 0) {
-                            args.push(generic.slice(start, i).trim());
-                            start = i + 1;
-                        }
-                    }
-                    const base = bareTypeName(ownerRawType);
-                    const picked = base === 'Map' ? args[1] : args[0];
-                    if (picked && !/^\?\s+super\b/.test(picked)) {
-                        const valueType = picked.replace(/^\?\s+extends\s+/, '').trim();
-                        if (valueType && valueType !== '?') {
-                            return `type:${qualifyTypeName(valueType)}`;
-                        }
-                    }
-                }
+                // Generic get() return contracts are resolved from the
+                // receiver's actual type at query time. A project container
+                // does not acquire List/Map semantics from its type arguments.
                 if (ownerType) {
-                    return `call:${qualifyTypeName(ownerRawType || ownerType)}:${methodNode.text}`;
+                    const written = ownerRawType || ownerType;
+                    return methodResultKind(hasParameterizedQualifier(written)
+                        ? written : qualifyTypeName(written), methodNode.text, arg, written);
                 }
                 const path = methodCallPathOf(arg);
                 if (path?.methods.length > 1) {
-                    return `chain:${path.owner}#${path.methods.join('#')}`;
+                    return `chain:${path.owner}#${path.methods.join('#')}|` +
+                        encodeURIComponent(JSON.stringify({ written: path.written, site: path.site,
+                            arities: path.arities }));
                 }
                 return 'expr';
             }
@@ -1749,6 +1933,17 @@ function findCallsInCode(code, parser) {
             default: return 'expr';
         }
     };
+    // The argument count alone: a chain records each hop's arity without
+    // deriving every nested argument's kind again (fix #418).
+    const getCallArgCount = (callNode) => {
+        const argsNode = callNode.childForFieldName('arguments');
+        if (!argsNode) return 0;
+        let count = 0;
+        for (let i = 0; i < argsNode.namedChildCount; i++) {
+            if (!argsNode.namedChild(i).type.endsWith('comment')) count++;
+        }
+        return count;
+    };
     const getCallArgs = (callNode) => {
         const argsNode = callNode.childForFieldName('arguments');
         if (!argsNode) return { argCount: 0, argKinds: null };
@@ -1760,6 +1955,13 @@ function findCallsInCode(code, parser) {
         }
         return { argCount: kinds.length, argKinds: kinds.some(k => k !== 'expr') ? kinds : null };
     };
+    const methodResultKind = (owner, method, node, written = owner) => {
+        const args = getCallArgs(node);
+        const kinds = args.argKinds || Array(args.argCount).fill('expr');
+        return `callshape:${encodeURIComponent(owner)}|${encodeURIComponent(method)}|` +
+            kinds.map(encodeURIComponent).join(',') + '|' +
+            encodeURIComponent(JSON.stringify({ written, site: typeOrigin('call', node) }));
+    };
 
     traverseTree(tree.rootNode, (node) => {
         // Track function entry
@@ -1878,10 +2080,13 @@ function findCallsInCode(code, parser) {
                         }
                     }
                 }
+                const pattern = !castReceiverType && receiverNode?.type === 'identifier'
+                    ? patternTypeAt(receiverNode) : null;
                 const receiverType = castReceiverType || inlineConstructorType || arrayElementType ||
-                    ((receiver && receiver !== 'this') ? getReceiverType(receiver) : undefined);
+                    pattern?.type || ((receiver && receiver !== 'this') ? getReceiverType(receiver) : undefined);
                 const receiverTypeQualifier = packageQualifier || arrayElementQualifier ||
-                    (!castReceiverType && receiver ? getReceiverTypeQualifier(receiver) : undefined);
+                    (pattern ? pattern.qualifier : undefined) ||
+                    (!castReceiverType && !pattern && receiver ? getReceiverTypeQualifier(receiver) : undefined);
                 const receiverIsTypeQualified = !!((receiverNode?.type === 'identifier' || packageQualifier) &&
                     receiver && /^[A-Z]/.test(receiver) && !receiverType &&
                     !isDeclaredLocal(receiver) && !hasEnclosingField(node, receiver));
@@ -1949,8 +2154,11 @@ function findCallsInCode(code, parser) {
                     ? methodCallPathOf(objNode) : null;
                 const receiverCallTypePath = receiverPath
                     ? (receiverPath.methods.length === 1
-                        ? `call:${receiverPath.owner}:${receiverPath.methods[0]}`
-                        : `chain:${receiverPath.owner}#${receiverPath.methods.join('#')}`)
+                        ? methodResultKind(receiverPath.owner, receiverPath.methods[0], objNode,
+                            receiverPath.written)
+                        : `chain:${receiverPath.owner}#${receiverPath.methods.join('#')}|` +
+                            encodeURIComponent(JSON.stringify({ written: receiverPath.written,
+                                site: receiverPath.site, arities: receiverPath.arities })))
                     : null;
                 calls.push({
                     callSite: typeOrigin('call', nameNode),
@@ -1961,7 +2169,8 @@ function findCallsInCode(code, parser) {
                     line: nameNode.startPosition.row + 1,
                     isMethod: !!objNode,
                     receiver,
-                    ...(receiverType && { receiverType, ...(getReceiverType(receiver, true) ||
+                    ...(receiverType && { receiverType, ...((pattern && pattern.type === receiverType && pattern.evidence) ||
+                        getReceiverType(receiver, true) ||
                         (castReceiverType ? { receiverTypeSource: 'cast', receiverTypeEvidence: typeOrigin('cast', objNode) } :
                             inlineConstructorType ? { receiverTypeSource: 'constructor', receiverTypeEvidence: typeOrigin('constructor', receiverNode) } :
                             arrayElementType ? { receiverTypeSource: 'annotation', receiverTypeEvidence: typeOrigin('annotation', receiverNode) } :
@@ -2002,11 +2211,14 @@ function findCallsInCode(code, parser) {
         // super(x) / this(x) — constructor delegation (fix #238: these
         // sites were invisible to every command). Resolve to the parent
         // class's constructor (super) or a same-class overload (this);
-        // Java constructors are indexed under the CLASS name, so the
-        // record carries the target class as its name.
+        // Java constructors are named after their class. The record carries
+        // that name, and constructor resolution selects its overload.
         if (node.type === 'explicit_constructor_invocation') {
+            // The constructor's own type declaration: a class, enum or
+            // record (a record's non-canonical constructor delegates with
+            // `this(...)`, fix #419).
             let cls = node.parent;
-            while (cls && cls.type !== 'class_declaration' && cls.type !== 'enum_declaration') {
+            while (cls && !JAVA_CONSTRUCTOR_OWNER_TYPES.has(cls.type)) {
                 cls = cls.parent;
             }
             const isSuperCall = node.children.some(c => c.type === 'super');
@@ -2023,6 +2235,7 @@ function findCallsInCode(code, parser) {
                 const genericIdx = targetClass.indexOf('<');
                 if (genericIdx > 0) targetClass = targetClass.substring(0, genericIdx);
                 const dotIdx = targetClass.lastIndexOf('.');
+                const constructorQualifier = dotIdx > 0 ? targetClass.substring(0, dotIdx) : null;
                 if (dotIdx > 0) targetClass = targetClass.substring(dotIdx + 1);
                 const enclosingFunction = getCurrentEnclosingFunction();
                 const ctorArgs = getCallArgs(node);
@@ -2032,10 +2245,12 @@ function findCallsInCode(code, parser) {
                     line: node.startPosition.row + 1,
                     isMethod: false,
                     isConstructor: true,
+                    ...(constructorQualifier && { constructorQualifier }),
                     // 'this' delegation names the ENCLOSING class by
                     // construction — an intra-class mechanism, never a
                     // caller edge for the class (jdtls-measured, fix #238).
                     ctorDelegation: isSuperCall ? 'super' : 'this',
+                    constructorSyntax: 'delegation',
                     argCount: ctorArgs.argCount,
                     ...(ctorArgs.argKinds && { argKinds: ctorArgs.argKinds }),
                     enclosingFunction
@@ -2067,6 +2282,7 @@ function findCallsInCode(code, parser) {
                     // constructor alive for deadcode/--unused, but never a
                     // caller edge for the enum (jdtls-measured, fix #238).
                     enumConstant: true,
+                    constructorSyntax: 'enum',
                     argCount: ctorArgs.argCount,
                     ...(ctorArgs.argKinds && { argKinds: ctorArgs.argKinds }),
                     enclosingFunction: getCurrentEnclosingFunction()
@@ -2088,8 +2304,10 @@ function findCallsInCode(code, parser) {
                 // as receiver (fix #206): a qualified type must not resolve to
                 // a same-file binding of an unrelated same-name symbol.
                 let typeQualifier = null;
+                let constructorQualifier = null;
                 const dotIdx = typeName.lastIndexOf('.');
                 if (dotIdx > 0) {
+                    constructorQualifier = typeName.substring(0, dotIdx);
                     const qualParts = typeName.substring(0, dotIdx).split('.');
                     typeQualifier = qualParts[qualParts.length - 1] || null;
                     typeName = typeName.substring(dotIdx + 1);
@@ -2104,6 +2322,7 @@ function findCallsInCode(code, parser) {
                     isMethod: false,
                     isConstructor: true,
                     ...(typeQualifier && { receiver: typeQualifier }),
+                    ...(constructorQualifier && { constructorQualifier }),
                     argCount: ctorArgs.argCount,
                     ...(ctorArgs.argKinds && { argKinds: ctorArgs.argKinds }),
                     enclosingFunction
@@ -2232,24 +2451,27 @@ function findCallsInCode(code, parser) {
             const resTypeNode = node.childForFieldName('type');
             const resNameNode = node.childForFieldName('name');
             const resValueNode = node.childForFieldName('value');
-            let typeName = resValueNode?.type === 'object_creation_expression'
-                ? extractTypeName(resValueNode.childForFieldName('type'))
-                : null;
-            let typeQualifier = resValueNode?.type === 'object_creation_expression'
-                ? extractReceiverTypeQualifier(resValueNode.childForFieldName('type'))
-                : null;
-            if (!typeName && resTypeNode && resTypeNode.text !== 'var') {
-                typeName = extractTypeName(resTypeNode);
-                typeQualifier = extractReceiverTypeQualifier(resTypeNode);
-            }
+            // The declared type is the variable's static type; only `var`
+            // takes the constructed one (fix #430: `try (ObjectPool<..> pool =
+            // new TestObjectPool())` calls ObjectPool's members).
+            const declared = resTypeNode && resTypeNode.text !== 'var';
+            const constructed = resValueNode?.type === 'object_creation_expression'
+                ? resValueNode.childForFieldName('type') : null;
+            const typeSource = declared ? resTypeNode : constructed;
+            const typeName = typeSource ? extractTypeName(typeSource) : null;
+            const typeQualifier = typeSource ? extractReceiverTypeQualifier(typeSource) : null;
+            // A resource is final: it holds exactly the constructed value,
+            // as a never-reassigned local does (fix #394).
+            const constructedType = declared && constructed ? extractTypeName(constructed) : null;
+            const exactValue = constructedType && (constructedType !== typeName ||
+                (extractReceiverTypeQualifier(constructed) || null) !== (typeQualifier || null));
             if (resNameNode && typeName) {
                 const scopeKey = functionStack[functionStack.length - 1].startLine;
                 const typeMap = scopeTypes.get(scopeKey);
-                if (typeMap) typeMap.set(resNameNode.text, typeName, 'with-binding', node);
+                if (typeMap) typeMap.set(resNameNode.text, typeName,
+                    exactValue ? { ...typeOrigin('with-binding', node), constructedType } : 'with-binding', node);
                 const rawTypeMap = scopeRawTypes.get(scopeKey);
-                const rawType = resValueNode?.type === 'object_creation_expression'
-                    ? resValueNode.childForFieldName('type')?.text
-                    : resTypeNode?.text;
+                const rawType = typeSource?.text;
                 if (rawType) rawTypeMap?.set(resNameNode.text, rawType);
                 const qualifierMap = scopeTypeQualifiers.get(scopeKey);
                 if (typeQualifier) qualifierMap?.set(resNameNode.text, typeQualifier);
@@ -2284,6 +2506,7 @@ function findCallsInCode(code, parser) {
         }
     });
 
+    calls.push(...require('./constructor-bases').implicitBaseCalls(tree.rootNode, 'java'));
     return calls;
 }
 
@@ -2421,6 +2644,116 @@ function findExportsInCode(code, parser) {
  * @param {object} [tree] - Pre-parsed tree (per-operation cache); parsed here when absent
  * @returns {Array<{line: number, column: number, usageType: string}>}
  */
+function staticValueImportSyntax(tree) {
+    const imports = [];
+    for (const declaration of tree.rootNode.namedChildren) {
+        if (declaration.type !== 'import_declaration' ||
+            !declaration.children.some(child => child.type === 'static')) continue;
+        const path = declaration.namedChildren.find(child =>
+            child.type === 'scoped_identifier' || child.type === 'identifier');
+        if (!path) continue;
+        const wildcard = declaration.children.some(child => child.text === '*');
+        const member = path.childForFieldName('name');
+        const owner = wildcard ? path : path.childForFieldName('scope');
+        if (owner) imports.push({ member: wildcard ? '*' : member?.text,
+            type: owner, token: wildcard ? null : member });
+    }
+    return imports;
+}
+
+/**
+ * Whether a pattern variable's scope (JLS 6.3.1) holds a reference (fix
+ * #420): 'in' (the reference names the pattern variable), 'out' (the
+ * variable is not in scope there) or 'unknown'. A switch-label pattern
+ * reaches its arm; an `instanceof` pattern follows the boolean structure
+ * of its condition (`&&`, `||`, `!`, `?:`, if/while conditions) and, when
+ * introduced while false, the statements after an `if` whose branch
+ * cannot complete normally.
+ */
+function patternBindingReach(binding, reference) {
+    const within = (outer, inner) => !!outer && outer.startIndex <= inner.startIndex && inner.endIndex <= outer.endIndex;
+    if (reference.startIndex <= binding.startIndex) return 'out';
+    for (let node = binding.parent; node; node = node.parent) {
+        if (node.type === 'switch_label') {
+            const arm = node.parent;
+            return arm && (arm.type === 'switch_rule' || arm.type === 'switch_block_statement_group') &&
+                within(arm, reference) ? 'in' : 'out';
+        }
+        if (node.type === 'instanceof_expression') return instanceofReach(node, reference, within);
+        if (/_statement$|^block$|_declaration$|lambda_expression/.test(node.type)) break;
+    }
+    return 'unknown';
+}
+
+function instanceofReach(expression, reference, within) {
+    // A statement that cannot complete normally (null: undecided).
+    const abrupt = statement => {
+        if (!statement) return false;
+        if (['return_statement', 'throw_statement', 'break_statement', 'continue_statement',
+            'yield_statement'].includes(statement.type)) return true;
+        if (statement.type === 'block') {
+            const last = statement.namedChildren.filter(child => !child.type.includes('comment')).pop();
+            return last ? abrupt(last) : false;
+        }
+        if (['expression_statement', 'local_variable_declaration'].includes(statement.type)) return false;
+        return null;
+    };
+    let polarity = true;
+    let node = expression;
+    for (;;) {
+        const parent = node.parent;
+        if (!parent) return 'unknown';
+        if (parent.type === 'parenthesized_expression') { node = parent; continue; }
+        if (parent.type === 'unary_expression' && parent.childForFieldName('operator')?.type === '!') {
+            polarity = !polarity;
+            node = parent;
+            continue;
+        }
+        if (parent.type === 'binary_expression') {
+            const operator = parent.childForFieldName('operator')?.type;
+            if (operator !== '&&' && operator !== '||') return 'out';
+            if (within(parent.childForFieldName('left'), node) && within(parent.childForFieldName('right'), reference)) {
+                return (operator === '&&') === polarity ? 'in' : 'out';
+            }
+            if ((operator === '&&') !== polarity) return 'out';
+            node = parent;
+            continue;
+        }
+        if (parent.type === 'ternary_expression' && within(parent.childForFieldName('condition'), node)) {
+            if (within(parent.childForFieldName('consequence'), reference)) return polarity ? 'in' : 'out';
+            if (within(parent.childForFieldName('alternative'), reference)) return polarity ? 'out' : 'in';
+            return 'out';
+        }
+        if (['while_statement', 'for_statement', 'do_statement'].includes(parent.type) &&
+            within(parent.childForFieldName('condition'), node)) {
+            if (within(parent.childForFieldName('body'), reference)) {
+                return parent.type !== 'do_statement' && polarity ? 'in' : 'out';
+            }
+            if (within(parent, reference)) return 'out';
+            // After a loop exited through its condition only.
+            return polarity ? 'out' : 'unknown';
+        }
+        if (parent.type === 'if_statement' && within(parent.childForFieldName('condition'), node)) {
+            const consequence = parent.childForFieldName('consequence');
+            const alternative = parent.childForFieldName('alternative');
+            if (within(consequence, reference)) return polarity ? 'in' : 'out';
+            if (alternative && within(alternative, reference)) return polarity ? 'out' : 'in';
+            if (within(parent, reference)) return 'out';
+            // The statements after the `if` in its block (JLS 6.3.2.2).
+            const block = parent.parent;
+            if (!block || !within(block, reference) || !['block', 'switch_block_statement_group',
+                'constructor_body'].includes(block.type)) return 'out';
+            const taken = polarity ? alternative : consequence;
+            const other = polarity ? consequence : alternative;
+            if (polarity && !alternative) return 'out';
+            const takenAbrupt = abrupt(taken), otherAbrupt = other ? abrupt(other) : false;
+            if (takenAbrupt === null || otherAbrupt === null) return 'unknown';
+            return takenAbrupt && !otherAbrupt ? 'in' : 'out';
+        }
+        return 'out';
+    }
+}
+
 function findUsagesInCode(code, name, parser, tree) {
     tree = tree || parseTree(parser, code);
     const usages = [];
@@ -2573,7 +2906,18 @@ function isEntryPoint(symbol) {
     return getEntryPointKind(symbol) !== null;
 }
 
+/** Omitted base initializer calls of one class, read as findCallsInCode reads them (fix #421). */
+function implicitBaseCallsOf(code, parser, ownerLine, ownerEndLine) {
+    return require('./constructor-bases').implicitBaseCallsOfOwner(parseTree(parser, code).rootNode, 'java', null,
+        ownerLine, ownerEndLine);
+}
+
 module.exports = {
+    recoverTypeAnnotatedVarargs,
+    implicitOwnerScope: node => ({ enclosingType: enclosingTypeName(node) }),
+    implicitBaseCallsOf,
+    staticValueImportSyntax,
+    patternBindingReach,
     findFunctions,
     findClasses,
     findStateObjects,