gitnexus 1.6.6-rc.21 → 1.6.6-rc.22

package/dist/core/ingestion/languages/cpp/conversion-rank.d.ts

@@ -1,31 +1,29 @@
 /**
- * C++ conversion-rank scoring for overload resolution (#1578).
+ * C++ conversion-rank scoring for overload resolution (#1578, #1637).
  *
- * Operates on **normalized** type strings (output of
- * `normalizeCppParamType` in `arity-metadata.ts`). After normalization:
- *   - int/long/short/unsigned → 'int'
- *   - float/double → 'double'
- *   - char → 'char', bool → 'bool'
- *
- * Because the normalizer collapses promotion pairs (int↔long,
- * float↔double) to the same string, those promotions are invisible at
- * this layer — they appear as exact matches (rank 0).
+ * Operates on normalized type strings (output of `normalizeCppParamType`
+ * in `arity-metadata.ts`) plus optional shape sidecars from #1630.
+ * Normalization intentionally collapses cv/ref/pointer spelling for stable
+ * graph IDs, so pointer/nullptr rules must consult `ParameterTypeClass`.
  *
  * Post-normalization ranking:
- *   - rank 0 — exact (same normalized type)
- *   - rank 1 — integral promotion (char→int, bool→int)
- *   - rank 2 — standard arithmetic conversion (int↔double, char→double,
- *              bool→double)
- *   - Infinity — mismatch (string↔int, user types, pointers, etc.)
+ *   - rank 0: exact (same normalized type)
+ *   - rank 1: integral promotion (char -> int, bool -> int)
+ *   - rank 2: standard conversion (arithmetic, nullptr -> T*, T* -> bool,
+ *             T* -> void*)
+ *   - rank 3: nullptr -> bool (kept worse than nullptr -> T*)
+ *   - rank 4: ellipsis conversion (worst viable)
+ *   - Infinity: mismatch (string -> int, user types, unsupported shapes)
  *
- * This function is intentionally C++-specific (issue #1578 pitfall:
- * keep conversion-rank tables out of shared overload-narrowing). Other
- * languages may define their own `ConversionRankFn` in the future.
+ * This function is intentionally C++-specific. Other languages may define
+ * their own `ConversionRankFn` in the future.
  */
+import type { ParameterTypeClass } from '../../../../_shared/index.js';
 /**
  * Return the conversion rank from `argType` to `paramType`.
  *
- * @returns 0 for exact match, 1 for integral promotion (char/bool→int),
- *          2 for standard arithmetic conversion, Infinity for mismatch.
+ * @returns 0 for exact match, 1 for integral promotion, 2 for standard
+ *          conversion, 3 for nullptr -> bool, 4 for ellipsis, Infinity
+ *          for mismatch.
  */
-export declare function cppConversionRank(argType: string, paramType: string): number;
+export declare function cppConversionRank(argType: string, paramType: string, argTypeClass?: ParameterTypeClass, paramTypeClass?: ParameterTypeClass): number;

package/dist/core/ingestion/languages/cpp/conversion-rank.js

@@ -1,30 +1,26 @@
 /**
- * C++ conversion-rank scoring for overload resolution (#1578).
+ * C++ conversion-rank scoring for overload resolution (#1578, #1637).
  *
- * Operates on **normalized** type strings (output of
- * `normalizeCppParamType` in `arity-metadata.ts`). After normalization:
- *   - int/long/short/unsigned → 'int'
- *   - float/double → 'double'
- *   - char → 'char', bool → 'bool'
- *
- * Because the normalizer collapses promotion pairs (int↔long,
- * float↔double) to the same string, those promotions are invisible at
- * this layer — they appear as exact matches (rank 0).
+ * Operates on normalized type strings (output of `normalizeCppParamType`
+ * in `arity-metadata.ts`) plus optional shape sidecars from #1630.
+ * Normalization intentionally collapses cv/ref/pointer spelling for stable
+ * graph IDs, so pointer/nullptr rules must consult `ParameterTypeClass`.
  *
  * Post-normalization ranking:
- *   - rank 0 — exact (same normalized type)
- *   - rank 1 — integral promotion (char→int, bool→int)
- *   - rank 2 — standard arithmetic conversion (int↔double, char→double,
- *              bool→double)
- *   - Infinity — mismatch (string↔int, user types, pointers, etc.)
+ *   - rank 0: exact (same normalized type)
+ *   - rank 1: integral promotion (char -> int, bool -> int)
+ *   - rank 2: standard conversion (arithmetic, nullptr -> T*, T* -> bool,
+ *             T* -> void*)
+ *   - rank 3: nullptr -> bool (kept worse than nullptr -> T*)
+ *   - rank 4: ellipsis conversion (worst viable)
+ *   - Infinity: mismatch (string -> int, user types, unsupported shapes)
  *
- * This function is intentionally C++-specific (issue #1578 pitfall:
- * keep conversion-rank tables out of shared overload-narrowing). Other
- * languages may define their own `ConversionRankFn` in the future.
+ * This function is intentionally C++-specific. Other languages may define
+ * their own `ConversionRankFn` in the future.
  */
 /** Set of normalized arithmetic types that support implicit conversion. */
 const ARITHMETIC = new Set(['int', 'double', 'char', 'bool']);
