gitnexus 1.6.6-rc.99 → 1.6.6

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 { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, findClassBindingInScope, } from '../scope/walkers.js';
+import { findAllCallableBindingsInScope, findCallableBindingInScope, findCallableBindingsAndAdlBlocker, resolveInheritanceBaseInScope, } 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;
@@ -27,6 +27,19 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
     // per call site. Same name + callable-kind filter that the previous scan
     // applied (see pickUniqueGlobalCallable JSDoc). Cost: O(|defs|) once.
     const globalCallablesBySimpleName = buildGlobalCallableIndex(scopes);
+    // Sibling index for constructor-form class fallback. Built once here so
+    // pickUniqueGlobalClass is O(1)-per-site rather than re-scanning
+    // defs.byId.values() at every constructor call. Same simple-name keying
+    // and class-like kind filter the previous per-site scan applied.
+    const globalClassesBySimpleName = buildGlobalClassIndex(scopes);
+    // Per-pass memo of pickUniqueGlobalCallable's post-filter candidate list,
+    // keyed (simpleName, callerFilePath). Only created when no per-caller
+    // visibility filter applies (the list is then a pure function of name+file —
+    // see pickUniqueGlobalCallable). Lets repeated free calls of the same name
+    // from one file reuse the same-name-bucket scan instead of re-walking it.
+    const scopeDefsCache = options.isCallableVisibleFromCaller === undefined
+        ? new Map()
+        : undefined;
     for (const parsed of parsedFiles) {
         for (const site of parsed.referenceSites) {
             if (site.kind !== 'call')
@@ -39,9 +52,32 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // the same two targets; see test expectations.
             let fnDef;
             if (site.callForm === 'constructor') {
-                const classDef = findClassBindingInScope(site.inScope, site.name, scopes);
-                if (classDef !== undefined) {
-                    fnDef = pickConstructorOrClass(classDef, workspaceIndex, scopes);
+                const classDef = resolveInheritanceBaseInScope(site.inScope, site.name, scopes, site.rawQualifiedName);
+                if (classDef !== undefined && classDef.type !== 'Interface') {
+                    // Most languages link `Type(...)` to the explicit Constructor def
+                    // when one exists (else the Class). Languages that model the call
+                    // as a reference to the type itself opt into
+                    // `constructorCallTargetsClass` and always link to the Class.
+                    fnDef =
+                        options.constructorCallTargetsClass === true
+                            ? classDef
+                            : pickConstructorOrClass(classDef, workspaceIndex, scopes, site.arity);
+                }
+                else if (options.allowGlobalFallback === true) {
+                    // The constructed type may live in a sibling/imported file that is
+                    // not in the call-site's lexical scope-chain bindings. Fall back to
+                    // a unique workspace-wide Class def by simple name (gated on the
+                    // same global-fallback opt-in as free calls). Then target the
+                    // Class or its Constructor per the language's preference.
+                    const globalClass = pickUniqueGlobalClass(site.name, globalClassesBySimpleName);
+                    if (globalClass !== undefined) {
+                        fnDef =
+                            globalClass.type === 'Interface'
+                                ? undefined
+                                : options.constructorCallTargetsClass === true
+                                    ? globalClass
+                                    : pickConstructorOrClass(globalClass, workspaceIndex, scopes, site.arity);
+                    }
                 }
             }
             // Implicit-this overload narrowing: an unqualified call inside
@@ -49,11 +85,13 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // enclosing class. When the workspace has multiple methods of
             // the same name in a single class, choose the best match by
             // arity + argument types.
+            let fnDefFromImplicitThis = false;
             if (fnDef === undefined) {
                 fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, {
                     conversionRankFn: options.conversionRankFn,
                     constraintCompatibility: options.constraintCompatibility,
                 });
+                fnDefFromImplicitThis = fnDef !== undefined;
             }
             // Scope-chain callable lookup. First-match preserves scope-chain
             // precedence (local shadows import). When a conversion-rank function
@@ -247,11 +285,22 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         callerScope: site.inScope,
                         scopes,
                     })
-                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn);
+                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache);
             }
             if (fnDef === undefined)
                 continue;
-            const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup);
+            if ((fnDefFromImplicitThis || fnDef.type === 'Method' || fnDef.type === 'Constructor') &&
+                options.isCallableVisibleFromCaller !== undefined &&
+                !options.isCallableVisibleFromCaller({
+                    callerParsed: parsed,
+                    candidate: fnDef,
+                    callerScope: site.inScope,
+                    scopes,
+                })) {
+                handledSites.add(siteKey(parsed.filePath, site));
+                continue;
+            }
+            const callerGraphId = resolveCallerGraphId(site.inScope, scopes, nodeLookup, site.atRange);
             if (callerGraphId === undefined)
                 continue;
             const tgtGraphId = resolveDefGraphId(fnDef.filePath, fnDef, nodeLookup);
