cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/cpp/file-local-linkage.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markFileLocal = markFileLocal;
+exports.isFileLocal = isFileLocal;
+exports.markCppAnonymousNamespaceRange = markCppAnonymousNamespaceRange;
+exports.isCppAnonymousNamespaceScope = isCppAnonymousNamespaceScope;
+exports.collectCppFileLocalSideChannel = collectCppFileLocalSideChannel;
+exports.applyCppFileLocalSideChannel = applyCppFileLocalSideChannel;
+exports.clearFileLocalNames = clearFileLocalNames;
+exports.populateCppAnonymousNamespaceScopes = populateCppAnonymousNamespaceScopes;
+exports.populateCppNonGloballyVisible = populateCppNonGloballyVisible;
+exports.isCppDefGloballyVisible = isCppDefGloballyVisible;
+exports.expandCppWildcardNames = expandCppWildcardNames;
+const inline_namespaces_js_1 = require("./inline-namespaces.js");
+/**
+ * Per-file set of symbol names with file-local linkage.
+ * In C++ there are two sources of file-local linkage:
+ *   1. `static` storage class (same as C)
+ *   2. Anonymous namespace (`namespace { ... }`)
+ *
+ * Populated during `emitCppScopeCaptures` and consumed by
+ * `expandCppWildcardNames` to exclude file-local symbols from
+ * cross-file wildcard import visibility.
+ *
+ * NOTE: module-level state, single-process-single-repo use only.
+ * Call `clearFileLocalNames()` at the start of each resolution pass.
+ *
+ * Key: filePath, Value: Set of file-local symbol names.
+ */
+const fileLocalNames = new Map();
+/**
+ * Per-file set of `SymbolDefinition.nodeId`s that are NOT visible by
+ * unqualified lookup from outside the file — class-owned methods/fields
+ * and namespace-nested symbols. Populated by `populateCppNonGloballyVisible`
+ * during the per-file `populateOwners` hook; consumed by
+ * `isCppDefGloballyVisible` from both `expandCppWildcardNames` (wildcard
+ * propagation) and the global free-call fallback's `isFileLocalDef` hook.
+ *
+ * Tracked per filePath rather than as a single global set so cross-file
+ * lookup correctly compares the candidate's owning file's non-visible
+ * set without leaking across pipeline invocations (the global free-call
+ * fallback checks `def.filePath !== callerFilePath` and then asks "is
+ * this def visible from outside its own file?" — that's exactly what
+ * this set encodes).
+ */
+const nonGloballyVisibleNodeIds = new Map();
+/**
+ * Per-file set of source-range keys identifying `namespace { ... }` blocks.
+ * Resolved to `ScopeId`s in `populateCppAnonymousNamespaceScopes` and
+ * consumed via `isCppAnonymousNamespaceScope`.
+ *
+ * Anonymous namespaces have file-local linkage but, unlike `static`, their
+ * members propagate to any TU that `#include`s the declaring file — each
+ * including TU gets its own internal-linkage copy. So for wildcard import
+ * expansion (`expandCppWildcardNames`) we treat anonymous-namespace owned
+ * defs as if declared at the enclosing scope. Cross-file unqualified
+ * lookup that does NOT go through `#include` is still blocked by the
+ * `isFileLocal` mark recorded on the def's name.
+ */
+const anonymousNamespaceRangesByFile = new Map();
+const anonymousNamespaceScopeIds = new Set();
+function rangeKey(r) {
+    return `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
+}
+/** Record a symbol name as file-local (static or anonymous namespace). */
+function markFileLocal(filePath, name) {
+    let names = fileLocalNames.get(filePath);
+    if (names === undefined) {
+        names = new Set();
+        fileLocalNames.set(filePath, names);
+    }
+    names.add(name);
+}
+/** Check whether a symbol name has file-local linkage in the given file. */
+function isFileLocal(filePath, name) {
+    return fileLocalNames.get(filePath)?.has(name) ?? false;
+}
+/** Capture-time: record an anonymous `namespace_definition` source range. */
+function markCppAnonymousNamespaceRange(filePath, range) {
+    let set = anonymousNamespaceRangesByFile.get(filePath);
+    if (set === undefined) {
+        set = new Set();
+        anonymousNamespaceRangesByFile.set(filePath, set);
+    }
+    set.add(rangeKey(range));
+}
+/** Predicate consumed by `populateCppNonGloballyVisible` and
+ *  `expandCppWildcardNames` to exempt anonymous-namespace scopes from
+ *  the cross-file unqualified-lookup exclusion that applies to ordinary
+ *  named namespaces. */
+function isCppAnonymousNamespaceScope(scopeId) {
+    return anonymousNamespaceScopeIds.has(scopeId);
+}
+/** Snapshot this file's file-local-linkage capture state for the side-channel. */
+function collectCppFileLocalSideChannel(filePath) {
+    const names = fileLocalNames.get(filePath);
+    const anon = anonymousNamespaceRangesByFile.get(filePath);
+    return {
+        fileLocalNames: names === undefined ? [] : [...names],
+        anonymousNamespaceRanges: anon === undefined ? [] : [...anon],
+    };
+}
+/** Restore this file's file-local-linkage capture state from the side-channel. */
+function applyCppFileLocalSideChannel(filePath, data) {
+    for (const name of data.fileLocalNames)
+        markFileLocal(filePath, name);
+    if (data.anonymousNamespaceRanges.length > 0) {
+        let set = anonymousNamespaceRangesByFile.get(filePath);
+        if (set === undefined) {
+            set = new Set();
+            anonymousNamespaceRangesByFile.set(filePath, set);
+        }
+        for (const r of data.anonymousNamespaceRanges)
+            set.add(r);
+    }
+}
+/** Clear tracked file-local names (call at start of each resolution pass). */
+function clearFileLocalNames() {
+    fileLocalNames.clear();
+    nonGloballyVisibleNodeIds.clear();
+    anonymousNamespaceRangesByFile.clear();
+    anonymousNamespaceScopeIds.clear();
+}
+/** Resolve recorded anonymous-namespace source ranges to `ScopeId`s.
+ *  Must run inside `populateOwners` BEFORE `populateCppNonGloballyVisible`
+ *  consults the resolved set. */
+function populateCppAnonymousNamespaceScopes(parsed) {
+    const ranges = anonymousNamespaceRangesByFile.get(parsed.filePath);
+    if (ranges === undefined || ranges.size === 0)
+        return;
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Namespace')
+            continue;
+        if (ranges.has(rangeKey(scope.range))) {
+            anonymousNamespaceScopeIds.add(scope.id);
+        }
+    }
+}
+/**
+ * Populate per-file "not globally visible" nodeIds by walking the parsed
+ * file's scopes. Run as part of the `populateOwners` hook so every C++
+ * scope is reflected before any cross-file resolution pass consults the
+ * set.
+ *
+ * A def is "not globally visible" when its nearest structurally enclosing
+ * scope is a `Namespace` or `Class` — those require qualification
+ * (`ns::name`, `Class::method`) for cross-file unqualified lookup.
+ * Module-scoped defs remain globally visible.
+ */
+function populateCppNonGloballyVisible(parsed) {
+    let set = nonGloballyVisibleNodeIds.get(parsed.filePath);
+    if (set === undefined) {
+        set = new Set();
+        nonGloballyVisibleNodeIds.set(parsed.filePath, set);
+    }
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Namespace' && scope.kind !== 'Class')
+            continue;
+        // Inline namespaces (`inline namespace v1 { ... }`) propagate their
+        // members to the enclosing namespace's unqualified-lookup scope per
+        // ISO C++ `[namespace.def]/p4`. Skip them here so cross-file
+        // unqualified lookup can still see their callable defs.
+        if (scope.kind === 'Namespace' && (0, inline_namespaces_js_1.isCppInlineNamespaceScope)(scope.id))
+            continue;
+        // Anonymous namespaces give internal linkage but their contents are
+        // visible at the enclosing scope within the same TU and propagate to
+        // any TU that `#include`s the declaring file. The `isFileLocal` mark
+        // (recorded on the def's name in this file) still blocks cross-file
+        // unqualified lookup that does not go through #include, so dropping
+        // the structural visibility exclusion here is safe.
+        if (scope.kind === 'Namespace' && anonymousNamespaceScopeIds.has(scope.id))
+            continue;
+        for (const def of scope.ownedDefs) {
+            set.add(def.nodeId);
+        }
+    }
+}
+/**
+ * Check whether a def is visible by unqualified lookup from outside its
+ * own file. Returns `false` for class-owned and namespace-nested defs.
+ *
+ * Used by the global free-call fallback's `isFileLocalDef` hook (which
+ * historically meant "static / anonymous-namespace" but semantically
+ * stands for "logically invisible cross-file"). Including class methods
+ * and namespace members under the same negative answer fixes the leak
+ * where unqualified `save()` resolved to `User::save` through a shared
+ * workspace registry walk.
+ */
+function isCppDefGloballyVisible(filePath, nodeId) {
+    return nonGloballyVisibleNodeIds.get(filePath)?.has(nodeId) !== true;
+}
+/**
+ * Return the names visible through a C++ wildcard import (`#include` or
+ * `using namespace`).
+ *
+ * ## Contract
+ *
+ * C++ unqualified name lookup only sees names at the importer's enclosing
+ * scope. Class members and namespace-nested symbols are NOT visible by
+ * unqualified lookup from a free function in an including TU — they must
+ * be reached via `Class::method`, `ns::name`, or a working `using`
+ * declaration. The filter below enforces that contract for header
+ * propagation: only defs whose nearest enclosing scope is the header's
+ * `Module` scope are emitted as wildcard-binding names.
+ *
+ * ## Why scope-aware and not predicate-on-qualifiedName
+ *
+ * A naive `def.qualifiedName.indexOf('.') === -1` check is unreliable
+ * because `populateClassOwnedMembers`
+ * (`cgraph/src/core/ingestion/scope-resolution/scope/walkers.ts`)
+ * only dot-qualifies `qualifiedName` for `Class` scopes. Namespace-nested
+ * defs (`namespace ns { void foo(); }`) arrive in `localDefs` with
+ * `qualifiedName === 'foo'` and `ownerId === undefined`, indistinguishable
+ * from a top-level free function. The structural truth lives in
+ * `Scope.ownedDefs`: each scope lists what it structurally owns; the
+ * Module scope owns only top-level symbols. We look the def up by
+ * `nodeId` against the scope tree to identify its owning kind.
+ *
+ * ## `localDefs` consumer survey (recorded for future maintainers)
+ *
+ * Other consumers of `ParsedFile.localDefs` were audited at the time
+ * this filter was introduced (see PR #1520 / plan
+ * `docs/plans/2026-05-12-002-fix-cpp-resolver-followups-plan.md`):
+ *
+ *   - `finalize-orchestrator.ts:113,163` — flattens defs into a workspace
+ *     registry keyed by `ownerId` + `qualifiedName`; class-owned and
+ *     namespace-owned symbols are registered under their owner, not as
+ *     unqualified names. Not a leak surface.
+ *   - `csharp/namespace-siblings.ts:307`, `go/expand-wildcards.ts:86`,
+ *     `php/scope-resolver.ts:141,151`, `c/static-linkage.ts:51` — other
+ *     languages' own wildcard / sibling expansions. Each owns its own
+ *     visibility contract.
+ *   - `receiver-bound-calls.ts:99`, `reconcile-ownership.ts:66,119`,
+ *     `mro.ts:61` — keyed by `ownerId` for member lookup, never used
+ *     as unqualified bindings.
+ *   - `go/interface-impls.ts:40,53`, `go/package-siblings.ts:41` — Go-
+ *     specific, sibling-package scoped.
+ *
+ * No other consumer treats `localDefs` as a flat unqualified-binding
+ * set the way this function did before the fix. If a future consumer
+ * does, mirror this filter or harden registration so class/namespace
+ * members never enter `localDefs` unqualified.
+ */
+/**
+ * Per-pass memo: `moduleScope` → owning `ParsedFile`, keyed on the
+ * `parsedFiles` array identity. The shared finalize Phase-4 loop calls
+ * `expandsWildcardTo` (→ this) ONCE PER RESOLVED `#include` edge with the same
+ * `parsedFiles` reference; the old `parsedFiles.find(...)` was therefore O(F)
+ * per edge → O(R·F) overall (at kernel scale the ~25–30k `.h` headers are
+ * classified C++, so this fires hard — the C twin in `c/static-linkage.ts`).
+ * Building the lookup once collapses it to O(R+F). `WeakMap`-keyed so it is
+ * reclaimed with the pass (no cross-pass staleness; mirrors
+ * {@link clearFileLocalNames}).
+ */
+const moduleScopeIndexByPass = new WeakMap();
+function moduleScopeIndex(parsedFiles) {
+    let index = moduleScopeIndexByPass.get(parsedFiles);
+    if (index === undefined) {
+        index = new Map();
+        // First-wins to preserve `Array.find` semantics (returns the first match).
+        for (const p of parsedFiles) {
+            if (!index.has(p.moduleScope))
+                index.set(p.moduleScope, p);
+        }
+        moduleScopeIndexByPass.set(parsedFiles, index);
+    }
+    return index;
+}
+function expandCppWildcardNames(targetModuleScope, parsedFiles) {
+    const target = moduleScopeIndex(parsedFiles).get(targetModuleScope);
+    if (target === undefined)
+        return [];
+    // Build nodeId → owning Scope map from the structural scope tree.
+    // `Scope.ownedDefs` is the canonical source of structural ownership;
+    // `localDefs` is its flattened union, which is why the original code
+    // leaked: walking only `localDefs` discards the owning-scope context.
+    const ownerScopeByNodeId = new Map();
+    for (const scope of target.scopes) {
+        for (const ownedDef of scope.ownedDefs) {
+            ownerScopeByNodeId.set(ownedDef.nodeId, scope);
+        }
+    }
+    const seen = new Set();
+    const names = [];
+    for (const def of target.localDefs) {
+        // Defense-in-depth: class methods carry a non-undefined ownerId after
+        // `populateClassOwnedMembers` runs. Skip them outright.
+        if (def.ownerId !== undefined)
+            continue;
+        // Structural visibility check: exclude defs whose owning scope is a
+        // Namespace or Class — these require qualification (`ns::name`,
+        // `Class::method`) and are NOT reachable by unqualified lookup in an
+        // including TU. When the owning scope is unknown we default to
+        // include (preserves prior behavior for any def whose structural
+        // ownership wasn't recorded in `Scope.ownedDefs`).
+        //
+        // Anonymous namespaces are exempt: their members propagate to the
+        // enclosing scope of any TU that #includes the declaring file (each
+        // including TU gets its own internal-linkage copy per ISO C++).
+        const ownerScope = ownerScopeByNodeId.get(def.nodeId);
+        const ownerIsAnonymousNamespace = ownerScope !== undefined &&
+            ownerScope.kind === 'Namespace' &&
+            anonymousNamespaceScopeIds.has(ownerScope.id);
+        if (ownerScope !== undefined &&
+            !ownerIsAnonymousNamespace &&
+            (ownerScope.kind === 'Namespace' || ownerScope.kind === 'Class')) {
+            continue;
+        }
+        const name = simpleName(def);
+        if (name === '')
+            continue;
+        // Same exemption for the `isFileLocal` mark — anonymous-namespace
+        // names are recorded as file-local to suppress the global free-call
+        // fallback's cross-file leak, but they MUST still propagate through
+        // wildcard import expansion to including TUs.
+        if (!ownerIsAnonymousNamespace && isFileLocal(target.filePath, name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}
+function simpleName(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/header-scan.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanCppHeaderFiles = scanCppHeaderFiles;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/** C++ header extensions to scan for in the workspace. */
+const HEADER_EXTENSIONS = new Set(['.h', '.hpp', '.hxx', '.hh', '.cuh']);
+/**
+ * Walk `repoPath` recursively and return relative paths of all C++ header files.
+ * Used by `loadResolutionConfig` so the C++ resolver can resolve `#include`
+ * targets that live in header files.
+ *
+ * Scans for: .h, .hpp, .hxx, .hh, .cuh
+ */
+function scanCppHeaderFiles(repoPath) {
+    const headers = new Set();
+    walk(repoPath, repoPath, headers);
+    return headers;
+}
+function walk(dir, root, out) {
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true, encoding: 'utf8' });
+    }
+    catch {
+        return; // permission denied, etc.
+    }
+    for (const entry of entries) {
+        const name = entry.name;
+        const full = (0, path_1.join)(dir, name);
+        if (entry.isDirectory()) {
+            if (name === 'node_modules' ||
+                name === '.git' ||
+                name === 'vendor' ||
+                name === 'dist' ||
+                name === 'build' ||
+                name === 'out' ||
+                name === 'target' ||
+                name === '_build' ||
+                name === '.next' ||
+                name.startsWith('cmake-build')) {
+                continue;
+            }
+            walk(full, root, out);
+        }
+        else if (entry.isFile()) {
+            const ext = name.slice(name.lastIndexOf('.'));
+            if (HEADER_EXTENSIONS.has(ext)) {
+                out.add((0, path_1.relative)(root, full).replace(/\\/g, '/'));
+            }
+        }
+    }
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/import-decomposer.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitCppInclude = splitCppInclude;
+exports.splitCppUsingDecl = splitCppUsingDecl;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+/**
+ * Decompose a `preproc_include` node into a CaptureMatch with structured
+ * import captures. C++ #include maps to a wildcard import (all symbols
+ * from the header are visible). Identical to C's splitCInclude.
+ *
+ * Only literal include paths are emitted as import sources:
+ *   #include <map>      → system_lib_string
+ *   #include "User.h"   → string_literal
+ * A computed include like `#include HEADER_MACRO` carries an `identifier`
+ * path node (the macro name, not a header path); we skip it so it never
+ * becomes a garbage literal import source (issue #1919 F5).
+ */
+function splitCppInclude(node) {
+    const pathNode = node.childForFieldName?.('path') ?? null;
+    if (pathNode === null) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child === null)
+                continue;
+            if (child.type === 'string_literal' || child.type === 'system_lib_string') {
+                return buildIncludeCapture(node, child);
+            }
+        }
+        return null;
+    }
+    return buildIncludeCapture(node, pathNode);
+}
+function buildIncludeCapture(node, pathNode) {
+    // Skip computed includes (`#include MACRO`) — the path is an `identifier`,
+    // not a literal header path. Emitting it would create a garbage import.
+    if (pathNode.type !== 'string_literal' && pathNode.type !== 'system_lib_string') {
+        return null;
+    }
+    let raw;
+    if (pathNode.type === 'string_literal') {
+        const content = pathNode.namedChildren.find((c) => c.type === 'string_content');
+        raw = content?.text ?? pathNode.text.replace(/^"|"$/g, '');
+    }
+    else {
+        raw = pathNode.text;
+        if (raw.startsWith('<') && raw.endsWith('>')) {
+            raw = raw.slice(1, -1);
+        }
+    }
+    const isSystem = pathNode.type === 'system_lib_string';
+    const result = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', node),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', node, 'wildcard'),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', node, raw),
+    };
+    if (isSystem) {
+        result['@import.system'] = (0, ast_helpers_js_1.syntheticCapture)('@import.system', node, 'true');
+    }
+    return result;
+}
+/**
+ * Decompose a `using_declaration` node into a CaptureMatch.
+ *
+ * tree-sitter-cpp produces:
+ *   using namespace std;  → using_declaration { "using", "namespace", identifier("std"), ";" }
+ *   using std::vector;    → using_declaration { "using", qualified_identifier("std::vector"), ";" }
+ *
+ * The first form is a wildcard import (all names from namespace).
+ * The second form is a named import (single symbol).
+ */
+function splitCppUsingDecl(node) {
+    if (node.type !== 'using_declaration')
+        return null;
+    // A class-scope `using Base::member;` changes the derived class's member
+    // lookup set; it is not a namespace import. The C++ member-lookup sidecar
+    // captures it separately, so suppress import decomposition here.
+    for (let parent = node.parent; parent !== null; parent = parent.parent) {
+        if (parent.type === 'class_specifier' || parent.type === 'struct_specifier')
+            return null;
+    }
+    // Check for "namespace" keyword among anonymous children
+    let hasNamespaceKeyword = false;
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child !== null && !child.isNamed && child.text === 'namespace') {
+            hasNamespaceKeyword = true;
+            break;
+        }
+    }
+    if (hasNamespaceKeyword) {
+        // using namespace <name>;
+        // The namespace name can be an identifier or qualified_identifier
+        let namespaceName = null;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child === null)
+                continue;
+            if (child.type === 'identifier' || child.type === 'qualified_identifier') {
+                namespaceName = child.text;
+                break;
+            }
+        }
+        if (namespaceName === null)
+            return null;
+        return {
+            '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', node),
+            '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', node, 'wildcard'),
+            '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', node, namespaceName),
+            '@import.using-namespace': (0, ast_helpers_js_1.syntheticCapture)('@import.using-namespace', node, 'true'),
+        };
+    }
+    // using <qualified_identifier>;  (e.g. using std::vector)
+    let qualId = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child !== null && child.type === 'qualified_identifier') {
+            qualId = child;
+            break;
+        }
+    }
+    if (qualId === null)
+        return null;
+    // Extract the imported name (last identifier) and source (namespace part)
+    const nameNode = qualId.childForFieldName?.('name') ?? null;
+    const scopeNode = qualId.childForFieldName?.('scope') ?? null;
+    const importedName = nameNode?.text ?? qualId.text.split('::').pop() ?? '';
+    const source = scopeNode?.text ?? qualId.text.replace(new RegExp('::' + importedName + '$'), '');
+    return {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', node),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', node, 'named'),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', node, source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', node, importedName),
+    };
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/import-target.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCppImportTarget = resolveCppImportTarget;
+const import_target_js_1 = require("../c/import-target.js");
+/**
+ * Resolve a C++ #include path to a file in the workspace.
+ * C++ #include path resolution is identical to C:
+ *   1. Same-directory sibling (relative lookup)
+ *   2. Exact match
+ *   3. Suffix match with depth + lexicographic tiebreak
+ *
+ * Re-exports the C implementation since the #include semantics are shared.
+ */
+function resolveCppImportTarget(targetRaw, fromFile, allFilePaths) {
+    return (0, import_target_js_1.resolveCImportTarget)(targetRaw, fromFile, allFilePaths);
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCppCaptureSideChannel = exports.collectCppCaptureSideChannel = exports.expandCppWildcardNames = exports.clearFileLocalNames = exports.isFileLocal = exports.markFileLocal = exports.resolveCppImportTarget = exports.cppReceiverBinding = exports.cppImportOwningScope = exports.cppBindingScopeFor = exports.cppMergeBindings = exports.cppArityCompatibility = exports.splitCppUsingDecl = exports.splitCppInclude = exports.normalizeCppTypeName = exports.interpretCppTypeBinding = exports.interpretCppImport = exports.emitCppScopeCaptures = void 0;
+/**
+ * C++ scope-resolution hooks (RFC #909 Ring 3).
+ */
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitCppScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitCppScopeCaptures; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretCppImport", { enumerable: true, get: function () { return interpret_js_1.interpretCppImport; } });
+Object.defineProperty(exports, "interpretCppTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretCppTypeBinding; } });
+Object.defineProperty(exports, "normalizeCppTypeName", { enumerable: true, get: function () { return interpret_js_1.normalizeCppTypeName; } });
+var import_decomposer_js_1 = require("./import-decomposer.js");
+Object.defineProperty(exports, "splitCppInclude", { enumerable: true, get: function () { return import_decomposer_js_1.splitCppInclude; } });
+Object.defineProperty(exports, "splitCppUsingDecl", { enumerable: true, get: function () { return import_decomposer_js_1.splitCppUsingDecl; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "cppArityCompatibility", { enumerable: true, get: function () { return arity_js_1.cppArityCompatibility; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "cppMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.cppMergeBindings; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "cppBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.cppBindingScopeFor; } });
+Object.defineProperty(exports, "cppImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.cppImportOwningScope; } });
+Object.defineProperty(exports, "cppReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.cppReceiverBinding; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveCppImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveCppImportTarget; } });
+var file_local_linkage_js_1 = require("./file-local-linkage.js");
+Object.defineProperty(exports, "markFileLocal", { enumerable: true, get: function () { return file_local_linkage_js_1.markFileLocal; } });
+Object.defineProperty(exports, "isFileLocal", { enumerable: true, get: function () { return file_local_linkage_js_1.isFileLocal; } });
+Object.defineProperty(exports, "clearFileLocalNames", { enumerable: true, get: function () { return file_local_linkage_js_1.clearFileLocalNames; } });
+Object.defineProperty(exports, "expandCppWildcardNames", { enumerable: true, get: function () { return file_local_linkage_js_1.expandCppWildcardNames; } });
+var capture_side_channel_js_1 = require("./capture-side-channel.js");
+Object.defineProperty(exports, "collectCppCaptureSideChannel", { enumerable: true, get: function () { return capture_side_channel_js_1.collectCppCaptureSideChannel; } });
+Object.defineProperty(exports, "applyCppCaptureSideChannel", { enumerable: true, get: function () { return capture_side_channel_js_1.applyCppCaptureSideChannel; } });