-/** Integral promotion targets: char→int and bool→int are rank 1. */
+/** Integral promotion targets: char -> int and bool -> int are rank 1. */
 const INTEGRAL_PROMOTION = new Map([
     ['char', 'int'],
     ['bool', 'int'],
@@ -32,16 +28,38 @@ const INTEGRAL_PROMOTION = new Map([
 /**
  * Return the conversion rank from `argType` to `paramType`.
  *
- * @returns 0 for exact match, 1 for integral promotion (char/bool→int),
- *          2 for standard arithmetic conversion, Infinity for mismatch.
+ * @returns 0 for exact match, 1 for integral promotion, 2 for standard
+ *          conversion, 3 for nullptr -> bool, 4 for ellipsis, Infinity
+ *          for mismatch.
  */
-export function cppConversionRank(argType, paramType) {
-    if (argType === paramType)
-        return 0;
-    // Integral promotions: char→int, bool→int (ISO C++ [conv.prom])
+export function cppConversionRank(argType, paramType, argTypeClass, paramTypeClass) {
+    if (argType === paramType) {
+        return exactShapeCompatible(argTypeClass, paramTypeClass) ? 0 : Infinity;
+    }
+    if (paramType === '...')
+        return 4;
     if (INTEGRAL_PROMOTION.get(argType) === paramType)
         return 1;
     if (ARITHMETIC.has(argType) && ARITHMETIC.has(paramType))
         return 2;
+    if (argType === 'null' && isPointer(paramTypeClass))
+        return 2;
+    if (argType === 'null' && paramType === 'bool')
+        return 3;
+    if (isPointer(argTypeClass) && paramType === 'bool')
+        return 2;
+    if (isPointer(argTypeClass) && isPointer(paramTypeClass) && paramType === 'void')
+        return 2;
     return Infinity;
 }
+function isPointer(typeClass) {
+    return typeClass?.indirection === 'pointer' && typeClass.pointerDepth > 0;
+}
+function exactShapeCompatible(argTypeClass, paramTypeClass) {
+    if (argTypeClass === undefined || paramTypeClass === undefined)
+        return true;
+    if (argTypeClass.indirection === 'unknown' || paramTypeClass.indirection === 'unknown') {
+        return true;
+    }
+    return isPointer(argTypeClass) === isPointer(paramTypeClass);
+}

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -202,7 +202,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         callerScope: site.inScope,
                         scopes,
                     })
-                    : undefined, site.argumentTypes, options.conversionRankFn);
+                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn);
             }
             if (fnDef === undefined)
                 continue;
@@ -261,7 +261,7 @@ function buildGlobalCallableIndex(scopes) {
     }
     return out;
 }
