ucn 5.3.4 → 5.3.6

package/languages/javascript.js

@@ -5,6 +5,9 @@
  * interfaces, type aliases, enums, and state objects.
  */
 
+const { ReceiverTypeMap, typeOrigin } = require('./type-evidence');
+
+
 const {
     traverseTree,
     traverseTreeCached,
@@ -1898,6 +1901,23 @@ function tsTypeName(node) {
     }
 }
 
+function tsArrayElement(node) {
+    if (!node) return null;
+    if (['type_annotation', 'parenthesized_type', 'readonly_type'].includes(node.type)) {
+        return tsArrayElement(node.namedChild(0));
+    }
+    if (node.type === 'union_type') {
+        const present = node.namedChildren.filter(child =>
+            !(child.type === 'literal_type' && ['null', 'undefined'].includes(child.text)));
+        return present.length === 1 ? tsArrayElement(present[0]) : null;
+    }
+    if (node.type !== 'array_type') return null;
+    const item = node.namedChild(0);
+    if (!['type_identifier', 'nested_type_identifier', 'generic_type', 'predefined_type'].includes(item?.type)) return null;
+    const type = tsTypeName(item);
+    return type ? { type, qualifier: tsTypeQualifier(item), node: item } : null;
+}
+
 /**
  * Variable receiving this call's result: `const x = foo()` / `x = await foo()`
  * → 'x'. Identifier targets only. Compared by node id — tree-sitter wrapper
@@ -1990,6 +2010,7 @@ function findCallsInCode(code, parser) {
     const moduleCompositions = new Map();
     const unsafeModuleCompositions = new Set();
     const namespaceAliases = new Set();
+    const arrayAnnotationNames = new Set();
     const accessRoot = (node) => {
         let current = node;
         while (current && (current.type === 'member_expression' ||
@@ -1999,6 +2020,12 @@ function findCallsInCode(code, parser) {
         return current?.type === 'identifier' ? current.text : undefined;
     };
     traverseTreeCached(tree.rootNode, node => {
+        if (['variable_declarator', 'required_parameter', 'optional_parameter'].includes(node.type)) {
+            const name = node.childForFieldName('name') || node.childForFieldName('pattern');
+            if (name?.type === 'identifier' && tsArrayElement(node.childForFieldName('type'))) {
+                arrayAnnotationNames.add(name.text);
+            }
+        }
         if (node.type === 'namespace_import') {
             const identifier = node.namedChild(0);
             if (identifier?.type === 'identifier') namespaceAliases.add(identifier.text);
@@ -2107,7 +2134,7 @@ function findCallsInCode(code, parser) {
     // false external edges and caller/callee disagreement.
     const aliases = new Map();  // aliasName -> [{ target, declarationIndex, scopeStart, scopeEnd }]
     const nonCallableNames = new Set();  // Track names assigned non-callable values
-    const localVarTypes = new Map();  // Track local variable types: varName -> typeName (for receiverType inference)
+    const localVarTypes = new ReceiverTypeMap();  // Track local variable types: varName -> typeName (for receiverType inference)
     const localVarTypeQualifiers = new Map(); // qualifier provenance for new ns.Type()
     // Names whose type came from a DECLARED annotation (TS `x: Foo` / typed
     // params). The compiler enforces assignability for these, so reassignment
@@ -2361,6 +2388,79 @@ function findCallsInCode(code, parser) {
         return false;
     };
 
+    // Resolve the actual lexical declaration for an indexed receiver. Keep
+    // untyped bindings too: a shadow must stop an outer annotation from
+    // leaking into a nested function or block. This lookup is cached per
+    // spelling and used only for bracket receivers, not every ordinary call.
+    const indexedBindings = new Map();
+    const indexedBinding = (name, site) => {
+        if (!indexedBindings.has(name)) {
+            const records = [];
+            const add = (pattern, declaration, scope) => {
+                if (!scope || !_patternDeclaresName(pattern, name)) return;
+                records.push({ declaration, scope, type: pattern?.type === 'identifier'
+                    ? declaration.childForFieldName('type') : null });
+            };
+            traverseTree(tree.rootNode, current => {
+                if (current.type === 'variable_declarator') {
+                    add(current.childForFieldName('name'), current, aliasScope(current));
+                } else if (isFunctionNode(current)) {
+                    const parameters = current.childForFieldName('parameters');
+                    for (const parameter of parameters?.namedChildren || []) {
+                        const pattern = parameter.childForFieldName('pattern') ||
+                            parameter.childForFieldName('name') || parameter;
+                        add(pattern, parameter, current);
+                    }
+                    const lone = current.childForFieldName('parameter');
+                    if (lone) add(lone, lone, current);
+                    const fnName = current.childForFieldName('name');
+                    if (fnName?.text === name) add(fnName, current,
+                        current.type === 'function_declaration' ? current.parent : current);
+                } else if (current.type === 'catch_clause') {
+                    add(current.childForFieldName('parameter'), current, current);
+                }
+                return true;
+            });
+            indexedBindings.set(name, records);
+        }
+        const matches = indexedBindings.get(name).filter(record =>
+            record.scope.startIndex <= site.startIndex && record.scope.endIndex >= site.endIndex)
+            .sort((a, b) => (a.scope.endIndex - a.scope.startIndex) - (b.scope.endIndex - b.scope.startIndex));
+        const nearest = matches[0];
+        if (!nearest || nearest.declaration.startIndex > site.startIndex ||
+            (matches[1] && matches[1].scope.id === nearest.scope.id)) return null;
+        return nearest;
+    };
+    const indexedArrayReceiver = object => {
+        if (object?.type !== 'subscript_expression') return null;
+        const root = object.childForFieldName('object');
+        const offset = object.childForFieldName('index');
+        if (root?.type !== 'identifier' || !arrayAnnotationNames.has(root.text) || !offset) return null;
+        let numeric = offset.type === 'number';
+        if (offset.type === 'identifier') {
+            const indexBinding = indexedBinding(offset.text, object);
+            const annotation = indexBinding?.type?.namedChild(0);
+            numeric = annotation?.type === 'predefined_type' && annotation.text === 'number';
+            if (!annotation && indexBinding?.declaration.childForFieldName('value')?.type === 'number') {
+                numeric = localVarTypes.get(offset.text) === 'Number';
+            }
+        }
+        if (!numeric) return null;
+        const binding = indexedBinding(root.text, object);
+        const element = tsArrayElement(binding?.type);
+        if (element && !element.qualifier) {
+            for (let scope = binding.declaration.parent; scope; scope = scope.parent) {
+                const parameters = scope.childForFieldName('type_parameters');
+                if (parameters?.namedChildren.some(parameter =>
+                    (parameter.childForFieldName('name')?.text || parameter.text) === element.type)) return null;
+            }
+        }
+        return element && { ...element,
+            evidence: { ...typeOrigin('annotation', binding.type), projection: 'array-element',
+                container: root.text, elementType: element.node.text,
+                index: { start: offset.startIndex, end: offset.endIndex, nodeType: offset.type } } };
+    };
+
     // fix #203: does a declaration node declare `name` (including nested destructuring)?
     const _declaresName = (declNode, name) => {
         for (let i = 0; i < declNode.namedChildCount; i++) {
@@ -2549,7 +2649,7 @@ function findCallsInCode(code, parser) {
                 endLine: node.endPosition.row + 1
             });
             // Save localVarTypes so inner declarations don't leak to sibling functions
-            localVarTypesStack.push(new Map(localVarTypes));
+            localVarTypesStack.push(new ReceiverTypeMap(localVarTypes));
             localVarTypeQualifiersStack.push(new Map(localVarTypeQualifiers));
             declaredTypeVarsStack.push(new Set(declaredTypeVars));
         }
@@ -2603,7 +2703,7 @@ function findCallsInCode(code, parser) {
                 // Infer type: const x = new Foo() / new pkg.Foo() → x is Foo
                 const ctorName = jsConstructorTypeName(initNode.childForFieldName('constructor'));
                 if (ctorName) {
-                    localVarTypes.set(nameNode.text, ctorName);
+                    localVarTypes.set(nameNode.text, ctorName, 'constructor', initNode);
                     const qualifier = jsConstructorTypeQualifier(
                         initNode.childForFieldName('constructor'));
                     if (qualifier) localVarTypeQualifiers.set(nameNode.text, qualifier);
@@ -2619,7 +2719,7 @@ function findCallsInCode(code, parser) {
                         ? typeNode.namedChild(0) : typeNode;
                     const typeName = tsTypeName(typeId);
                     if (typeName) {
-                        localVarTypes.set(nameNode.text, typeName);
+                        localVarTypes.set(nameNode.text, typeName, 'annotation', typeNode);
                         declaredTypeVars.add(nameNode.text);
                         const annotationQualifier = tsTypeQualifier(typeId);
                         if (annotationQualifier) {
@@ -2632,7 +2732,7 @@ function findCallsInCode(code, parser) {
                     // Literal declaration types the variable (fix #262):
                     // `const lines = []` → Array. Annotation, when present,
                     // wins (the branch above).
-                    localVarTypes.set(nameNode.text, JS_LITERAL_ASSIGN_TYPES[initNode.type]);
+                    localVarTypes.set(nameNode.text, JS_LITERAL_ASSIGN_TYPES[initNode.type], 'literal', initNode);
                 }
             }
         }
@@ -2645,7 +2745,7 @@ function findCallsInCode(code, parser) {
                 const inner = typeNode.type === 'type_annotation' ? typeNode.namedChild(0) : typeNode;
                 const typeName = tsTypeName(inner);
                 if (typeName) {
-                    localVarTypes.set(pat.text, typeName);
+                    localVarTypes.set(pat.text, typeName, 'annotation', node);
                     declaredTypeVars.add(pat.text);
                     const annotationQualifier = tsTypeQualifier(inner);
                     if (annotationQualifier) {
@@ -2666,7 +2766,7 @@ function findCallsInCode(code, parser) {
                     nonCallableNames.add(left.text);
                     const ctorName = jsConstructorTypeName(right.childForFieldName('constructor'));
                     if (ctorName && !isConditionalReassignment(node)) {
-                        localVarTypes.set(left.text, ctorName);
+                        localVarTypes.set(left.text, ctorName, 'constructor', right);
                         const qualifier = jsConstructorTypeQualifier(
                             right.childForFieldName('constructor'));
                         if (qualifier) localVarTypeQualifiers.set(left.text, qualifier);
@@ -2678,7 +2778,7 @@ function findCallsInCode(code, parser) {
                 } else if (right && JS_LITERAL_ASSIGN_TYPES[right.type]) {
                     // Literal reassignment re-types the variable (fix #262)
                     if (!declaredTypeVars.has(left.text)) {
-                        localVarTypes.set(left.text, JS_LITERAL_ASSIGN_TYPES[right.type]);
+                        localVarTypes.set(left.text, JS_LITERAL_ASSIGN_TYPES[right.type], 'literal', right);
                         localVarTypeQualifiers.delete(left.text);
                     }
                 } else if (localVarTypes.has(left.text) && !declaredTypeVars.has(left.text)) {
@@ -2861,7 +2961,11 @@ function findCallsInCode(code, parser) {
                                     isMethod: true,
                                     boundCall: true,
                                     receiver: boundReceiver,
-                                    ...(boundReceiverType && { receiverType: boundReceiverType }),
+                                    ...(boundReceiverType && { receiverType: boundReceiverType,
+                                        ...(prototypeOwner ? {
+                                            receiverTypeSource: 'type-qualified',
+                                            receiverTypeEvidence: typeOrigin('type-qualified', innerObj),
+                                        } : localVarTypes.fields(innerObj?.text, boundReceiverType)) }),
                                     ...(innerObj?.type === 'identifier' &&
                                         localVarTypeQualifiers.has(innerObj.text) && {
                                             receiverTypeQualifier: localVarTypeQualifiers.get(innerObj.text),
@@ -2962,10 +3066,11 @@ function findCallsInCode(code, parser) {
                         const constructedReceiverQualifier = objNode?.type === 'new_expression'
                             ? jsConstructorTypeQualifier(objNode.childForFieldName('constructor'))
                             : undefined;
-                        const receiverType = receiver
+                        const indexedReceiver = indexedArrayReceiver(objNode);
+                        const receiverType = indexedReceiver?.type || (receiver
                             ? localVarTypes.get(receiver)
                             : (constructedReceiverType ||
-                                (objNode ? JS_LITERAL_RECEIVER_TYPES[objNode.type] : undefined));
+                                (objNode ? JS_LITERAL_RECEIVER_TYPES[objNode.type] : undefined)));
                         // Module receiver (ns.helper()) — unless locally shadowed
                         // by a typed instance binding
                         const receiverModuleSpecifier = jsLiteralRequireModule(objNode);
@@ -3001,10 +3106,17 @@ function findCallsInCode(code, parser) {
                             callEnd: node.endIndex,
                             isMethod: true,
                             receiver,
-                            ...(receiverType && { receiverType }),
-                            ...((constructedReceiverQualifier ||
+                            ...(receiverType && { receiverType,
+                                ...(indexedReceiver ? { receiverTypeSource: 'annotation',
+                                    receiverTypeEvidence: indexedReceiver.evidence }
+                                    : receiver ? localVarTypes.fields(receiver, receiverType) : {
+                                    receiverTypeSource: constructedReceiverType ? 'constructor' : 'literal',
+                                    receiverTypeEvidence: typeOrigin(constructedReceiverType ? 'constructor' : 'literal', objNode),
+                                }),
+                            }),
+                            ...((indexedReceiver?.qualifier || constructedReceiverQualifier ||
                                 (receiver && localVarTypeQualifiers.get(receiver))) && {
-                                receiverTypeQualifier: constructedReceiverQualifier ||
+                                receiverTypeQualifier: indexedReceiver?.qualifier || constructedReceiverQualifier ||
                                     localVarTypeQualifiers.get(receiver),
                             }),
                             ...(receiverIsModule && { receiverIsModule: true }),
@@ -3087,7 +3199,7 @@ function findCallsInCode(code, parser) {
                                         line: arg.startPosition.row + 1,
                                         isMethod: true,
                                         receiver: hofRecv,
-                                        ...(hofRecvType && { receiverType: hofRecvType }),
+                                        ...(hofRecvType && { receiverType: hofRecvType, ...localVarTypes.fields(hofRecv, hofRecvType) }),
                                         isFunctionReference: true,
                                         enclosingFunction
                                     });
@@ -3135,7 +3247,7 @@ function findCallsInCode(code, parser) {
                                     line: arg.startPosition.row + 1,
                                     isMethod: true,
                                     receiver: mvObj.text,
-                                    ...(mvType && { receiverType: mvType }),
+                                    ...(mvType && { receiverType: mvType, ...localVarTypes.fields(mvObj.text, mvType) }),
                                     isFunctionReference: true,
                                     enclosingFunction
                                 });
@@ -3290,8 +3402,7 @@ function findCallsInCode(code, parser) {
                 // Restore localVarTypes to pre-function state
                 const saved = localVarTypesStack.pop();
                 if (saved) {
-                    localVarTypes.clear();
-                    for (const [k, v] of saved) localVarTypes.set(k, v);
+                    localVarTypes.restore(saved);
                 }
                 const savedQualifiers = localVarTypeQualifiersStack.pop();
                 if (savedQualifiers) {