gitnexus 1.6.5-rc.8 → 1.6.5

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

@@ -0,0 +1,13 @@
+import { resolveCImportTarget } from '../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.
+ */
+export function resolveCppImportTarget(targetRaw, fromFile, allFilePaths) {
+    return resolveCImportTarget(targetRaw, fromFile, allFilePaths);
+}

package/dist/core/ingestion/languages/cpp/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * C++ scope-resolution hooks (RFC #909 Ring 3).
+ */
+export { emitCppScopeCaptures } from './captures.js';
+export { interpretCppImport, interpretCppTypeBinding, normalizeCppTypeName } from './interpret.js';
+export { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
+export { cppArityCompatibility } from './arity.js';
+export { cppMergeBindings } from './merge-bindings.js';
+export { cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding } from './simple-hooks.js';
+export { resolveCppImportTarget } from './import-target.js';
+export { markFileLocal, isFileLocal, clearFileLocalNames, expandCppWildcardNames, } from './file-local-linkage.js';

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

@@ -0,0 +1,11 @@
+/**
+ * C++ scope-resolution hooks (RFC #909 Ring 3).
+ */
+export { emitCppScopeCaptures } from './captures.js';
+export { interpretCppImport, interpretCppTypeBinding, normalizeCppTypeName } from './interpret.js';
+export { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
+export { cppArityCompatibility } from './arity.js';
+export { cppMergeBindings } from './merge-bindings.js';
+export { cppBindingScopeFor, cppImportOwningScope, cppReceiverBinding } from './simple-hooks.js';
+export { resolveCppImportTarget } from './import-target.js';
+export { markFileLocal, isFileLocal, clearFileLocalNames, expandCppWildcardNames, } from './file-local-linkage.js';

package/dist/core/ingestion/languages/cpp/inline-namespaces.d.ts

@@ -0,0 +1,67 @@
+/**
+ * C++ inline namespace support (U5 of plan 2026-05-13-001).
+ *
+ * `inline namespace v1 { void foo(); }` has two ISO C++ semantics that
+ * GitNexus must model:
+ *
+ *   1. **Transitive unqualified visibility.** Names declared in an inline
+ *      namespace are reachable by unqualified lookup from the enclosing
+ *      namespace's scope, as if they were declared directly there.
+ *      `populateCppNonGloballyVisible` (file-local-linkage.ts) treats
+ *      inline-namespace members as globally visible for cross-file
+ *      unqualified lookup.
+ *
+ *   2. **Transitive qualified visibility.** `outer::foo()` resolves to
+ *      `outer::v1::foo()` when `v1` is inline. The qualified-namespace
+ *      receiver resolver (`resolveCppQualifiedNamespaceMember`) walks
+ *      inline-namespace children transitively when collecting candidates.
+ *
+ * State lifecycle: capture-time `markCppInlineNamespaceRange` records each
+ * inline namespace's source range; `populateCppInlineNamespaceScopes`
+ * resolves ranges to `ScopeId`s during `populateOwners`. Cleared via
+ * `clearCppInlineNamespaces`, called from `clearFileLocalNames`.
+ *
+ * STL idiom this enables: `std::__1::vector` (libc++) and `std::__cxx11`
+ * (libstdc++) are inline namespaces of `std`. With this support,
+ * `std::vector` qualified calls resolve to the inline-namespace
+ * declaration transparently.
+ */
+import type { ParsedFile, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+interface RangeKey {
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly endLine: number;
+    readonly endCol: number;
+}
+/** Capture-time: record a namespace_definition's range as inline.
+ *  Called from `emitCppScopeCaptures` when the tree-sitter AST shows an
+ *  `inline` keyword child on `namespace_definition`. */
+export declare function markCppInlineNamespaceRange(filePath: string, range: RangeKey): void;
+/** Clear all inline-namespace state. Called from `clearFileLocalNames`. */
+export declare function clearCppInlineNamespaces(): void;
+/** Resolve captured ranges to actual ScopeIds by matching scope ranges
+ *  against the inline-namespace ranges recorded for this file. Run from
+ *  the cpp resolver's `populateOwners` hook so the per-pipeline Set is
+ *  populated before any resolution pass consults it. */
+export declare function populateCppInlineNamespaceScopes(parsed: ParsedFile): void;
+/** Predicate consumed by `populateCppNonGloballyVisible` to exempt
+ *  inline-namespace members from cross-file unqualified-lookup
+ *  exclusion (they remain reachable as if declared at the enclosing
+ *  namespace's level). */
+export declare function isCppInlineNamespaceScope(scopeId: ScopeId): boolean;
+/**
+ * Walk every parsed file looking for a Namespace scope whose qualified
+ * name matches `receiverName`, collect its callable ownedDefs matching
+ * `memberName`, transitively descending into any inline-namespace
+ * children (since they're members of the enclosing namespace under ISO
+ * C++).
+ *
+ * Returns the most specific (innermost) match — for `outer::foo()`
+ * where `inline namespace v1` declares `foo`, returns `v1::foo`. When
+ * multiple inline-namespace children declare the same name, ISO C++
+ * leaves the call ambiguous; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
+ */
+export declare function resolveCppQualifiedNamespaceMember(receiverName: string, memberName: string, parsedFiles: readonly ParsedFile[], _scopes: ScopeResolutionIndexes): SymbolDefinition | 'ambiguous' | undefined;
+export {};

package/dist/core/ingestion/languages/cpp/inline-namespaces.js

@@ -0,0 +1,176 @@
+/**
+ * C++ inline namespace support (U5 of plan 2026-05-13-001).
+ *
+ * `inline namespace v1 { void foo(); }` has two ISO C++ semantics that
+ * GitNexus must model:
+ *
+ *   1. **Transitive unqualified visibility.** Names declared in an inline
+ *      namespace are reachable by unqualified lookup from the enclosing
+ *      namespace's scope, as if they were declared directly there.
+ *      `populateCppNonGloballyVisible` (file-local-linkage.ts) treats
+ *      inline-namespace members as globally visible for cross-file
+ *      unqualified lookup.
+ *
+ *   2. **Transitive qualified visibility.** `outer::foo()` resolves to
+ *      `outer::v1::foo()` when `v1` is inline. The qualified-namespace
+ *      receiver resolver (`resolveCppQualifiedNamespaceMember`) walks
+ *      inline-namespace children transitively when collecting candidates.
+ *
+ * State lifecycle: capture-time `markCppInlineNamespaceRange` records each
+ * inline namespace's source range; `populateCppInlineNamespaceScopes`
+ * resolves ranges to `ScopeId`s during `populateOwners`. Cleared via
+ * `clearCppInlineNamespaces`, called from `clearFileLocalNames`.
+ *
+ * STL idiom this enables: `std::__1::vector` (libc++) and `std::__cxx11`
+ * (libstdc++) are inline namespaces of `std`. With this support,
+ * `std::vector` qualified calls resolve to the inline-namespace
+ * declaration transparently.
+ */
+import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
+const inlineNamespaceRangesByFile = new Map();
+const inlineNamespaceScopeIds = new Set();
+function rangeKey(r) {
+    return `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
+}
+/** Capture-time: record a namespace_definition's range as inline.
+ *  Called from `emitCppScopeCaptures` when the tree-sitter AST shows an
+ *  `inline` keyword child on `namespace_definition`. */
+export function markCppInlineNamespaceRange(filePath, range) {
+    let set = inlineNamespaceRangesByFile.get(filePath);
+    if (set === undefined) {
+        set = new Set();
+        inlineNamespaceRangesByFile.set(filePath, set);
+    }
+    set.add(rangeKey(range));
+}
+/** Clear all inline-namespace state. Called from `clearFileLocalNames`. */
+export function clearCppInlineNamespaces() {
+    inlineNamespaceRangesByFile.clear();
+    inlineNamespaceScopeIds.clear();
+}
+/** Resolve captured ranges to actual ScopeIds by matching scope ranges
+ *  against the inline-namespace ranges recorded for this file. Run from
+ *  the cpp resolver's `populateOwners` hook so the per-pipeline Set is
+ *  populated before any resolution pass consults it. */
+export function populateCppInlineNamespaceScopes(parsed) {
+    const ranges = inlineNamespaceRangesByFile.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))) {
+            inlineNamespaceScopeIds.add(scope.id);
+        }
+    }
+}
+/** Predicate consumed by `populateCppNonGloballyVisible` to exempt
+ *  inline-namespace members from cross-file unqualified-lookup
+ *  exclusion (they remain reachable as if declared at the enclosing
+ *  namespace's level). */
+export function isCppInlineNamespaceScope(scopeId) {
+    return inlineNamespaceScopeIds.has(scopeId);
+}
+/**
+ * Walk every parsed file looking for a Namespace scope whose qualified
+ * name matches `receiverName`, collect its callable ownedDefs matching
+ * `memberName`, transitively descending into any inline-namespace
+ * children (since they're members of the enclosing namespace under ISO
+ * C++).
+ *
+ * Returns the most specific (innermost) match — for `outer::foo()`
+ * where `inline namespace v1` declares `foo`, returns `v1::foo`. When
+ * multiple inline-namespace children declare the same name, ISO C++
+ * leaves the call ambiguous; returns `'ambiguous'` so the caller
+ * suppresses edge emission rather than picking arbitrarily (#1564).
+ */
+export function resolveCppQualifiedNamespaceMember(receiverName, memberName, parsedFiles, _scopes) {
+    const allHits = [];
+    const seenNodeId = new Set();
+    for (const parsed of parsedFiles) {
+        const scopesById = new Map();
+        for (const sc of parsed.scopes)
+            scopesById.set(sc.id, sc);
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Namespace')
+                continue;
+            const nsDef = findNamespaceDefInScope(scope);
+            if (nsDef === undefined)
+                continue;
+            const nsName = nsDef.qualifiedName?.split('.').pop() ?? nsDef.qualifiedName ?? '';
+            if (nsName !== receiverName)
+                continue;
+            // Found a matching namespace scope in this file. Collect ALL
+            // members transitively through any inline-namespace children.
+            const hits = findMemberInNamespaceTransitive(scope, scopesById, memberName);
+            for (const hit of hits) {
+                if (seenNodeId.has(hit.nodeId))
+                    continue;
+                seenNodeId.add(hit.nodeId);
+                allHits.push(hit);
+            }
+        }
+    }
+    if (allHits.length === 0)
+        return undefined;
+    if (allHits.length === 1)
+        return allHits[0];
+    // Multi-candidate: the `resolveQualifiedReceiverMember` hook has no
+    // access to call-site arity or argument types, so
+    // `narrowOverloadCandidates` cannot actually narrow here — the call
+    // with `(allHits, undefined, undefined)` is effectively a pass-through.
+    // We retain it so that `isOverloadAmbiguousAfterNormalization` can
+    // still detect int/long-style normalization collisions on this path,
+    // but for any multi-hit case where candidates have genuinely distinct
+    // signatures (e.g. `foo(int)` vs `foo(double)` in different inline
+    // children), we conservatively suppress rather than pick arbitrarily.
+    // A future enhancement could thread call-site argument info through
+    // the `resolveQualifiedReceiverMember` contract to enable real
+    // narrowing here.
+    const narrowed = narrowOverloadCandidates(allHits, undefined, undefined);
+    if (narrowed.length === 1)
+        return narrowed[0];
+    if (narrowed.length === 0)
+        return undefined;
+    if (isOverloadAmbiguousAfterNormalization(narrowed, undefined))
+        return 'ambiguous';
+    // Multiple surviving candidates (distinct signatures) — conservative
+    // suppress because we lack call-site info to disambiguate.
+    return 'ambiguous';
+}
+/** Recursively search a namespace scope and any inline-namespace
+ *  descendants for callable defs with the given simple name. Non-inline
+ *  nested namespaces are NOT traversed — they require explicit
+ *  qualification (`outer::nested::foo`). Returns ALL matches so the
+ *  caller can detect same-name ambiguity across inline children (#1564). */
+function findMemberInNamespaceTransitive(scope, scopesById, memberName) {
+    const results = [];
+    // Check this scope's own ownedDefs first.
+    for (const def of scope.ownedDefs) {
+        if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
+            continue;
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        if (simple === memberName)
+            results.push(def);
+    }
+    // Descend into inline-namespace children.
+    for (const childScope of scopesById.values()) {
+        if (childScope.parent !== scope.id)
+            continue;
+        if (childScope.kind !== 'Namespace')
+            continue;
+        if (!inlineNamespaceScopeIds.has(childScope.id))
+            continue;
+        const childHits = findMemberInNamespaceTransitive(childScope, scopesById, memberName);
+        for (const hit of childHits)
+            results.push(hit);
+    }
+    return results;
+}
+function findNamespaceDefInScope(scope) {
+    for (const def of scope.ownedDefs) {
+        if (def.type === 'Namespace')
+            return def;
+    }
+    return undefined;
+}

package/dist/core/ingestion/languages/cpp/interpret.d.ts

@@ -0,0 +1,35 @@
+import type { CaptureMatch, ParsedImport, ParsedTypeBinding } from '../../../../_shared/index.js';
+/**
+ * Interpret a C++ import capture into a ParsedImport.
+ *
+ * C++ has three import forms:
+ *   1. #include "file.h"  → wildcard import (all symbols from header)
+ *   2. using namespace X; → wildcard import (all symbols from namespace X)
+ *   3. using X::name;     → named import (single symbol from namespace X)
+ *
+ * System headers (#include <...>) are not resolved to local files.
+ */
+export declare function interpretCppImport(captures: CaptureMatch): ParsedImport | null;
+/**
+ * Interpret a C++ type-binding capture into a ParsedTypeBinding.
+ *
+ * Source classification (strongest → weakest):
+ *   - `'parameter-annotation'` — function parameter type
+ *   - `'annotation'`          — explicit type declaration (`User user;`)
+ *   - `'assignment-inferred'` — typed init (`User user = ...`)
+ *   - `'constructor'`         — constructor call (`auto u = User(...)` / `User{}`)
+ *   - `'return'`              — function return type
+ *   - `'field'`               — class field type
+ *   - `'alias'`               — `auto x = existingVar`
+ */
+export declare function interpretCppTypeBinding(captures: CaptureMatch): ParsedTypeBinding | null;
+/**
+ * Normalize a C++ type name: strip pointer/array/reference syntax,
+ * qualifiers, while preserving template arguments for specialization-aware
+ * receiver binding (`List<User>` vs `List<Order>`).
+ *
+ * Keeping template arguments here allows receiver-bound fallback to match
+ * specialization-specific class defs first; non-template behavior is preserved
+ * by base-name fallback in resolveClassBindingForName.
+ */
+export declare function normalizeCppTypeName(text: string): string;

package/dist/core/ingestion/languages/cpp/interpret.js

@@ -0,0 +1,113 @@
+/**
+ * Interpret a C++ import capture into a ParsedImport.
+ *
+ * C++ has three import forms:
+ *   1. #include "file.h"  → wildcard import (all symbols from header)
+ *   2. using namespace X; → wildcard import (all symbols from namespace X)
+ *   3. using X::name;     → named import (single symbol from namespace X)
+ *
+ * System headers (#include <...>) are not resolved to local files.
+ */
+export function interpretCppImport(captures) {
+    const source = captures['@import.source']?.text;
+    if (source === undefined)
+        return null;
+    // System headers are not resolved to local files
+    if (captures['@import.system'] !== undefined)
+        return null;
+    const kind = captures['@import.kind']?.text;
+    if (kind === 'named') {
+        // using X::name — named import
+        const importedName = captures['@import.name']?.text;
+        if (importedName === undefined)
+            return null;
+        return { kind: 'named', targetRaw: source, localName: importedName, importedName };
+    }
+    // #include or using namespace — wildcard import
+    return { kind: 'wildcard', targetRaw: source };
+}
+/**
+ * Interpret a C++ type-binding capture into a ParsedTypeBinding.
+ *
+ * Source classification (strongest → weakest):
+ *   - `'parameter-annotation'` — function parameter type
+ *   - `'annotation'`          — explicit type declaration (`User user;`)
+ *   - `'assignment-inferred'` — typed init (`User user = ...`)
+ *   - `'constructor'`         — constructor call (`auto u = User(...)` / `User{}`)
+ *   - `'return'`              — function return type
+ *   - `'field'`               — class field type
+ *   - `'alias'`               — `auto x = existingVar`
+ */
+export function interpretCppTypeBinding(captures) {
+    const name = captures['@type-binding.name']?.text;
+    const type = captures['@type-binding.type']?.text;
+    if (name === undefined || type === undefined)
+        return null;
+    let source = 'annotation';
+    if (captures['@type-binding.parameter'] !== undefined) {
+        source = 'parameter-annotation';
+    }
+    else if (captures['@type-binding.constructor'] !== undefined) {
+        source = 'constructor-inferred';
+    }
+    else if (captures['@type-binding.return'] !== undefined) {
+        source = 'return-annotation';
+    }
+    else if (captures['@type-binding.field'] !== undefined) {
+        // Field types are structurally equivalent to annotations — the type
+        // is explicitly written, not inferred.
+        source = 'annotation';
+    }
+    else if (captures['@type-binding.member-access'] !== undefined) {
+        // auto addr = user.address — the type is inferred from the member access.
+        // Synthesize a dotted rawName ("receiver.field") so compound-receiver
+        // can resolve the chain: look up receiver's class, then field's type.
+        const receiver = captures['@type-binding.member-access-receiver']?.text;
+        if (receiver !== undefined) {
+            return { boundName: name, rawTypeName: `${receiver}.${type}`, source: 'assignment-inferred' };
+        }
+        source = 'assignment-inferred';
+    }
+    else if (captures['@type-binding.alias'] !== undefined) {
+        // auto alias = existingVar — the type is inferred from the RHS variable.
+        source = 'assignment-inferred';
+    }
+    else if (captures['@type-binding.assignment'] !== undefined) {
+        source = 'assignment-inferred';
+    }
+    else if (captures['@type-binding.annotation'] !== undefined) {
+        source = 'annotation';
+    }
+    return { boundName: name, rawTypeName: normalizeCppTypeName(type), source };
+}
+/**
+ * Normalize a C++ type name: strip pointer/array/reference syntax,
+ * qualifiers, while preserving template arguments for specialization-aware
+ * receiver binding (`List<User>` vs `List<Order>`).
+ *
+ * Keeping template arguments here allows receiver-bound fallback to match
+ * specialization-specific class defs first; non-template behavior is preserved
+ * by base-name fallback in resolveClassBindingForName.
+ */
+export function normalizeCppTypeName(text) {
+    let t = text.trim();
+    // Strip const, volatile, restrict, static, extern, inline, mutable, constexpr
+    t = t
+        .replace(/\b(const|volatile|restrict|static|extern|inline|mutable|constexpr|consteval)\b/g, '')
+        .trim();
+    // Strip pointer stars
+    while (t.endsWith('*'))
+        t = t.slice(0, -1).trim();
+    while (t.startsWith('*'))
+        t = t.slice(1).trim();
+    // Strip reference markers
+    while (t.endsWith('&'))
+        t = t.slice(0, -1).trim();
+    // Strip array brackets
+    t = t.replace(/\[.*?\]/g, '').trim();
+    // Strip struct/union/enum/class prefixes
+    t = t.replace(/^(struct|union|enum|class)\s+/, '');
+    // Strip leading :: (global namespace qualifier)
+    t = t.replace(/^::/, '');
+    return t;
+}

package/dist/core/ingestion/languages/cpp/merge-bindings.d.ts

@@ -0,0 +1,13 @@
+import type { BindingRef } from '../../../../_shared/index.js';
+/**
+ * C++ merge bindings: first-wins by tier.
+ *
+ * C++ tier precedence:
+ *   local(0) > namespace(1) > import(2) > reexport(3) > wildcard(4)
+ *
+ * Unlike C (no namespaces), C++ uses the `namespace` tier for symbols
+ * brought in via `using namespace X;` that are then locally referenced.
+ * The tier ordering ensures local definitions shadow namespace imports,
+ * which in turn shadow wildcard #include imports.
+ */
+export declare function cppMergeBindings(existing: readonly BindingRef[], incoming: readonly BindingRef[], _scopeId: string): BindingRef[];

package/dist/core/ingestion/languages/cpp/merge-bindings.js

@@ -0,0 +1,29 @@
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+/**
+ * C++ merge bindings: first-wins by tier.
+ *
+ * C++ tier precedence:
+ *   local(0) > namespace(1) > import(2) > reexport(3) > wildcard(4)
+ *
+ * Unlike C (no namespaces), C++ uses the `namespace` tier for symbols
+ * brought in via `using namespace X;` that are then locally referenced.
+ * The tier ordering ensures local definitions shadow namespace imports,
+ * which in turn shadow wildcard #include imports.
+ */
+export function cppMergeBindings(existing, incoming, _scopeId) {
+    const seen = new Set();
+    return [...existing, ...incoming]
+        .sort((a, b) => (TIER[a.origin] ?? 99) - (TIER[b.origin] ?? 99) || a.def.nodeId.localeCompare(b.def.nodeId))
+        .filter((binding) => {
+        if (seen.has(binding.def.nodeId))
+            return false;
+        seen.add(binding.def.nodeId);
+        return true;
+    });
+}

package/dist/core/ingestion/languages/cpp/query.d.ts

@@ -0,0 +1,3 @@
+import Parser from 'tree-sitter';
+export declare function getCppParser(): Parser;
+export declare function getCppScopeQuery(): Parser.Query;