gitnexus 1.6.5-rc.48 → 1.6.5-rc.49

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

@@ -0,0 +1,31 @@
+/**
+ * C++ conversion-rank scoring for overload resolution (#1578).
+ *
+ * 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).
+ *
+ * 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.)
+ *
+ * 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.
+ */
+/**
+ * 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.
+ */
+export declare function cppConversionRank(argType: string, paramType: string): number;

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

@@ -0,0 +1,47 @@
+/**
+ * C++ conversion-rank scoring for overload resolution (#1578).
+ *
+ * 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).
+ *
+ * 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.)
+ *
+ * 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.
+ */
+/** 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. */
+const INTEGRAL_PROMOTION = new Map([
+    ['char', 'int'],
+    ['bool', 'int'],
+]);
+/**
+ * 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.
+ */
+export function cppConversionRank(argType, paramType) {
+    if (argType === paramType)
+        return 0;
+    // Integral promotions: char→int, bool→int (ISO C++ [conv.prom])
+    if (INTEGRAL_PROMOTION.get(argType) === paramType)
+        return 1;
+    if (ARITHMETIC.has(argType) && ARITHMETIC.has(paramType))
+        return 2;
+    return Infinity;
+}

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -4,6 +4,7 @@ import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js
 import { populateClassOwnedMembers } from '../../scope-resolution/scope/walkers.js';
 import { cppProvider } from '../c-cpp.js';
 import { cppArityCompatibility } from './arity.js';
+import { cppConversionRank } from './conversion-rank.js';
 import { cppMergeBindings } from './merge-bindings.js';
 import { resolveCppImportTarget } from './import-target.js';
 import { scanCppHeaderFiles } from './header-scan.js';
