@lzehrung/codegraph 2.3.30 → 2.4.0

package/dist/indexer/locals-and-exports.js

@@ -1,17 +1,38 @@
+import { cTagRole } from "../languages/definitions/c.js";
 import { isGraphOnlyLanguage } from "../document-links.js";
 import { capturesByName, capturesNamed, rangeFromNativeCapture } from "../native/query-results.js";
 import { buildByteToStringIndexMap } from "../native/byte-index.js";
 import { ProjectedSyntaxTree } from "../native/projected-tree.js";
 import { assertNativeRequiredAvailable, getNativeSyntaxTreeExecution, isNativeRequiredUnavailableError, } from "../native/tree-sitter-native.js";
-import { maskJsLikeCommentsAndStrings } from "../util/comments.js";
+import { maskJsLikeCommentsAndStrings, maskJsLikeCommentsStringsAndRegex } from "../util/comments.js";
 import { sliceText, toRange, unquote } from "../util/ast.js";
 import { bindingKindToSymbolKind } from "./declarations.js";
 import { buildScopeIndexFromSource } from "./scope.js";
+import { findClosestScopeBinding } from "./navigation-local.js";
 import { SymbolKind } from "./types.js";
 import { isPythonInstanceAttributeDeclaration } from "../languages/definitions/python.js";
+import { phpConstructorPromotedVariable, phpPropertyPromotionParameter } from "./navigation-php.js";
 import { importCapture } from "../languages/graph-captures.js";
 import { ECMASCRIPT_IDENTIFIER_SOURCE, XID_IDENTIFIER_SOURCE } from "../util/identifiers.js";
 import { isExportedDeclaration } from "./declaration-visibility.js";