-function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, conversionRankFn) {
+function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn) {
     const scopeDefs = [];
     const scopeSeen = new Set();
     for (const def of globalCallablesBySimpleName.get(name) ?? []) {
@@ -300,6 +300,7 @@ function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, call
     // disambiguate (e.g., `f(int)` vs `f(double)` called with `f(2.5)`).
     if (scopeDefs.length > 1) {
         const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, {
+            argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
         });
         if (narrowed.length === 1)
@@ -340,6 +341,7 @@ function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, call
     // Same argument-type + conversion-rank narrowing for the model pool.
     if (defs.length > 1) {
         const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, {
+            argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
         });
         if (narrowed.length === 1)

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -37,7 +37,7 @@
  *       (monotonicity).
  *   5. Empty input returns empty output.
  */
-import type { ArityVerdict, Callsite, ConstraintContext, SymbolDefinition } from '../../../../_shared/index.js';
+import type { ArityVerdict, Callsite, ConstraintContext, ParameterTypeClass, SymbolDefinition } from '../../../../_shared/index.js';
 /**
  * Per-slot conversion-rank function. Returns a numeric cost for
  * converting `argType` to `paramType`:
@@ -49,7 +49,7 @@ import type { ArityVerdict, Callsite, ConstraintContext, SymbolDefinition } from
  * Each language provides its own implementation. The function operates
  * on normalized type strings (output of the language's type normalizer).
  */
-export type ConversionRankFn = (argType: string, paramType: string) => number;
+export type ConversionRankFn = (argType: string, paramType: string, argTypeClass?: ParameterTypeClass, paramTypeClass?: ParameterTypeClass) => number;
 /**
  * Optional hook bundle for narrowing extension points. Threaded in
  * from `pickOverload` / `pickImplicitThisOverload` so per-language

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -81,8 +81,9 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             for (let i = 0; i < argTypes.length && i < params.length; i++) {
                 if (argTypes[i] === '')
                     continue;
-                if (argTypes[i] !== params[i])
+                if (!exactTypeSlotMatches(argTypes[i], params[i], hookCtx?.argumentTypeClasses?.[i], d.parameterTypeClasses?.[i])) {
                     return false;
+                }
             }
             return true;
         });
@@ -97,7 +98,7 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             // are returned; multiple survivors are genuinely ambiguous. When
             // ranking also yields empty, fall through to the arity-filtered
             // `candidates` set — matches pre-#1606 behavior.
-            const ranked = rankByConversion(candidates, argTypes, hookCtx.conversionRankFn);
+            const ranked = rankByConversion(candidates, argTypes, hookCtx.conversionRankFn, hookCtx.argumentTypeClasses);
             if (ranked.length > 0)
                 result = ranked;
         }
@@ -134,6 +135,22 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
     }
     return result;
 }
+function exactTypeSlotMatches(argType, paramType, argTypeClass, paramTypeClass) {
+    if (argType !== paramType)
+        return false;
+    // C++ normalizes away pointer markers (`int*` -> `int`). When both sides
+    // provide shape sidecars, do not let that collapse make `int` exactly match
+    // `int*`. Unknown sidecar evidence preserves the previous string-only path.
+    if (argTypeClass === undefined || paramTypeClass === undefined)
+        return true;
+    if (argTypeClass.indirection === 'unknown' || paramTypeClass.indirection === 'unknown') {
+        return true;
+    }
+    return isPointerShape(argTypeClass) === isPointerShape(paramTypeClass);
+}
+function isPointerShape(typeClass) {
+    return typeClass.indirection === 'pointer' && typeClass.pointerDepth > 0;
+}
 /**
  * Pairwise dominance comparison (ISO C++ [over.ics.rank]).
  *
@@ -146,7 +163,7 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
  * Candidates with at least one `Infinity`-ranked slot (incompatible
  * type) are excluded before pairwise comparison begins.
  */
-function rankByConversion(candidates, argTypes, rankFn) {
+function rankByConversion(candidates, argTypes, rankFn, argTypeClasses) {
     // Step 1: compute per-slot ranks and exclude non-viable candidates.
     const viable = [];
     for (const d of candidates) {
@@ -155,12 +172,17 @@ function rankByConversion(candidates, argTypes, rankFn) {
             continue;
         const ranks = [];
         let ok = true;
-        for (let i = 0; i < argTypes.length && i < params.length; i++) {
+        for (let i = 0; i < argTypes.length; i++) {
+            const paramType = parameterTypeAt(params, i);
+            if (paramType === undefined) {
+                ok = false;
+                break;
+            }
             if (argTypes[i] === '') {
                 ranks.push(0); // unknown arg → any-match (rank 0)
                 continue;
             }
-            const r = rankFn(argTypes[i], params[i]);
+            const r = rankFn(argTypes[i], paramType, argTypeClasses?.[i], parameterTypeClassAt(d.parameterTypeClasses, i));
             if (!isFinite(r)) {
                 ok = false;
                 break;
@@ -190,6 +212,18 @@ function rankByConversion(candidates, argTypes, rankFn) {
     }
     return viable.filter((_, idx) => !dominated.has(idx)).map((v) => v.def);
 }
+function parameterTypeAt(params, argIndex) {
+    if (argIndex < params.length)
+        return params[argIndex];
+    return params[params.length - 1] === '...' ? '...' : undefined;
+}
+function parameterTypeClassAt(params, argIndex) {
+    if (params === undefined)
+        return undefined;
+    if (argIndex < params.length)
+        return params[argIndex];
+    return params[params.length - 1]?.base === '...' ? params[params.length - 1] : undefined;
+}
 /**
  * Compare two per-slot rank vectors.
  * Returns  -1 if `a` dominates `b` (not worse everywhere, better somewhere),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.6-rc.21",
+  "version": "1.6.6-rc.22",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",