@@ -140,6 +141,10 @@ export const cppScopeResolver = {
     propagatesReturnTypesAcrossImports: true,
     // C++ #include brings in all symbols — enable global free call fallback
     allowGlobalFreeCallFallback: true,
+    // C++ standard-conversion-sequence ranking for overload resolution (#1578).
+    // Disambiguates `f(int)` vs `f(double)` called with `f(2.5)` by scoring
+    // each candidate's conversion cost; exact match wins over standard conversion.
+    conversionRankFn: cppConversionRank,
     // Range-for element type inference: for (auto& user : users) → bind user to User
     populateRangeBindings: populateCppRangeBindings,
     // C++ method return-type bindings need to be visible from module scope

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -256,6 +256,7 @@ import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { LanguageProvider } from '../../language-provider.js';
 import { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { SemanticModel } from '../../model/semantic-model.js';
+import type { ConversionRankFn } from '../passes/overload-narrowing.js';
 /** A LinearizeStrategy receives the full ancestor map so C3-style
  *  algorithms (which need to merge each parent's MRO) can implement
  *  themselves. Python's depth-first first-seen only consumes
@@ -465,6 +466,19 @@ export interface ScopeResolver {
      * but is too loose as a default for strict module systems.
      */
     readonly allowGlobalFreeCallFallback?: boolean;
+    /**
+     * Optional per-slot conversion-rank function for overload resolution.
+     * When provided, `narrowOverloadCandidates` uses ranked scoring as a
+     * fallback when the exact-type filter produces no match. The function
+     * returns a numeric cost (0 = exact, 1 = promotion, 2 = standard
+     * conversion, Infinity = incompatible) for converting an argument
+     * type to a parameter type.
+     *
+     * The conversion-rank table is language-specific (issue #1578 pitfall:
+     * keep it out of shared overload-narrowing). C++ provides
+     * `cppConversionRank`; other languages define their own if needed.
+     */
+    readonly conversionRankFn?: ConversionRankFn;
     /**
      * Optional predicate to identify definitions with file-local linkage
      * (e.g. C `static` functions). When provided, `pickUniqueGlobalCallable`

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

@@ -22,6 +22,7 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
 import type { SemanticModel } from '../../model/semantic-model.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
+import { type ConversionRankFn } from './overload-narrowing.js';
 export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, _referenceIndex: {
     readonly bySourceScope: ReadonlyMap<ScopeId, readonly Reference[]>;
 }, handledSites: Set<string>, model: SemanticModel, workspaceIndex: WorkspaceResolutionIndex, options?: {
@@ -42,6 +43,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
             readonly startCol: number;
         };
     }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
+    readonly conversionRankFn?: ConversionRankFn;
 }): number;
 /** Walk up from the call-site scope to the enclosing class scope,
  *  pick a method member by name with overload narrowing on arity +
@@ -61,4 +63,4 @@ export declare function pickImplicitThisOverload(site: {
     readonly name: string;
     readonly arity?: number;
     readonly argumentTypes?: readonly string[];
-}, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel): SymbolDefinition | undefined;
+}, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, conversionRankFn?: ConversionRankFn): SymbolDefinition | undefined;

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

@@ -17,7 +17,7 @@
  * generalization plan.
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
-import { findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findClassBindingInScope, } from '../scope/walkers.js';
+import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findClassBindingInScope, } from '../scope/walkers.js';
 import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from './overload-narrowing.js';
 export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _referenceIndex, handledSites, model, workspaceIndex, options = {}) {
     let emitted = 0;
@@ -45,17 +45,48 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the same name in a single class, choose the best match by
             // arity + argument types.
             if (fnDef === undefined) {
-                fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model);
+                fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, options.conversionRankFn);
             }
+            // Scope-chain callable lookup. First-match preserves scope-chain
+            // precedence (local shadows import). When a conversion-rank function
+            // is available AND the binding scope contains multiple overloads,
+            // refine with `narrowOverloadCandidates` to pick the best overload
+            // by argument types (#1578). The first-match result is kept as a
+            // fallback when narrowing is indeterminate.
             if (fnDef === undefined) {
                 if (options.resolveAdlCandidates === undefined) {
+                    // Non-ADL path: first-match preserves scope-chain precedence
+                    // (local shadows import). When a conversion-rank function is
+                    // available AND the binding scope contains multiple overloads,
+                    // refine with narrowOverloadCandidates (#1578).
                     fnDef = findCallableBindingInScope(site.inScope, site.name, scopes);
+                    if (fnDef !== undefined && options.conversionRankFn !== undefined) {
+                        const allCallables = findAllCallableBindingsInScope(site.inScope, site.name, scopes);
+                        if (allCallables.length > 1) {
+                            const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, options.conversionRankFn);
+                            if (narrowed.length === 1) {
+                                fnDef = narrowed[0];
+                            }
+                            else if (narrowed.length > 1) {
+                                // Multiple survivors after conversion-rank scoring.
+                                // Suppress when all candidates share the same file (true
+                                // overloads) — mirrors ADL merged-candidate path behavior.
+                                // Cross-file candidates are shadowing; keep first-match.
+                                const sameFile = narrowed.every((d) => d.filePath === narrowed[0].filePath);
+                                if (sameFile) {
+                                    handledSites.add(`${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`);
+                                    continue;
+                                }
+                            }
+                            // narrowed.length === 0: keep the first-match fnDef —
+                            // preserves local-shadows-import.
+                        }
+                    }
                 }
                 else {
-                    // ISO C++ `[basic.lookup.unqual]` §7: ADL is suppressed when
-                    // ordinary lookup finds a non-function name (variable, class, enum)
-                    // or a block-scope function declaration (not via using-declaration)
-                    // at the nearest scope where the name exists.
+                    // ADL path: ISO C++ `[basic.lookup.unqual]` §7 — ADL is suppressed
+                    // when ordinary lookup finds a non-function name or a block-scope
+                    // function declaration.
                     const { callables: ordinary, nonCallableFound, blockScopeDeclFound, } = findCallableBindingsAndAdlBlocker(site.inScope, site.name, scopes);
                     const adlSuppressed = nonCallableFound || blockScopeDeclFound;
                     const adl = adlSuppressed
@@ -66,46 +97,63 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             argumentTypes: site.argumentTypes,
                             atRange: { startLine: site.atRange.startLine, startCol: site.atRange.startCol },
                         }, parsed, scopes, parsedFiles);
-                    // Preserve existing ordinary-lookup behavior when ADL contributed
-                    // no candidates.
+                    // When ADL contributed no candidates, narrow ordinary candidates
+                    // with conversion-rank scoring when multiple overloads exist.
+                    // Single candidate or empty falls through to first-match.
                     if (adl === undefined || adl.length === 0) {
-                        fnDef = ordinary[0];
+                        if (ordinary.length <= 1 || options.conversionRankFn === undefined) {
+                            fnDef = ordinary[0];
+                        }
+                        else {
+                            const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
+                            const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, options.conversionRankFn);
+                            if (narrowed.length === 1) {
+                                fnDef = narrowed[0];
+                            }
+                            else if (narrowed.length > 1) {
+                                // Multiple survivors — suppress when same-file (true
+                                // overloads), mirrors ADL merged-candidate behavior.
+                                const sameFile = narrowed.every((d) => d.filePath === narrowed[0].filePath);
+                                if (sameFile) {
+                                    handledSites.add(siteKey);
+                                    continue;
+                                }
+                                fnDef = ordinary[0]; // cross-file shadowing → first-match
+                            }
+                            else {
+                                fnDef = ordinary[0]; // narrowed empty → first-match
+                            }
+                        }
                     }
                     else {
                         const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
                         const merged = [];
-                        const seen = new Set();
+                        const seenMerge = new Set();
                         const push = (defs) => {
                             for (const d of defs) {
-                                if (seen.has(d.nodeId))
+                                if (seenMerge.has(d.nodeId))
                                     continue;
-                                seen.add(d.nodeId);
+                                seenMerge.add(d.nodeId);
                                 merged.push(d);
                             }
                         };
                         push(ordinary);
                         push(adl);
-                        const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes);
+                        const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, options.conversionRankFn);
                         if (narrowed.length === 1) {
                             fnDef = narrowed[0];
                         }
                         else if (narrowed.length === 0) {
-                            // ADL contributed candidates, but none survived arity/type
-                            // narrowing. Treat as handled to avoid global-name fallback
-                            // binding to the same mismatched symbol by simple-name
-                            // uniqueness.
                             handledSites.add(siteKey);
                             continue;
                         }
                         else if (narrowed.length > 1) {
-                            // Suppress ambiguous overload calls (emit zero edges) when
-                            // merged ordinary+ADL candidate sets cannot be disambiguated.
                             if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
                                 handledSites.add(siteKey);
                                 continue;
                             }
-                            // Multiple survivors remain but no conversion-ranking step
-                            // exists yet; suppress instead of picking arbitrarily.
+                            // Multiple survivors remain after conversion-rank scoring;
+                            // suppress instead of picking arbitrarily.
                             handledSites.add(siteKey);
                             continue;
                         }
@@ -124,7 +172,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         callerScope: site.inScope,
                         scopes,
                     })
-                    : undefined);
+                    : undefined, site.argumentTypes, options.conversionRankFn);
             }
             if (fnDef === undefined)
                 continue;
@@ -157,7 +205,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     }
     return emitted;
 }
-function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLocalDef, callArity, isCallerVisible) {
+function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, conversionRankFn) {
     const scopeDefs = [];
     const scopeSeen = new Set();
     for (const def of scopes.defs.byId.values()) {
@@ -195,6 +243,15 @@ function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLoc
         if (arityMatch !== undefined)
             return arityMatch;
     }
+    // When arity narrowing left >1 candidate, try overload narrowing with
+    // argument types + conversion ranking (#1578). This picks the unique
+    // best-rank candidate when exact-type or conversion-rank scoring can
+    // disambiguate (e.g., `f(int)` vs `f(double)` called with `f(2.5)`).
+    if (scopeDefs.length > 1) {
+        const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, conversionRankFn);
+        if (narrowed.length === 1)
+            return narrowed[0];
+    }
     const defs = [];
     const seen = new Set();
     const push = (pool) => {
@@ -227,6 +284,12 @@ function pickUniqueGlobalCallable(name, model, scopes, callerFilePath, isFileLoc
         if (arityMatch !== undefined)
             return arityMatch;
     }
+    // Same argument-type + conversion-rank narrowing for the model pool.
+    if (defs.length > 1) {
+        const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, conversionRankFn);
+        if (narrowed.length === 1)
+            return narrowed[0];
+    }
     return undefined;
 }
 /**
@@ -282,7 +345,7 @@ function pickConstructorOrClass(classDef, workspaceIndex) {
  *  Exported for unit testing — language-agnostic logic, exercised
  *  via synthetic stubs in `pick-implicit-this-overload.test.ts`. The
  *  production call site is `applyFreeCallFallback` immediately above. */
-export function pickImplicitThisOverload(site, scopes, workspaceIndex, model) {
+export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, conversionRankFn) {
     // Find the enclosing Class scope by walking parents.
     let curId = site.inScope;
     let classScopeId;
@@ -311,7 +374,7 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model) {
     // ambiguous narrowing (multiple compatible candidates with no
     // disambiguating signal) leaves the call unresolved rather than
     // routing to an arbitrary first overload by registration order.
-    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes);
+    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, conversionRankFn);
     if (candidates.length !== 1)
         return undefined;
     return candidates[0];

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

@@ -24,10 +24,28 @@
  *      equality. An empty string in `argTypes[i]` means "unknown" and
  *      counts as a match. Mismatches disqualify. A non-empty typed
  *      result wins; otherwise return the arity-filtered candidates.
+ *   4b. When the exact-type filter from step 4 returns empty AND a
+ *       `conversionRankFn` is provided, rank candidates via pairwise
+ *       dominance comparison (ISO C++ [over.ics.rank]): F1 beats F2
+ *       only when F1 is not worse for every arg and better for at
+ *       least one. Non-dominated candidates are returned; multiple
+ *       survivors are genuinely ambiguous.
  *   5. Empty input returns empty output.
  */
 import type { SymbolDefinition } from '../../../../_shared/index.js';
-export declare function narrowOverloadCandidates(overloads: readonly SymbolDefinition[], argCount: number | undefined, argTypes: readonly string[] | undefined): readonly SymbolDefinition[];
+/**
+ * Per-slot conversion-rank function. Returns a numeric cost for
+ * converting `argType` to `paramType`:
+ *   - 0 = exact match (no conversion)
+ *   - 1 = promotion (e.g. char→int, bool→int in C++)
+ *   - 2 = standard conversion (e.g. int→double)
+ *   - Infinity = incompatible types
+ *
+ * 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 declare function narrowOverloadCandidates(overloads: readonly SymbolDefinition[], argCount: number | undefined, argTypes: readonly string[] | undefined, conversionRankFn?: ConversionRankFn): readonly SymbolDefinition[];
 /**
  * Detect when >1 candidate share identical `parameterTypes` after the
  * per-language normalizer has collapsed distinct underlying types. This

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

@@ -24,9 +24,15 @@
  *      equality. An empty string in `argTypes[i]` means "unknown" and
  *      counts as a match. Mismatches disqualify. A non-empty typed
  *      result wins; otherwise return the arity-filtered candidates.
+ *   4b. When the exact-type filter from step 4 returns empty AND a
+ *       `conversionRankFn` is provided, rank candidates via pairwise
+ *       dominance comparison (ISO C++ [over.ics.rank]): F1 beats F2
+ *       only when F1 is not worse for every arg and better for at
+ *       least one. Non-dominated candidates are returned; multiple
+ *       survivors are genuinely ambiguous.
  *   5. Empty input returns empty output.
  */
-export function narrowOverloadCandidates(overloads, argCount, argTypes) {
+export function narrowOverloadCandidates(overloads, argCount, argTypes, conversionRankFn) {
     if (overloads.length === 0)
         return [];
     const arityMatches = argCount === undefined
@@ -76,9 +82,100 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes) {
         });
         if (typed.length > 0)
             return typed;
+        // ── Conversion-rank scoring (step 4b) ──────────────────────────
+        // The exact-type filter above rejected every candidate. When a
+        // per-language conversion-rank function is available, rank via
+        // pairwise dominance: F1 beats F2 only when F1 is not worse for
+        // every arg and better for at least one. Non-dominated candidates
+        // are returned; multiple survivors are genuinely ambiguous.
+        if (conversionRankFn !== undefined) {
+            const ranked = rankByConversion(candidates, argTypes, conversionRankFn);
+            if (ranked.length > 0)
+                return ranked;
+        }
     }
     return candidates;
 }
