ucn 5.2.1 → 5.2.2

package/languages/javascript.js

@@ -463,6 +463,55 @@ function returnsReceiverSelf(node) {
     return sawSelf;
 }
 
+/**
+ * Exact call expression returned by an expression-bodied arrow. This is a
+ * syntax proof, not return-type inference: query-time flow resolves the call
+ * through its ordinary import/receiver ownership rails. Block bodies,
+ * conditionals, and other expressions deliberately stay unmarked.
+ */
+function returnedArrowCallSpan(node) {
+    if (node.type !== 'arrow_function') return null;
+    let body = node.childForFieldName('body');
+    while (body?.type === 'parenthesized_expression' && body.namedChildCount === 1) {
+        body = body.namedChild(0);
+    }
+    if (body?.type !== 'call_expression') return null;
+    return { start: body.startIndex, end: body.endIndex };
+}
+
+/**
+ * Exact `this.field...` value returned by a one-statement method body. The
+ * deliberately narrow shape proves both that the member path is returned and
+ * that no fallthrough/alternate return widens the compiler-inferred type.
+ */
+function returnedReceiverFieldPath(node) {
+    const body = node.childForFieldName('body');
+    if (!body || body.type !== 'statement_block' || body.namedChildCount !== 1) {
+        return null;
+    }
+    const statement = body.namedChild(0);
+    if (statement?.type !== 'return_statement' || statement.namedChildCount !== 1) {
+        return null;
+    }
+    let value = statement.namedChild(0);
+    while (value?.type === 'parenthesized_expression' && value.namedChildCount === 1) {
+        value = value.namedChild(0);
+    }
+    const fields = [];
+    while (value?.type === 'member_expression') {
+        const property = value.childForFieldName('property');
+        const object = value.childForFieldName('object');
+        if (!property || !object ||
+            !['property_identifier', 'private_property_identifier', 'identifier']
+                .includes(property.type)) {
+            return null;
+        }
+        fields.unshift(property.text);
+        value = object;
+    }
+    return value?.type === 'this' && fields.length > 0 ? fields : null;
+}
+
 /**
  * Process a node for function extraction (single-pass helper)
  * Returns true if node was matched, false otherwise
@@ -634,6 +683,7 @@ function _processFunction(node, functions, processedRanges, lines) {
                         // declaration text, so we double-check the value node directly.
                         const valueIsAsync = valueNode.text.trimStart().startsWith('async ');
                         const isAsync = valueIsAsync || modifiers.includes('async');
+                        const returnedCall = returnedArrowCallSpan(valueNode);
 
                         functions.push({
                             name: nameNode.text,
@@ -648,6 +698,10 @@ function _processFunction(node, functions, processedRanges, lines) {
                             modifiers,
                             ...lexicalOwnerRange(node),
                             ...typeAnno,
+                            ...(returnedCall && {
+                                returnedCallStart: returnedCall.start,
+                                returnedCallEnd: returnedCall.end,
+                            }),
                             ...(generics && { generics }),
                             ...(docstring && { docstring })
                         });
@@ -1301,6 +1355,8 @@ function extractClassMembers(classNode, codeOrLines) {
                 const isAsync = text.match(/^\s*(?:(?:public|private|protected)\s+)?(?:static\s+)?(?:override\s+)?async\s/) !== null;
                 const returnType = extractReturnType(child) ||
                     (returnsReceiverSelf(child) ? 'this' : null);
+                const returnedReceiverPath = !returnType
+                    ? returnedReceiverFieldPath(child) : null;
                 const docstring = extractJSDocstring(code, startLine);
                 const paramsStructured = parseStructuredParams(paramsNode, 'javascript');
                 const typeAnno = buildTypeAnnotations(paramsStructured, returnType, code, startLine, true);
@@ -1329,6 +1385,7 @@ function extractClassMembers(classNode, codeOrLines) {
                     // (fix #230) — pickBestDefinition prefers the implementation.
                     ...(child.type === 'method_signature' && { isSignature: true }),
                     ...typeAnno,
+                    ...(returnedReceiverPath && { returnedReceiverPath }),
                     ...(docstring && { docstring }),
                     ...(decorators.length > 0 && { decorators }),
                     ...(decoratorsWithArgs.length > 0 && { decoratorsWithArgs })
@@ -1467,6 +1524,14 @@ function extractClassMembers(classNode, codeOrLines) {
                     const fieldTypeNode = child.childForFieldName('type');
                     const fieldType = fieldTypeNode
                         ? fieldTypeNode.text.replace(/^:\s*/, '').trim() : undefined;