@@ -312,8 +361,11 @@ function recordSuppressedOutcome(record, input) {
  * (falling back to the qualifiedName itself when undotted). Used by
  * `pickUniqueGlobalCallable` so every free-call fallback site is O(1)
  * instead of O(|defs|).
+ *
+ * Exported for unit testing — language-agnostic logic, exercised via synthetic
+ * stubs in `pick-unique-global-callable.test.ts`.
  */
-function buildGlobalCallableIndex(scopes) {
+export function buildGlobalCallableIndex(scopes) {
     const out = new Map();
     for (const def of scopes.defs.byId.values()) {
         if (def.type !== 'Function' && def.type !== 'Method' && def.type !== 'Constructor')
@@ -331,27 +383,95 @@ function buildGlobalCallableIndex(scopes) {
     }
     return out;
 }
-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) ?? []) {
-        // Skip file-local defs (e.g. C `static` functions) that live in a
-        // different file from the caller — they are logically invisible.
-        if (isFileLocalDef !== undefined && def.filePath !== callerFilePath && isFileLocalDef(def)) {
+/**
+ * Build a `simpleName -> class-like defs` index from `scopes.defs` once per
+ * pass — the structural sibling of `buildGlobalCallableIndex`, consumed by
+ * `pickUniqueGlobalClass` so constructor-form fallback is O(1)-per-site
+ * instead of O(|defs|).
+ *
+ * **Kind filter (KTD5 — KEEP `'Interface'`):** the set is
+ * `Class | Struct | Interface`, matching the idiomatic class-like set used
+ * elsewhere in the scope-resolution bridge (`graph-bridge/ids.ts`,
+ * `node-lookup.ts`). This is a behavior-PRESERVING perf refactor for all 8
+ * `allowGlobalFreeCallFallback` languages — the previous per-site scan used
+ * exactly this filter. Excluding Swift `protocol` (`Interface`) defs because
+ * protocols aren't instantiable is a *separate* Swift-semantics question with
+ * its own test; dropping `Interface` here would be a deliberate
+ * behavior-changing edit, not part of U5.
+ *
+ * Bucket insertion order follows `defs.byId.values()` iteration order, so the
+ * downstream "keep first" / ambiguity ordering in `pickUniqueGlobalClass` is
+ * byte-identical to the old linear scan (equivalence verified).
+ *
+ * Exported for unit testing — language-agnostic logic, exercised via synthetic
+ * stubs in `pick-unique-global-class.test.ts`.
+ */
+export function buildGlobalClassIndex(scopes) {
+    const out = new Map();
+    for (const def of scopes.defs.byId.values()) {
+        if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
             continue;
-        }
-        // Caller-side visibility filter (e.g., PHP namespace + use-function
-        // import gating). When defined, blocks candidates the caller cannot
-        // legally reach. Languages without namespace-scoped function resolution
-        // leave this undefined → no filtering.
-        if (isCallerVisible !== undefined && !isCallerVisible(def)) {
+        const qualified = def.qualifiedName;
+        if (qualified === undefined || qualified.length === 0)
             continue;
+        const dot = qualified.lastIndexOf('.');
+        const simple = dot === -1 ? qualified : qualified.slice(dot + 1);
+        const bucket = out.get(simple);
+        if (bucket)
+            bucket.push(def);
+        else
+            out.set(simple, [def]);
+    }
+    return out;
+}
+/**
+ * Resolve a free (unqualified, receiver-less) call to a globally-unique
+ * callable def by simple name. See the in-body comments for the narrowing
+ * order. Exported for unit testing — the `scopeDefsCache` equivalence is
+ * exercised via synthetic stubs in `pick-unique-global-callable.test.ts`.
+ */
+export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache) {
+    // The scope-index candidate list is a pure function of (name, callerFilePath):
+    // the same-name bucket is fixed for the pass, the file-local filter depends
+    // only on the candidate + callerFilePath, and the logical-key dedup is
+    // deterministic. When no per-caller visibility filter applies, memoize it so
+    // repeated free calls of the same name from one file — the kernel's hot
+    // pattern (e.g. `kmalloc` across hundreds of `drivers/` sites, where the
+    // same-name bucket has thousands of defs) — reuse the bucket scan instead of
+    // re-walking it per site. The cached array is only ever READ by the arity /
+    // overload narrowers below (both `.filter()`-based — they never mutate it),
+    // so one shared instance across call sites is safe. The cache is bypassed
+    // when a visibility filter is present (`isCallerVisible !== undefined`),
+    // because the list would then depend on the caller's scope, not just its file.
+    const cacheKey = scopeDefsCache !== undefined && isCallerVisible === undefined
+        ? `${name}${callerFilePath}`
+        : undefined;
+    let scopeDefs = cacheKey !== undefined ? scopeDefsCache.get(cacheKey) : undefined;
+    if (scopeDefs === undefined) {
+        const built = [];
+        const scopeSeen = new Set();
+        for (const def of globalCallablesBySimpleName.get(name) ?? []) {
+            // Skip file-local defs (e.g. C `static` functions) that live in a
+            // different file from the caller — they are logically invisible.
+            if (isFileLocalDef !== undefined && def.filePath !== callerFilePath && isFileLocalDef(def)) {
+                continue;
+            }
+            // Caller-side visibility filter (e.g., PHP namespace + use-function
+            // import gating). When defined, blocks candidates the caller cannot
+            // legally reach. Languages without namespace-scoped function resolution
+            // leave this undefined → no filtering.
+            if (isCallerVisible !== undefined && !isCallerVisible(def)) {
+                continue;
+            }
+            const key = logicalCallableKey(def);
+            if (scopeSeen.has(key))
+                continue;
+            scopeSeen.add(key);
+            built.push(def);
         }
-        const key = logicalCallableKey(def);
-        if (scopeSeen.has(key))
-            continue;
-        scopeSeen.add(key);
-        scopeDefs.push(def);
+        scopeDefs = built;
+        if (cacheKey !== undefined)
+            scopeDefsCache.set(cacheKey, built);
     }
     if (scopeDefs.length === 1)
         return scopeDefs[0];
@@ -449,13 +569,14 @@ function logicalCallableKey(def) {
  *  Class def itself when no explicit Constructor exists. Matches
  *  legacy behavior — tests assert targetLabel === 'Class' for implicit
  *  ctors and targetLabel === 'Constructor' for explicit ones. */
-function pickConstructorOrClass(classDef, workspaceIndex, scopes) {
+function pickConstructorOrClass(classDef, workspaceIndex, scopes, callArity) {
     const classScope = workspaceIndex.classScopeByDefId.get(classDef.nodeId);
     if (classScope === undefined)
         return classDef;
+    const ctors = [];
     for (const def of classScope.ownedDefs) {
         if (def.type === 'Constructor')
-            return def;
+            ctors.push(def);
     }
     if (scopes !== undefined) {
         for (const childId of scopes.scopeTree.getChildren(classScope.id)) {
@@ -464,11 +585,50 @@ function pickConstructorOrClass(classDef, workspaceIndex, scopes) {
                 continue;
             for (const def of childScope.ownedDefs) {
                 if (def.type === 'Constructor')
-                    return def;
+                    ctors.push(def);
             }
         }
     }
-    return classDef;
+    if (ctors.length === 0)
+        return classDef;
+    if (callArity !== undefined) {
+        const narrowed = narrowByArity(ctors, callArity);
+        if (narrowed !== undefined)
+            return narrowed;
+    }
+    return ctors[0];
+}
+/** Find a unique workspace-wide class-like def by simple name, for a
+ *  constructor-form call `Type(...)` whose type lives outside the call
+ *  site's lexical bindings (a sibling/imported file). Returns the def
+ *  only when all matches share ONE qualified name — i.e. they are
+ *  fragments of a single logical type (partial classes / extensions
+ *  that re-key onto the same type), which resolve to the same graph
+ *  node. Genuinely distinct types with the same simple name are
+ *  ambiguous and leave the call unresolved rather than guessing. Gated
+ *  by the caller on `allowGlobalFallback`, mirroring
+ *  `pickUniqueGlobalCallable`.
+ *
+ *  Consumes the once-built `buildGlobalClassIndex` (`simpleName ->
+ *  class-like defs`) so each call site is O(1) rather than O(|defs|).
+ *  The index's `Class | Struct | Interface` kind filter is intentionally
+ *  KEPT (KTD5) — see `buildGlobalClassIndex` for why dropping `Interface`
+ *  would be a separate, behavior-changing Swift-semantics edit.
+ *
+ *  Exported for unit testing — language-agnostic logic, exercised via
+ *  synthetic stubs in `pick-unique-global-class.test.ts`. The production
+ *  call site is the constructor-form fallback in `emitFreeCallFallback`. */
+export function pickUniqueGlobalClass(name, index) {
+    let found;
+    for (const def of index.get(name) ?? []) {
+        // Same qualified name = same logical type (extension / partial-class
+        // fragment); keep the first and don't treat it as ambiguous.
+        if (found !== undefined && found.qualifiedName !== def.qualifiedName)
+            return undefined;
+        if (found === undefined)
+            found = def;
+    }
+    return found;
 }
 /** Walk up from the call-site scope to the enclosing class scope,
  *  pick a method member by name with overload narrowing on arity +

package/dist/core/ingestion/scope-resolution/passes/imported-return-types.js

@@ -38,7 +38,7 @@
  * Generic; promoted from `languages/python/scope-resolver.ts` per the
  * scope-resolution generalization plan.
  */
-import { lookupBindingsAt, namesAtScope } from '../scope/walkers.js';
+import { lookupBindingsAt, namesAtScope, moduleScopeIdOf, namespaceTypeBindingFor, } from '../scope/walkers.js';
 /**
  * Max chain depth for the post-finalize re-follow. Effective end-to-end
  * depth is roughly 2× this number, because chain-following runs once
@@ -56,6 +56,9 @@ const RECHAIN_MAX_DEPTH = 8;
 export function followChainPostFinalize(start, fromScopeId, scopes) {
     let current = start;
     const visited = new Set();
+    // The caller's module scope is fixed across the walk; resolve it once so the
+    // accessibility-gated per-namespace fallback below can be consulted cheaply.
+    const moduleScopeId = moduleScopeIdOf(fromScopeId, scopes);
     for (let depth = 0; depth < RECHAIN_MAX_DEPTH; depth++) {
         if (current.rawName.includes('.'))
             return current;
@@ -71,6 +74,23 @@ export function followChainPostFinalize(start, fromScopeId, scopes) {
             next = undefined;
             scopeId = scope.parent;
         }
+        // Scope-independent fallbacks (#1871), mirroring findReceiverTypeBinding's
+        // precedence: named namespaces accessible from this file
+        // (`namespaceTypeBindings`, gated by accessibility) first — they lived in the
+        // chain pre-#1871 and so must outrank the flat global channel — then the
+        // global/default namespace (`workspaceTypeBindings`, visible everywhere).
+        // Both live in shared channels rather than each Scope.typeBindings to avoid
+        // the O(files × names) blow-up.
+        if (next === undefined) {
+            const nsHit = namespaceTypeBindingFor(moduleScopeId, current.rawName, scopes);
+            if (nsHit !== undefined && nsHit !== current)
+                next = nsHit;
+        }
+        if (next === undefined) {
+            const ws = scopes.workspaceTypeBindings?.get(current.rawName);
+            if (ws !== undefined && ws !== current)
+                next = ws;
+        }
         if (next === undefined)
             return current;
         if (visited.has(next.rawName))

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

@@ -106,7 +106,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
     const graphIdToClassDef = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
-            if (def.type !== 'Class' && def.type !== 'Interface')
+            if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
                 continue;
             const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
             if (graphId !== undefined)

package/dist/core/ingestion/scope-resolution/pipeline/phase.d.ts

@@ -3,23 +3,20 @@
  *
  * Generic registry-primary resolution phase (RFC #909 Ring 3).
  *
- * For every language in `MIGRATED_LANGUAGES` (per-language flag set)
- * whose provider is registered in `SCOPE_RESOLVERS`:
+ * For every language whose provider is registered in `SCOPE_RESOLVERS`:
  *   1. Filter scanned files by language extension.
  *   2. Read file contents.
  *   3. Drive the scope-based pipeline end-to-end via the generic
  *      `runScopeResolution(input, provider)` orchestrator.
  *   4. Emit IMPORTS / CALLS / ACCESSES / INHERITS / USES edges.
  *
- * Pairs with the per-language gates in `import-processor.ts` and
- * `call-processor.ts` that skip files when their language is registry-
- * primary, so we don't double-emit edges from both code paths.
+ * This is the sole resolution path — RING4-1 (#942) deleted the legacy
+ * call-resolution DAG, so there is no longer a per-language flag gating
+ * registry-vs-legacy.
  *
- * Adding a language is two changes:
- *   - Implement `ScopeResolver` in `languages/<lang>/scope-resolver.ts`
- *     and register it in `scope-resolution/pipeline/registry.ts`.
- *   - Add the language to `MIGRATED_LANGUAGES` in
- *     `registry-primary-flag.ts`.
+ * Adding a language is one change: implement `ScopeResolver` in
+ * `languages/<lang>/scope-resolver.ts` and register it in
+ * `scope-resolution/pipeline/registry.ts`.
  *
  * @deps    parse  (needs Symbol nodes already in the graph so emit-references
  *                  can attach edges to existing Function/Method/Class nodes)
@@ -40,7 +37,7 @@ export interface ScopeResolutionOutput {
     readonly referenceEdgesEmitted: number;
     /** Additive stream of resolver diagnostics; does not affect graph edges. */
     readonly resolutionOutcomes: readonly ResolutionOutcome[];
-    /** Per-language breakdown for telemetry / shadow-parity. */
+    /** Per-language breakdown for telemetry. */
     readonly perLanguage: ReadonlyMap<SupportedLanguages, {
         readonly filesProcessed: number;
         readonly importsEmitted: number;