+import { cppQualifiedNameSegments } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { cppCallableIsDefinition, cppCallableShapeForNode } from "./cpp-callables.js";
+import { typescriptCollapsedOverloadTarget, typescriptCallableContainerKey, typescriptCallableRoleAt, } from "./ts-callables.js";
+// Missing captured comments prove missing documentation only for these languages.
+// Python captures # comments but not triple-quoted function/class docstrings.
+/** Languages whose parsers capture docstrings onto local definitions. */
+export const DOCSTRING_CAPTURE_LANGUAGES = new Set([
+    "ts",
+    "tsx",
+    "js",
+    "go",
+    "java",
+    "csharp",
+    "kotlin",
+    "rust",
+    "zig",
+    "scss",
+]);
 /**
  * Matches one `exportScopeBlockers` entry against an ancestor node. A plain entry compares the
  * node type; a `parent>node` entry also requires that parent type, which is how Python separates a
@@ -30,6 +51,9 @@ const JS_FALLBACK_REEXPORT_SPECIFIER_PATTERN = new RegExp(String.raw `^(?:type\s
 const JS_FALLBACK_REEXPORT_TYPE_SPECIFIER_PATTERN = new RegExp(String.raw `^type\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})(?:\s+as\s+(${ECMASCRIPT_IDENTIFIER_SOURCE}))?$`, "u");
 const JS_FALLBACK_REEXPORT_NAMESPACE_PATTERN = new RegExp(String.raw `\bexport\s*\*\s+as\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})\s+from\s*("|')([^"']*)\2`, "gu");
 const JS_FALLBACK_CJS_FUNCTION_PATTERN = new RegExp(String.raw `(?:^|[;\n\r])\s*(?:exports|module\.exports)\.(${ECMASCRIPT_IDENTIFIER_SOURCE})\s*=\s*(function\b|\([^)]*\)\s*=>)`, "gu");
+const JS_FALLBACK_CJS_MODULE_FUNCTION_PATTERN = new RegExp(String.raw `(?:^|[;\n\r])\s*module\.exports\s*=\s*(?:async\s+)?(?:function\b\s*\*?\s*(${ECMASCRIPT_IDENTIFIER_SOURCE})?\s*\(|\([^)]*\)\s*=>|${ECMASCRIPT_IDENTIFIER_SOURCE}\s*=>)`, "gu");
+const JS_FALLBACK_CJS_MODULE_IDENTIFIER_PATTERN = new RegExp(String.raw `(?:^|[;\n\r])\s*module\.exports\s*=\s*(${ECMASCRIPT_IDENTIFIER_SOURCE})(?![$_\p{ID_Continue}\u200c\u200d])(?=\s*(?:;|$|\r|\n))`, "gu");
+const JS_FALLBACK_TOP_LEVEL_LOCAL_PATTERN = new RegExp(String.raw `(?:^|[;{}\n\r])\s*(?:export\s+)?(?:default\s+)?(?:declare\s+)?((?:abstract\s+)?class|(?:async\s+)?function|const|let|var)\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})(?![$_\p{ID_Continue}\u200c\u200d])`, "gu");
 const JS_FALLBACK_CJS_OBJECT_FUNCTION_PATTERN = new RegExp(String.raw `(${ECMASCRIPT_IDENTIFIER_SOURCE})\s*:\s*(function\b|\([^)]*\)\s*=>)`, "gu");
 const JS_DEFAULT_FUNCTION_PATTERN = new RegExp(String.raw `\bexport\s+default\s+(?:async\s+)?function\b\s*\*?\s*(${ECMASCRIPT_IDENTIFIER_SOURCE})`, "u");
 const JS_DEFAULT_CLASS_PATTERN = new RegExp(String.raw `\bexport\s+default\s+(?:abstract\s+)?class\s+(${ECMASCRIPT_IDENTIFIER_SOURCE})`, "u");
@@ -57,12 +81,21 @@ const MEMBER_CONTAINER_NODE_TYPES = {
     class_declaration: true,
     abstract_class_declaration: true,
     class_definition: true,
+    class_specifier: true,
+    struct_specifier: true,
+    union_specifier: true,
     class: true,
     interface_declaration: true,
     impl_item: true,
     trait_item: true,
     enum_declaration: true,
     enum_item: true,
+    // Zig has no implicit member scope of its own; a function nested in one of these container
+    // forms is a method, matching the receiver-call detection in receiver-calls.ts's
+    // MEMBER_CONTAINER_TYPES, which already lists all three.
+    struct_declaration: true,
+    union_declaration: true,
+    opaque_declaration: true,
 };
 const CALLABLE_DECLARATION_NODE_TYPES = {
     function_declaration: true,
@@ -77,6 +110,8 @@ const CALLABLE_DECLARATION_NODE_TYPES = {
 function isTypeMemberDeclaration(node) {
     if (isPythonInstanceAttributeDeclaration(node))
         return true;
+    if (phpConstructorPromotedVariable(node))
+        return true;
     let current = node.parent?.parent ?? null;
     while (current) {
         if (MEMBER_CONTAINER_NODE_TYPES[current.type])
@@ -87,6 +122,104 @@ function isTypeMemberDeclaration(node) {
     }
     return false;
 }
+function cppQualifiedExportName(nameNode, source, name, omitInlineNamespaces = false) {
+    const namespaceSegments = [];
+    let qualifiedSegments = null;
+    let current = nameNode;
+    while (current) {
+        if (!qualifiedSegments && current.type === "qualified_identifier") {
+            // `a::C::run` nests `C::run` inside `a::(...)`; the outermost node carries the full path.
+            while (current.parent?.type === "qualified_identifier")
+                current = current.parent;
+            if (current.parent?.type !== "using_declaration") {
+                const segments = cppQualifiedNameSegments(current, source);
+                if (segments.length > 1)
+                    qualifiedSegments = segments;
+            }
+        }
+        if (current.type === "namespace_definition") {
+            const namespaceName = current.childForFieldName("name");
+            if (!namespaceName) {
+                current = current.parent;
+                continue;
+            }
+            const declaresNamespaceSegment = namespaceName.startIndex <= nameNode.startIndex && namespaceName.endIndex >= nameNode.endIndex;
+            if (declaresNamespaceSegment) {
+                qualifiedSegments =
+                    namespaceName.type === "nested_namespace_specifier"
+                        ? namespaceName.namedChildren
+                            .filter((child) => child.type === "namespace_identifier" && child.endIndex <= nameNode.endIndex)
+                            .map((child) => sliceText(child, source))
+                        : [name];
+            }
+            else if (!omitInlineNamespaces || current.child(0)?.type !== "inline") {
+                namespaceSegments.unshift(cppQualifiedNameSegments(namespaceName, source));
+            }
+        }
+        current = current.parent;
+    }
+    return [...namespaceSegments.flat(), ...(qualifiedSegments ?? [name])].join("::");
+}
+const RUBY_CONTAINER_TYPES = new Set(["class", "module"]);
+/** Whether `container`'s own body (not a nested class or module) declares `name`. */
+function rubyContainerDeclares(container, name, source) {
+    const visit = (node) => {
+        for (const child of node.namedChildren) {
+            if (RUBY_CONTAINER_TYPES.has(child.type)) {
+                const childName = child.childForFieldName("name");
+                if (childName && sliceText(childName, source) === name)
+                    return true;
+                continue;
+            }
+            if (visit(child))
+                return true;
+        }
+        return false;
+    };
+    return visit(container);
+}
+/**
+ * Nested Ruby constants are not top-level names. `module Outer; class Base`
+ * exports as `Outer::Base`, so a `require` cannot bind bare `Base`. A `scope_resolution`
+ * name (`class Inner::Tool`) looks up its first segment lexically, as Ruby does: the
+ * innermost enclosing class or module that declares `Inner` in this file supplies the
+ * prefix (`Outer::Inner::Tool`); otherwise the path is top-level. A leading `::` is absolute.
+ */
+function rubyQualifiedExportName(nameNode, source, name) {
+    if (name.startsWith("::"))
+        return name.slice(2);
+    const containers = [];
+    for (let current = nameNode.parent; current; current = current.parent) {
+        if (!RUBY_CONTAINER_TYPES.has(current.type))
+            continue;
+        const containerName = current.childForFieldName("name");
+        if (!containerName)
+            continue;
+        const ownsExport = containerName.startIndex <= nameNode.startIndex && containerName.endIndex >= nameNode.endIndex;
+        if (ownsExport)
+            continue;
+        const text = sliceText(containerName, source);
+        if (text)
+            containers.push({ node: current, text });
+    }
+    // `containers` is innermost first. A plain constant is owned by the innermost container; a
+    // scope-resolution name by the innermost container that declares its first segment.
+    let ownerIndex = 0;
+    if (nameNode.type === "scope_resolution") {
+        const firstSegment = name.split("::")[0] ?? name;
+        ownerIndex = containers.findIndex((container) => rubyContainerDeclares(container.node, firstSegment, source));
+        if (ownerIndex < 0)
+            return name;
+    }
+    else if (nameNode.type !== "constant") {
+        return name;
+    }
+    const prefix = containers
+        .slice(ownerIndex)
+        .reverse()
+        .map((container) => container.text);
+    return prefix.length ? `${prefix.join("::")}::${name}` : name;
+}
 const C_DECLARATOR_IDENTIFIER_PATTERN = new RegExp(`^${XID_IDENTIFIER_SOURCE}`, "u");
 const C_DECLARATOR_QUALIFIER_PATTERN = /^(?:const|volatile|restrict|_Atomic)\b/;
 function cDeclaratorDeclaredName(text) {
@@ -128,40 +261,92 @@ function declaratorNameNode(node) {
     }
     return undefined;
 }