+/**
+ * Pairwise dominance comparison (ISO C++ [over.ics.rank]).
+ *
+ * F1 is a better match than F2 when F1's conversion rank is **not
+ * worse** for every argument AND **strictly better** for at least one.
+ * Candidates dominated by any other viable candidate are removed.
+ * If more than one non-dominated candidate remains, they are genuinely
+ * ambiguous — callers suppress the edge rather than picking arbitrarily.
+ *
+ * Candidates with at least one `Infinity`-ranked slot (incompatible
+ * type) are excluded before pairwise comparison begins.
+ */
+function rankByConversion(candidates, argTypes, rankFn) {
+    // Step 1: compute per-slot ranks and exclude non-viable candidates.
+    const viable = [];
+    for (const d of candidates) {
+        const params = d.parameterTypes;
+        if (params === undefined)
+            continue;
+        const ranks = [];
+        let ok = true;
+        for (let i = 0; i < argTypes.length && i < params.length; i++) {
+            if (argTypes[i] === '') {
+                ranks.push(0); // unknown arg → any-match (rank 0)
+                continue;
+            }
+            const r = rankFn(argTypes[i], params[i]);
+            if (!isFinite(r)) {
+                ok = false;
+                break;
+            }
+            ranks.push(r);
+        }
+        if (!ok)
+            continue;
+        viable.push({ def: d, ranks });
+    }
+    if (viable.length <= 1)
+        return viable.map((v) => v.def);
+    // Step 2: pairwise dominance — remove candidates dominated by any other.
+    const dominated = new Set();
+    for (let i = 0; i < viable.length; i++) {
+        if (dominated.has(i))
+            continue;
+        for (let j = i + 1; j < viable.length; j++) {
+            if (dominated.has(j))
+                continue;
+            const cmp = pairwiseCompare(viable[i].ranks, viable[j].ranks);
+            if (cmp < 0)
+                dominated.add(j); // i dominates j
+            else if (cmp > 0)
+                dominated.add(i); // j dominates i
+        }
+    }
+    return viable.filter((_, idx) => !dominated.has(idx)).map((v) => v.def);
+}
+/**
+ * Compare two per-slot rank vectors.
+ * Returns  -1 if `a` dominates `b` (not worse everywhere, better somewhere),
+ *          +1 if `b` dominates `a`,
+ *           0 if neither dominates (incomparable or equal).
+ */
+function pairwiseCompare(a, b) {
+    let aBetter = false;
+    let bBetter = false;
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+        if (a[i] < b[i])
+            aBetter = true;
+        else if (b[i] < a[i])
+            bBetter = true;
+        if (aBetter && bBetter)
+            return 0; // incomparable — early exit
+    }
+    if (aBetter && !bBetter)
+        return -1;
+    if (bBetter && !aBetter)
+        return 1;
+    return 0;
+}
 /**
  * Detect when >1 candidate share identical `parameterTypes` after the
  * per-language normalizer has collapsed distinct underlying types. This

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -41,7 +41,7 @@ import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -249,7 +249,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     for (const ownerId of chain) {
                         const methodOverloads = model.methods.lookupAllByOwner(ownerId, memberName);
                         if (methodOverloads.length > 0) {
-                            const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes);
+                            const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes, provider.conversionRankFn);
                             if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
                                 ambiguous = true;
                                 break;
@@ -262,6 +262,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                                 hiddenByName = true;
                                 break;
                             }
+                            // Multiple tied survivors with distinct param types (e.g.
+                            // h(int,double) vs h(double,int) both scoring 2) → ambiguous.
+                            if (narrowed.length > 1) {
+                                ambiguous = true;
+                                break;
+                            }
                             memberDef = narrowed[0] ?? methodOverloads[0];
                             break;
                         }
@@ -461,7 +467,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     let memberDef;
                     let ambiguous = false;
                     for (const ownerId of chain) {
-                        const picked = pickOverload(ownerId, memberName, site, model);
+                        const picked = pickOverload(ownerId, memberName, site, model, provider.conversionRankFn);
                         if (picked === OVERLOAD_AMBIGUOUS) {
                             ambiguous = true;
                             break;
@@ -512,7 +518,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
  *  types when multiple overloads share the name. Falls back to the
  *  first-seen def (legacy `findOwnedMember` semantics) when there's
  *  no narrowing signal or when `argumentTypes` is unavailable. */