+                    // A direct identifier initializer on a static field keeps
+                    // the lexical callable identity available to the IR:
+                    // `static create = createSchema`. Resolution remains
+                    // same-file and overload-disciplined in createFileIR;
+                    // expressions, member accesses, and instance fields do
+                    // not receive this proof marker.
+                    const callableTarget = isStatic && valueNode?.type === 'identifier'
+                        ? valueNode.text : undefined;
                     members.push({
                         name,
                         startLine,
@@ -1474,6 +1539,7 @@ function extractClassMembers(classNode, codeOrLines) {
                         memberType: name.startsWith('#') ? 'private field' : 'field',
                         ...(isStatic && { modifiers: ['static'] }),
                         ...(fieldType && { fieldType }),
+                        ...(callableTarget && { callableTarget }),
                         ...(fieldDecorators.length > 0 && { decorators: fieldDecorators })
                         // Not a method - regular field
                     });
@@ -1920,13 +1986,120 @@ function findCallsInCode(code, parser) {
     const tree = parseTree(parser, code);
     const calls = [];
     const assignedMembers = new Set();
+    const mutatedObjectRoots = new Set();
+    const moduleCompositions = new Map();
+    const unsafeModuleCompositions = new Set();
+    const namespaceAliases = new Set();
+    const accessRoot = (node) => {
+        let current = node;
+        while (current && (current.type === 'member_expression' ||
+            current.type === 'subscript_expression')) {
+            current = current.childForFieldName('object');
+        }
+        return current?.type === 'identifier' ? current.text : undefined;
+    };
     traverseTreeCached(tree.rootNode, node => {
-        if (node.type !== 'assignment_expression' &&
-            node.type !== 'augmented_assignment_expression') return true;
-        const left = node.childForFieldName('left');
-        if (left?.type === 'member_expression') assignedMembers.add(left.text);
+        if (node.type === 'namespace_import') {
+            const identifier = node.namedChild(0);
+            if (identifier?.type === 'identifier') namespaceAliases.add(identifier.text);
+        }
+        if (node.type === 'variable_declarator') {
+            const declaration = node.parent;
+            const nameNode = node.childForFieldName('name');
+            const valueNode = node.childForFieldName('value');
+            if (nameNode?.type === 'identifier' && valueNode?.type === 'object' &&
+                declaration?.type === 'lexical_declaration' &&
+                declaration.child(0)?.text === 'const' && isModuleScope(declaration)) {
+                const layers = [];
+                let spreadCandidates = 0;
+                for (let i = 0; i < valueNode.namedChildCount; i++) {
+                    const item = valueNode.namedChild(i);
+                    if (item.type === 'spread_element') {
+                        const value = item.namedChild(0);
+                        if (value?.type === 'identifier') {
+                            // Namespace imports may legally appear later in
+                            // the module. Resolve candidates after this pass
+                            // has seen the complete import surface.
+                            layers.push({ kind: 'spread-candidate', receiver: value.text });
+                            spreadCandidates++;
+                        } else {
+                            layers.push({ kind: 'unknown' });
+                        }
+                        continue;
+                    }
+                    if (item.type === 'pair') {
+                        const key = item.childForFieldName('key');
+                        const staticKey = key && ['property_identifier', 'identifier', 'string']
+                            .includes(key.type)
+                            ? key.text.replace(/^['"]|['"]$/g, '') : null;
+                        layers.push(staticKey
+                            ? { kind: 'property', name: staticKey }
+                            : { kind: 'unknown' });
+                        continue;
+                    }
+                    if (item.type === 'shorthand_property_identifier' ||
+                        item.type === 'method_definition') {
+                        const name = item.type === 'method_definition'
+                            ? item.childForFieldName('name')?.text : item.text;
+                        layers.push(name
+                            ? { kind: 'property', name }
+                            : { kind: 'unknown' });
+                        continue;
+                    }
+                    layers.push({ kind: 'unknown' });
+                }
+                if (spreadCandidates > 0) moduleCompositions.set(nameNode.text, layers);
+            }
+        }
+        if (node.type === 'assignment_expression' ||
+            node.type === 'augmented_assignment_expression') {
+            const left = node.childForFieldName('left');
+            if (left?.type === 'member_expression') assignedMembers.add(left.text);
+            const root = accessRoot(left);
+            if (root) mutatedObjectRoots.add(root);
+        }
+        // A namespace-spread composite is exact only while the ordinary
+        // object remains private and unmodified. Any use of the object value
+        // itself (export, alias, return, argument, spread, etc.) can expose a
+        // mutation; property reads/calls are the sole accepted uses.
+        if (node.type !== 'identifier' || !moduleCompositions.has(node.text)) return true;
+        const parent = node.parent;
+        if (parent?.type === 'variable_declarator' &&
+            parent.childForFieldName('name')?.id === node.id) return true;
+        if ((parent?.type === 'member_expression' ||
+            parent?.type === 'subscript_expression') &&
+            parent.childForFieldName('object')?.id === node.id) {
+            let access = parent;
+            while ((access.parent?.type === 'member_expression' ||
+                access.parent?.type === 'subscript_expression') &&
+                access.parent.childForFieldName('object')?.id === access.id) {
+                access = access.parent;
+            }
+            const container = access.parent;
+            const assigned = (container?.type === 'assignment_expression' ||
+                container?.type === 'augmented_assignment_expression') &&
+                container.childForFieldName('left')?.id === access.id;
+            const updated = container?.type === 'update_expression';
+            const deleted = container?.type === 'unary_expression' &&
+                container.child(0)?.text === 'delete';
+            if (!assigned && !updated && !deleted) return true;
+        }
+        unsafeModuleCompositions.add(node.text);
         return true;
     });
+    for (const [name, layers] of moduleCompositions) {
+        const normalized = layers.map(layer => layer.kind === 'spread-candidate'
+            ? (namespaceAliases.has(layer.receiver)
+                ? { kind: 'spread', receiver: layer.receiver }
+                : { kind: 'unknown' })
+            : layer);
+        if (normalized.some(layer => layer.kind === 'spread')) {
+            moduleCompositions.set(name, normalized);
+        } else {
+            moduleCompositions.delete(name);
+        }
+    }
+    for (const name of mutatedObjectRoots) unsafeModuleCompositions.add(name);
     const functionStack = [];  // Stack of { name, startLine, endLine }
     // Local aliases with lexical ownership. A flat aliasName→target map leaks
     // block locals into the rest of a module (`let effect = batchedEffect`
@@ -2162,6 +2335,16 @@ function findCallsInCode(code, parser) {
 
     const _patternDeclaresName = (pattern, name) => {
         if (!pattern) return false;
+        // TypeScript parameter wrappers contain both the runtime binding
+        // pattern and a type annotation. Only the pattern declares names:
+        // `metadata: registries.GlobalMeta` must not make the namespace
+        // identifier `registries` look like a shadowing parameter.
+        if (pattern.type === 'required_parameter' ||
+            pattern.type === 'optional_parameter') {
+            return _patternDeclaresName(
+                pattern.childForFieldName('pattern') ||
+                pattern.childForFieldName('name'), name);
+        }
         if ((pattern.type === 'identifier' ||
             pattern.type === 'shorthand_property_identifier_pattern') &&
             pattern.text === name) return true;
@@ -2189,6 +2372,60 @@ function findCallsInCode(code, parser) {
         return false;
     };
 
+    // Bare callback references need to distinguish a module-owned VALUE from
+    // an unbound name. File-level import reachability cannot prove the value's
+    // identity: `const app = express(); use(app)` may live in a file that also
+    // imports the pinned target, but `app` is the factory result rather than a
+    // direct lexical reference to that target. Keep the parser evidence exact
+    // and cheap by collecting only declarations whose lexical owner is the
+    // program/module root (export wrappers included).
+    const moduleValueBindings = new Set();
+    const collectPatternNames = (pattern) => {
+        if (!pattern) return;
+        if (pattern.type === 'identifier' ||
+            pattern.type === 'shorthand_property_identifier_pattern') {
+            moduleValueBindings.add(pattern.text);
+            return;
+        }
+        if (pattern.type === 'pair_pattern' || pattern.type === 'pair') {
+            collectPatternNames(pattern.childForFieldName('value'));
+            return;
+        }
+        if (pattern.type === 'assignment_pattern') {
+            collectPatternNames(
+                pattern.childForFieldName('left') || pattern.childForFieldName('pattern'));
+            return;
+        }
+        for (let i = 0; i < pattern.namedChildCount; i++) {
+            collectPatternNames(pattern.namedChild(i));
+        }
+    };
+    const collectModuleDeclaration = (statement) => {
+        let declaration = statement;
+        if (statement.type === 'export_statement') {
+            declaration = null;
+            for (let i = 0; i < statement.namedChildCount; i++) {
+                const child = statement.namedChild(i);
+                if (child.type === 'lexical_declaration' || child.type === 'variable_declaration') {
+                    declaration = child;
+                    break;
+                }
+            }
+        }
+        if (!declaration ||
+            (declaration.type !== 'lexical_declaration' &&
+                declaration.type !== 'variable_declaration')) return;
+        for (let i = 0; i < declaration.namedChildCount; i++) {
+            const declarator = declaration.namedChild(i);
+            if (declarator.type === 'variable_declarator') {
+                collectPatternNames(declarator.childForFieldName('name'));
+            }
+        }
+    };
+    for (let i = 0; i < tree.rootNode.namedChildCount; i++) {
+        collectModuleDeclaration(tree.rootNode.namedChild(i));
+    }
+
     // fix #203: is a bare-identifier function REFERENCE shadowed by a
     // let/const/var local, for/catch binding, or inner-arrow param in an
     // enclosing lexical scope? Block-accurate, declaration-before-use.
@@ -2241,6 +2478,11 @@ function findCallsInCode(code, parser) {
         return false;
     };
 
+    const bareReferenceBindingFields = (refNode) => ({
+        ...(isShadowedByLocal(refNode, refNode.text) && { localShadow: true }),
+        ...(moduleValueBindings.has(refNode.text) && { moduleLocalBinding: true }),
+    });
+
     const isConditionalReassignment = node => {
         for (let p = node.parent; p && !isFunctionNode(p); p = p.parent) {
             if (p.type === 'if_statement') {
@@ -2429,7 +2671,7 @@ function findCallsInCode(code, parser) {
                     isMethod: false,
                     isFunctionReference: true,
                     isPotentialCallback: true,
-                    ...(isShadowedByLocal(right, right.text) && { localShadow: true }),
+                    ...bareReferenceBindingFields(right),
                     enclosingFunction: getCurrentEnclosingFunction(),
                 });
             }
@@ -2696,6 +2938,9 @@ function findCallsInCode(code, parser) {
                         const receiverIsModule = !!receiverModuleSpecifier ||
                             (!!receiver && moduleAliases.has(receiver) &&
                                 !localVarTypes.has(receiver));
+                        const receiverModuleComposition = receiver &&
+                            !unsafeModuleCompositions.has(receiver)
+                            ? moduleCompositions.get(receiver) : undefined;
                         const firstArg = getFirstStringArg(node);
                         const argCount = getArgCount(node);
                         let assignedTo = jsAssignmentTargetOf(node);
@@ -2730,6 +2975,9 @@ function findCallsInCode(code, parser) {
                             }),
                             ...(receiverIsModule && { receiverIsModule: true }),
                             ...(receiverModuleSpecifier && { receiverModuleSpecifier }),
+                            ...(receiverModuleComposition && {
+                                receiverModuleComposition,
+                            }),
                             ...(receiver && assignedMembers.has(`${receiver}.${propName}`) && {
                                 receiverMemberAssigned: true,
                             }),
@@ -2787,7 +3035,7 @@ function findCallsInCode(code, parser) {
                                     line: arg.startPosition.row + 1,
                                     isMethod: false,
                                     isFunctionReference: true,
-                                    ...(isShadowedByLocal(arg, arg.text) && { localShadow: true }),
+                                    ...bareReferenceBindingFields(arg),
                                     enclosingFunction
                                 });
                             } else if (arg.type === 'member_expression') {
@@ -2832,7 +3080,7 @@ function findCallsInCode(code, parser) {
                                 isMethod: false,
                                 isFunctionReference: true,
                                 isPotentialCallback: true,
-                                ...(isShadowedByLocal(arg, arg.text) && { localShadow: true }),
+                                ...bareReferenceBindingFields(arg),
                                 enclosingFunction
                             });
                         }
@@ -2873,7 +3121,7 @@ function findCallsInCode(code, parser) {
                                             isMethod: false,
                                             isFunctionReference: true,
                                             isPotentialCallback: true,
-                                            ...(isShadowedByLocal(val, val.text) && { localShadow: true }),
+                                            ...bareReferenceBindingFields(val),
                                             enclosingFunction
                                         });
                                     }
@@ -2977,7 +3225,7 @@ function findCallsInCode(code, parser) {
                         isMethod: false,
                         isFunctionReference: true,
                         isPotentialCallback: true,
-                        ...(isShadowedByLocal(child, child.text) && { localShadow: true }),
+                        ...bareReferenceBindingFields(child),
                         enclosingFunction
                     });
                 } else if (child.type === 'member_expression') {