-function declaratorCaptureName(capture, node) {
-    const fromNode = declaratorNameNode(node)?.text;
-    if (fromNode)
-        return fromNode;
-    if (capture.nodeType === "identifier" || capture.nodeType === "type_identifier")
-        return capture.text;
-    return cDeclaratorDeclaredName(capture.text)?.name;
-}
-function localExportDedupeKey(entry) {
+// C function and tag redeclarations share an identity. Tags remain separate from
+// typedefs and other ordinary names, even when both are classified as TypeAlias.
+function localExportDedupeKey(entry, languageId) {
+    if (languageId === "c") {
+        if (entry.target.kind === SymbolKind.Function)
+            return `${entry.exportedAs}\0function`;
+        if (entry.target.cTag) {
+            return `${entry.exportedAs}\0tag`;
+        }
+    }
     return `${entry.exportedAs}\0${entry.target.localName}\0${entry.target.range.start.index ?? 0}\0${entry.target.range.end.index ?? 0}`;
 }
-function dedupeExportEntries(entries) {
-    const seen = new Set();
+function collapseTypeScriptCallableExports(exports, tree, languageId) {
+    if ((languageId !== "ts" && languageId !== "tsx") || !tree)
+        return exports;
+    const groups = new Map();
+    for (const entry of exports) {
+        if (entry.type !== "local" || entry.target.kind !== SymbolKind.Function)
+            continue;
+        const start = entry.target.range.start.index ?? 0;
+        const end = entry.target.range.end.index ?? start;
+        const role = typescriptCallableRoleAt(tree, start, end);
+        if (role === "other")
+            continue;
+        const key = `${typescriptCallableContainerKey(tree, start, end)}\0${entry.exportedAs}`;
+        const group = groups.get(key) ?? [];
+        group.push(entry);
+        groups.set(key, group);
+    }
+    const drop = new Set();
+    for (const group of groups.values()) {
+        if (group.length < 2)
+            continue;
+        const canonical = typescriptCollapsedOverloadTarget(group, tree, (entry) => entry.target);
+        if (!canonical)
+            continue;
+        if (!canonical.target.docstring?.trim()) {
+            const documented = group.find((entry) => entry.target.docstring?.trim());
+            if (documented?.target.docstring)
+                canonical.target.docstring = documented.target.docstring;
+        }
+        for (const entry of group) {
+            if (entry !== canonical)
+                drop.add(entry);
+        }
+    }
+    if (drop.size === 0)
+        return exports;
+    return exports.filter((entry) => !drop.has(entry));
+}
+function dedupeExportEntries(entries, languageId) {
+    const seen = new Map();
     const out = [];
     for (const entry of entries) {
         if (entry.type !== "local") {
             out.push(entry);
             continue;
         }
-        const key = localExportDedupeKey(entry);
-        if (seen.has(key))
+        const key = localExportDedupeKey(entry, languageId);
+        const previousIndex = seen.get(key);
+        if (previousIndex !== undefined) {
+            const previous = out[previousIndex];
+            if (languageId === "c" &&
+                entry.target.cTag === "declaration" &&
+                previous?.type === "local" &&
+                previous.target.cTag &&
+                previous.target.cTag !== "declaration") {
+                out[previousIndex] = entry;
+            }
             continue;
-        seen.add(key);
+        }
+        seen.set(key, out.length);
         out.push(entry);
     }
     return out;
 }
-function appendJsLikeRegexFallbackExports(file, source, locals, exports) {
+function appendJsLikeRegexFallbackExports(file, source, locals, exports, leadingDocstringAt, tree) {
     const maskedSource = maskJsLikeCommentsAndStrings(source);
     JS_FALLBACK_DECLARATION_PATTERN.lastIndex = 0;
     JS_FALLBACK_DEFAULT_PATTERN.lastIndex = 0;
     JS_FALLBACK_EXPORT_ASSIGN_PATTERN.lastIndex = 0;
     JS_FALLBACK_REEXPORT_NAMESPACE_PATTERN.lastIndex = 0;
     JS_FALLBACK_CJS_FUNCTION_PATTERN.lastIndex = 0;
+    JS_FALLBACK_CJS_MODULE_FUNCTION_PATTERN.lastIndex = 0;
+    JS_FALLBACK_CJS_MODULE_IDENTIFIER_PATTERN.lastIndex = 0;
+    JS_FALLBACK_TOP_LEVEL_LOCAL_PATTERN.lastIndex = 0;
     JS_FALLBACK_CJS_OBJECT_FUNCTION_PATTERN.lastIndex = 0;
     const reDecl = JS_FALLBACK_DECLARATION_PATTERN;
     const reDefault = JS_FALLBACK_DEFAULT_PATTERN;
@@ -170,8 +355,67 @@ function appendJsLikeRegexFallbackExports(file, source, locals, exports) {
     const reReexportNs = JS_FALLBACK_REEXPORT_NAMESPACE_PATTERN;
     const reStar = /\bexport\s*\*\s*from\s*("|')([^"']*)\1/gu;
     const reCjsFn = JS_FALLBACK_CJS_FUNCTION_PATTERN;
+    const reCjsModuleFn = JS_FALLBACK_CJS_MODULE_FUNCTION_PATTERN;
+    const reCjsModuleIdentifier = JS_FALLBACK_CJS_MODULE_IDENTIFIER_PATTERN;
+    const reTopLevelLocal = JS_FALLBACK_TOP_LEVEL_LOCAL_PATTERN;
     const reCjsObjFn = JS_FALLBACK_CJS_OBJECT_FUNCTION_PATTERN;
     const moduleExportsObject = /module\.exports\s*=\s*\{([^}]*)\}/su;
+    const capturedCommonJsFunctionAt = (exportedAs, propertyIndex) => {
+        const root = tree?.rootNode;
+        if (!root || propertyIndex < 0 || propertyIndex >= source.length)
+            return undefined;
+        let node = root.descendantForIndex(propertyIndex, propertyIndex + 1);
+        while (node && node !== root && node.type !== "assignment_expression" && node.type !== "pair") {
+            node = node.parent;
+        }
+        if (!node || node === root)
+            return undefined;
+        const value = node.childForFieldName(node.type === "pair" ? "value" : "right");
+        if (!value)
+            return undefined;
+        const headerEnd = value.childForFieldName("body")?.startIndex ?? value.endIndex;
+        // A native function export points into this RHS header, not at an earlier same-named local.
+        return exports.find((entry) => {
+            if (entry.type !== "local" || entry.exportedAs !== exportedAs || entry.target.file !== file)
+                return false;
+            if (entry.target.kind !== SymbolKind.Function)
+                return false;
+            const start = entry.target.range.start.index;
+            return start !== undefined && start >= value.startIndex && start < headerEnd;
+        });
+    };
+    const appendCommonJsFunction = (exportedAs, propertyIndex, moduleValue = false) => {
+        const docstring = leadingDocstringAt(propertyIndex);
+        const existing = capturedCommonJsFunctionAt(exportedAs, propertyIndex);
+        if (existing) {
+            if (docstring && !existing.target.docstring)
+                existing.target.docstring = docstring;
+            return;
+        }
+        if (moduleValue && exports.some((entry) => entry.type === "local" && entry.mechanism === "cjs-module-value")) {
+            return;
+        }
+        let line = 1;
+        let lineStart = 0;
+        for (let offset = 0; offset < propertyIndex; offset++) {
+            if (source.charCodeAt(offset) === 10) {
+                line++;
+                lineStart = offset + 1;
+            }
+        }
+        const start = { line, column: propertyIndex - lineStart + 1, index: propertyIndex };
+        const end = { ...start, column: start.column + exportedAs.length, index: propertyIndex + exportedAs.length };
+        const target = { file, localName: exportedAs, kind: SymbolKind.Function, range: { start, end } };
+        if (docstring)
+            target.docstring = docstring;
+        locals.push(target);
+        if (moduleValue) {
+            exports.push({ type: "local", exportedAs, target, mechanism: "cjs-module-value" });
+        }
+        else {
+            exports.push({ type: "local", exportedAs, target });
+        }
+    };
     let match;
     while ((match = reDecl.exec(maskedSource))) {
         const name = match[1];
@@ -203,6 +447,7 @@ function appendJsLikeRegexFallbackExports(file, source, locals, exports) {
                     type: "local",
                     exportedAs: "default",
                     target: { ...local, kind: SymbolKind.Default },
+                    mechanism: "ts-export-assignment",
                 });
             }
         }
@@ -263,20 +508,97 @@ function appendJsLikeRegexFallbackExports(file, source, locals, exports) {
     }
     while ((match = reCjsFn.exec(maskedSource))) {
         const exportedAs = match[1];
-        let local = locals.find((def) => def.localName === exportedAs);
-        if (!local) {
-            const idx = match.index + match[0].indexOf(exportedAs);
-            const pos = { line: 1, column: 1, index: idx };
-            local = {
+        const propertyIndex = match.index + match[0].indexOf(exportedAs);
+        appendCommonJsFunction(exportedAs, propertyIndex);
+    }
+    while ((match = reCjsModuleFn.exec(maskedSource))) {
+        const propertyIndex = match.index + match[0].indexOf("exports");
+        appendCommonJsFunction("exports", propertyIndex, true);
+    }
+    let identifierMatch = reCjsModuleIdentifier.exec(maskedSource);
+    if (identifierMatch && !exports.some((entry) => entry.type === "local" && entry.exportedAs === "default")) {
+        const identifierAssignments = [identifierMatch];
+        while ((identifierMatch = reCjsModuleIdentifier.exec(maskedSource)))
+            identifierAssignments.push(identifierMatch);
+        // Only a single module-scope declaration can prove the value behind module.exports.
+        // The comments/strings/regex mask preserves offsets while keeping nested declarations out.
+        const scopeSource = maskJsLikeCommentsStringsAndRegex(source);
+        let scanIndex = 0;
+        let scanLine = 1;
+        let lastLineBreak = -1;
+        let scopeDepth = 0;
+        const depthAt = (index) => {
+            while (scanIndex < index) {
+                const ch = scopeSource[scanIndex++];
+                if (ch === "{")
+                    scopeDepth++;
+                if (ch === "\n") {
+                    scanLine++;
+                    lastLineBreak = scanIndex - 1;
+                }
+                if (ch === "}")
+                    scopeDepth--;
+            }
+            return scopeDepth;
+        };
+        const declarations = new Map();
+        const valueNames = new Set(identifierAssignments.map((assignment) => assignment[1]));
+        let declarationMatch;
+        while ((declarationMatch = reTopLevelLocal.exec(scopeSource))) {
+            const name = declarationMatch[2];
+            if (!valueNames.has(name))
+                continue;
+            const startIndex = declarationMatch.index + declarationMatch[0].lastIndexOf(name);
+            if (depthAt(startIndex))
+                continue;
+            const declaration = declarationMatch[1];
+            let kind = SymbolKind.Variable;
+            if (declaration.endsWith("function"))
+                kind = SymbolKind.Function;
+            if (declaration.endsWith("class"))
+                kind = SymbolKind.Class;
+            const start = { line: scanLine, column: startIndex - lastLineBreak, index: startIndex };
+            const local = locals.find((def) => def.localName === name && def.range.start.index === startIndex) ?? {
                 file,
-                localName: exportedAs,
-                kind: SymbolKind.Function,
-                range: { start: pos, end: pos },
+                localName: name,
+                kind,
+                range: { start, end: { ...start, column: start.column + name.length, index: startIndex + name.length } },
             };
-            locals.push(local);
+            const namedDeclarations = declarations.get(name) ?? [];
+            const docstring = leadingDocstringAt(startIndex);
+            if (docstring && !local.docstring)
+                local.docstring = docstring;
+            namedDeclarations.push(local);
+            declarations.set(name, namedDeclarations);
         }
-        if (!exports.some((entry) => entry.type === "local" && entry.exportedAs === exportedAs)) {
-            exports.push({ type: "local", exportedAs, target: local });
+        scanIndex = 0;
+        scopeDepth = 0;
+        const provenValue = (assignment) => {
+            const name = assignment[1];
+            const rhsIndex = assignment.index + assignment[0].lastIndexOf(name);
+            if (depthAt(rhsIndex))
+                return undefined;
+            // A line break before .method, [key] or a call still belongs to the RHS.
+            let afterRhs = rhsIndex + name.length;
+            while (/\s/u.test(maskedSource[afterRhs] ?? ""))
+                afterRhs++;
+            if (maskedSource[afterRhs] === "." || maskedSource[afterRhs] === "[" || maskedSource[afterRhs] === "(") {
+                return undefined;
+            }
+            const candidates = declarations.get(name);
+            return candidates?.length === 1 ? candidates[0] : undefined;
+        };
+        // As in the native path, a reassigned module.exports has no single proven value.
+        const selected = identifierAssignments.length === 1 ? provenValue(identifierAssignments[0]) : undefined;
+        if (selected) {
+            if (!locals.includes(selected))
+                locals.push(selected);
+            exports.push({
+                type: "local",
+                exportedAs: "default",
+                target: { ...selected, kind: SymbolKind.Default },
+                mechanism: "cjs-module-value",
+            });
         }
     }
     const moduleExportsObjMatch = moduleExportsObject.exec(maskedSource);
@@ -284,24 +606,12 @@ function appendJsLikeRegexFallbackExports(file, source, locals, exports) {
         return;
     }
     const objContent = moduleExportsObjMatch[1];
+    const objectStart = moduleExportsObjMatch.index + moduleExportsObjMatch[0].indexOf("{") + 1;
     let objectMatch;
     while ((objectMatch = reCjsObjFn.exec(objContent))) {
         const exportedAs = objectMatch[1];
-        let local = locals.find((def) => def.localName === exportedAs);
-        if (!local) {
-            const idx = moduleExportsObjMatch.index + moduleExportsObjMatch[0].indexOf(exportedAs);
-            const pos = { line: 1, column: 1, index: idx };
-            local = {
-                file,
-                localName: exportedAs,
-                kind: SymbolKind.Function,
-                range: { start: pos, end: pos },
-            };
-            locals.push(local);
-        }
-        if (!exports.some((entry) => entry.type === "local" && entry.exportedAs === exportedAs)) {
-            exports.push({ type: "local", exportedAs, target: local });
-        }
+        const propertyIndex = objectStart + objectMatch.index + objectMatch[0].indexOf(exportedAs);
+        appendCommonJsFunction(exportedAs, propertyIndex);
     }
 }
 export function collectLocalsAndExportsFromSource(file, source, support, imports = [], opts) {
@@ -406,6 +716,11 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
         };
         if (node && isTypeMemberDeclaration(node))
             base.isMember = true;
+        if (support.id === "c" && node) {
+            const tagRole = cTagRole(node);
+            if (tagRole)
+                base.cTag = tagRole;
+        }
         if (docstring)
             base.docstring = docstring;
         if (lineSpan)
@@ -437,6 +752,22 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
         }
         return tree;
     };
+    const leadingDocstringAt = (index) => {
+        const root = ensureTree()?.rootNode;
+        if (!root || index < 0 || index >= source.length)
+            return undefined;
+        let node = root.descendantForIndex(index, index + 1);
+        if (node === root)
+            return undefined;
+        // Comments attach to the assignment statement or object member, not its function expression.
+        while (node.parent &&
+            node.parent.type !== "program" &&
+            node.parent.type !== "statement_block" &&
+            node.parent.type !== "object") {
+            node = node.parent;
+        }
+        return extractLeadingDocstring(node);
+    };
     // Lazily build once: converts every native capture's UTF-8 byte offsets to UTF-16
     // string indexes in O(1) per capture instead of rescanning the source per offset.
     // `ensureTree()` builds the same map internally when native mode is active, so route
@@ -522,6 +853,13 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
                             }
                         }
                     }