-function pickOverload(ownerId, memberName, site, model) {
+function pickOverload(ownerId, memberName, site, model, conversionRankFn) {
     const overloads = model.methods.lookupAllByOwner(ownerId, memberName);
     if (overloads.length === 0) {
         // Non-callable member (field / property / variable) — ACCESSES
@@ -522,7 +528,7 @@ function pickOverload(ownerId, memberName, site, model) {
     }
     if (overloads.length === 1)
         return overloads[0];
-    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes);
+    const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, conversionRankFn);
     // When narrowing leaves >1 candidate that share identical normalized
     // parameter-types (e.g., C++ `f(int)` vs `f(long)` both collapsed to
     // `['int']` by `normalizeCppParamType`), suppress the edge entirely.
@@ -531,6 +537,12 @@ function pickOverload(ownerId, memberName, site, model) {
     // PR #1520 review follow-up plan U2 / Claude review Finding 5.
     if (isOverloadAmbiguousAfterNormalization(candidates, site.arity))
         return OVERLOAD_AMBIGUOUS;
+    // When conversion-rank scoring leaves >1 tied candidate with distinct
+    // parameter types (e.g. h(int,double) vs h(double,int) both scoring 2),
+    // suppress rather than picking arbitrarily — C++ would call this
+    // ambiguous. Mirrors ADL merged-candidate suppression behavior.
+    if (candidates.length > 1)
+        return OVERLOAD_AMBIGUOUS;
     return candidates[0] ?? overloads[0];
 }
 /**

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -249,6 +249,7 @@ export function runScopeResolution(input, provider) {
         isFileLocalDef: provider.isFileLocalDef,
         isCallableVisibleFromCaller: provider.isCallableVisibleFromCaller,
         resolveAdlCandidates: provider.resolveAdlCandidates,
+        conversionRankFn: provider.conversionRankFn,
     });
     const { emitted, skipped } = emitReferencesViaLookup(graph, indexes, referenceIndex, nodeLookup, handledSites);
     const importsEmitted = emitImportEdges(graph, indexes.imports, indexes.scopeTree, provider.importEdgeReason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.48",
+  "version": "1.6.5-rc.49",
   "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",