+                    else if (node && phpPropertyPromotionParameter(node)) {
+                        const promoted = phpConstructorPromotedVariable(node, source);
+                        if (promoted) {
+                            pushLocal(sliceText(promoted, source), SymbolKind.Variable, toRange(promoted), promoted);
+                            capturedLocals = true;
+                        }
+                    }
                     else {
                         pushLocal(capture.text, classifyLocalCapture(node), nativeRange, node);
                     }
@@ -536,12 +874,13 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
             return false;
         }
     };
+    let scopeIndexForExports;
     const usedQueryLocals = extractLocalsFromNativeQueries();
     if (!usedQueryLocals) {
         const scopeTree = ensureTree();
         if (scopeTree) {
-            const scopeIdx = buildScopeIndexFromSource(file, source, support, imports, { tree: scopeTree });
-            for (const b of scopeIdx.all) {
+            scopeIndexForExports = buildScopeIndexFromSource(file, source, support, imports, { tree: scopeTree });
+            for (const b of scopeIndexForExports.all) {
                 if (!b.def)
                     continue;
                 const kind = bindingKindToSymbolKind(b.kind);
@@ -622,12 +961,27 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
             const range = rangeFromNativeCapture(capture, ensureByteIndexMap());
             return treeForEnrichment.rootNode.descendantForIndex(range.start.index ?? 0, range.end.index ?? 0) ?? undefined;
         };
+        const localVisibleAtCapture = (capture) => {
+            const node = nodeForCapture(capture);
+            if (!node || !treeForEnrichment)
+                return undefined;
+            scopeIndexForExports ??= buildScopeIndexFromSource(file, source, support, imports, { tree: treeForEnrichment });
+            const binding = findClosestScopeBinding(scopeIndexForExports, capture.text, node, support);
+            const definition = binding?.def;
+            if (!definition)
+                return undefined;
+            return locals.find((local) => local.localName === binding.name &&
+                local.range.start.index === definition.start.index &&
+                local.range.end.index === definition.end.index);
+        };
         const defaultDeclarationNameNode = (node) => {
             if (!node)
                 return undefined;
             return (node.childForFieldName("name") ?? node.childForFieldName("declaration")?.childForFieldName("name") ?? undefined);
         };
         const hasDefaultExport = () => exports.some((entry) => entry.type === "local" && entry.exportedAs === "default");
+        // A second `module.exports = X` makes the required value depend on control flow.
+        let cjsModuleValueSeen = false;
         const excludedCaptures = [];
         for (const match of matches) {
             for (const capture of match.captures) {
@@ -800,6 +1154,25 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
                 });
                 continue;
             }
+            if (map["cjs_module_value"]) {
+                if (cjsModuleValueSeen) {
+                    const previous = exports.findIndex((entry) => entry.type === "local" && entry.exportedAs === "default" && entry.mechanism === "cjs-module-value");
+                    if (previous >= 0)
+                        exports.splice(previous, 1);
+                    continue;
+                }
+                cjsModuleValueSeen = true;
+                const local = localVisibleAtCapture(map["cjs_module_value"]);
+                if (local && !hasDefaultExport()) {
+                    exports.push({
+                        type: "local",
+                        exportedAs: "default",
+                        target: { ...local, kind: SymbolKind.Default },
+                        mechanism: "cjs-module-value",
+                    });
+                }
+                continue;
+            }
             if (map["cjs_shorthand"]) {
                 const nameText = map["cjs_shorthand"].text;
                 const local = locals.find((def) => def.localName === nameText);
@@ -823,9 +1196,19 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
             if (map["cjs_export_name"] && map["cjs_fn"]) {
                 const exportedAs = map["cjs_export_name"].text;
                 const fnNode = nodeForCapture(map["cjs_fn"]);
-                const sym = buildSymbolDef(exportedAs, SymbolKind.Function, rangeFromNativeCapture(map["cjs_fn"], ensureByteIndexMap()), fnNode);
-                locals.push(sym);
-                exports.push({ type: "local", exportedAs, target: sym });
+                const nameNode = fnNode?.childForFieldName("name");
+                const range = nameNode ? toRange(nameNode) : rangeFromNativeCapture(map["cjs_fn"], ensureByteIndexMap());
+                const existing = locals.find((def) => def.localName === exportedAs && def.range.start.index === range.start.index);
+                const sym = existing ?? buildSymbolDef(exportedAs, SymbolKind.Function, range, nameNode ?? fnNode);
+                if (!existing)
+                    locals.push(sym);
+                const directModuleValue = exportedAs === "exports" && !!map["mod"] && !map["prop"];
+                exports.push({
+                    type: "local",
+                    exportedAs,
+                    target: sym,
+                    ...(directModuleValue ? { mechanism: "cjs-module-value" } : {}),
+                });
                 continue;
             }
             if (map["default"]) {
@@ -875,6 +1258,7 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
                         type: "local",
                         exportedAs: "default",
                         target: { ...local, kind: SymbolKind.Default },
+                        mechanism: "ts-export-assignment",
                     });
                 }
                 continue;
@@ -886,20 +1270,56 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
                 const visibilityNameNode = nodeForCapture(nameCapture);
                 if (visibilityNameNode && !isExportedDeclaration(support.id, visibilityNameNode))
                     continue;
-                const nameText = map["declarator"]
-                    ? declaratorCaptureName(nameCapture, nodeForCapture(nameCapture))
-                    : nameCapture.text;
+                let nameText = nameCapture.text;
+                let nameRange = rangeFromNativeCapture(nameCapture, ensureByteIndexMap());
+                if (map["declarator"]) {
+                    const namedNode = declaratorNameNode(visibilityNameNode);
+                    if (namedNode) {
+                        nameText = namedNode.text;
+                        nameRange = toRange(namedNode);
+                    }
+                    else {
+                        const extracted = cDeclaratorDeclaredName(nameCapture.text);
+                        if (!extracted)
+                            continue;
+                        nameText = extracted.name;
+                        const captureStart = nameRange.start.index ?? 0;
+                        nameRange = rangeFromOffsets(captureStart + extracted.start, captureStart + extracted.end);
+                    }
+                }
                 if (!nameText)
                     continue;
-                const local = locals.find((def) => def.localName === nameText);
+                const local = locals.find((def) => def.localName === nameText &&
+                    def.range.start.index === nameRange.start.index &&
+                    def.range.end.index === nameRange.end.index) ?? locals.find((def) => def.localName === nameText);
                 if (local) {
                     const isDefaultExport = /^\s*export\s+default\b/.test(stmtText);
+                    const qualifiedExportName = () => {
+                        if (!visibilityNameNode)
+                            return nameText;
+                        if (support.id === "cpp")
+                            return cppQualifiedExportName(visibilityNameNode, source, nameText);
+                        if (support.id === "ruby")
+                            return rubyQualifiedExportName(visibilityNameNode, source, nameText);
+                        return nameText;
+                    };
+                    const exportedName = qualifiedExportName();
                     if (!isDefaultExport) {
                         exports.push({
                             type: "local",
-                            exportedAs: nameText,
+                            exportedAs: exportedName,
                             target: local,
                         });
+                        if (support.id === "cpp" && visibilityNameNode && exportedName !== nameText) {
+                            const visibleAs = cppQualifiedExportName(visibilityNameNode, source, nameText, true);
+                            if (visibleAs !== exportedName) {
+                                exports.push({
+                                    type: "local",
+                                    exportedAs: visibleAs,
+                                    target: local,
+                                });
+                            }
+                        }
                     }
                     if (isDefaultExport && !hasDefaultExport()) {
                         exports.push({
@@ -950,12 +1370,97 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
                 throw error;
         }
     }
+    if (support.id === "cpp") {
+        const treeForUsingDeclarations = ensureTree();
+        if (treeForUsingDeclarations) {
+            const callableExports = new Map();
+            let retainedCount = 0;
+            for (const entry of exports) {
+                if (entry.type === "local" && entry.target.kind === SymbolKind.Function) {
+                    const { start, end } = entry.target.range;
+                    const nameNode = treeForUsingDeclarations.rootNode.descendantForPosition({ row: start.line - 1, column: start.column - 1 }, { row: end.line - 1, column: end.column - 1 });
+                    const shape = cppCallableShapeForNode(nameNode);
+                    if (shape) {
+                        const key = `${entry.exportedAs}\0${shape.signature}`;
+                        const isDefinition = cppCallableIsDefinition(nameNode);
+                        const existing = callableExports.get(key);
+                        if (existing) {
+                            if (isDefinition && !existing.isDefinition) {
+                                exports[existing.index] = entry;
+                                existing.isDefinition = true;
+                            }
+                            continue;
+                        }
+                        callableExports.set(key, { index: retainedCount, isDefinition });
+                    }
+                }
+                exports[retainedCount++] = entry;
+            }
+            exports.length = retainedCount;
+        }
+        const visitUsingDeclaration = (node) => {
+            if (support.exportScopeBlockers.some((blocker) => matchesExportScopeBlocker(node, blocker)))
+                return;
+            if (node.type === "using_declaration") {
+                const qualified = node.namedChildren.find((child) => child.type === "qualified_identifier") ??
+                    node.namedChildren
+                        .flatMap((child) => child.namedChildren)
+                        .find((child) => child.type === "qualified_identifier");
+                if (qualified) {
+                    const importedSegments = cppQualifiedNameSegments(qualified, source);
+                    const importedName = importedSegments.join("::");
+                    const localName = importedSegments.at(-1);
+                    if (!localName)
+                        return;
+                    const exportedName = cppQualifiedExportName(node, source, localName);
+                    const exportedNames = [exportedName];
+                    if (exportedName !== localName) {
+                        const visibleAs = cppQualifiedExportName(node, source, localName, true);
+                        if (visibleAs !== exportedName)
+                            exportedNames.push(visibleAs);
+                    }
+                    const targets = exports.filter((entry) => entry.type === "local" && entry.exportedAs === importedName);
+                    for (const exportedAs of exportedNames) {
+                        // Included declarations are not available during per-file extraction.
+                        // Retain the qualified target for resolution against the completed index.
+                        for (const imp of imports) {
+                            if (imp.kind !== "star" || typeof imp.resolved !== "string")
+                                continue;
+                            exports.push({
+                                type: "reexport",
+                                exportedAs,
+                                fromModule: imp.resolved,
+                                sourceSpecifier: importedName,
+                            });
+                        }
+                        for (const target of targets) {
+                            if (exports.some((entry) => entry.type === "local" &&
+                                entry.exportedAs === exportedAs &&
+                                entry.target.range.start.index === target.target.range.start.index)) {
+                                continue;
+                            }
+                            exports.push({
+                                type: "local",
+                                exportedAs,
+                                target: target.target,
+                            });
+                        }
+                    }
+                }
+                return;
+            }
+            for (const child of node.namedChildren)
+                visitUsingDeclaration(child);
+        };
+        if (treeForUsingDeclarations)
+            visitUsingDeclaration(treeForUsingDeclarations.rootNode);
+    }
     // The native query does not cover CommonJS member assignments and some
     // re-export forms. Always run the deduplicating fallback for JS-like files:
     // source-form probes are too error-prone to risk silently dropping exports.
     const isJsLike = support.id === "ts" || support.id === "tsx" || support.id === "js";
     if (isJsLike) {
-        appendJsLikeRegexFallbackExports(file, source, locals, exports);
+        appendJsLikeRegexFallbackExports(file, source, locals, exports, leadingDocstringAt, ensureTree());
     }
     if (support.id === "python") {
         for (const binding of imports) {
@@ -1040,6 +1545,12 @@ export function collectLocalsAndExportsFromSource(file, source, support, imports
             }
         }
     }
-    return { file, exports: dedupeExportEntries(exports), imports, locals };
+    return {
+        file,
+        exports: dedupeExportEntries(collapseTypeScriptCallableExports(exports, ensureTree(), support.id), support.id),
+        imports,
+        locals,
+        ...(tree && DOCSTRING_CAPTURE_LANGUAGES.has(support.id) ? { docstringsChecked: true } : {}),
+    };
 }
 //# sourceMappingURL=locals-and-exports.js.map