gitnexus 1.6.11-rc.8 → 1.6.11

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

@@ -73,6 +73,17 @@ interface ResolveCompoundReceiverOptions {
     readonly constructionSyntax?: ScopeResolver['constructionSyntax'];
     /** Verified namespace handles visible in the current file. */
     readonly namespaceTargets?: ReadonlyMap<string, readonly string[]>;
+    /** A namespace member may be a name the target module imported and
+     *  publishes (hub modules). See `ScopeResolver.namespaceExportsIncludeImportedNames`. */
+    readonly namespaceExportsIncludeImportedNames?: boolean;
+    /** Resolve a qualified CLASS name (`opmod.Op`, `hub.sub.Thing`,
+     *  `mod.Outer.Inner`) through the language's namespace chain walk
+     *  (`ScopeResolver.resolveNamespaceChains`). Seeds the dotted-chain walk
+     *  when its head is a namespace rather than a value: `opmod.Op.lookup` is
+     *  the enum `Op` reached through the module `opmod`, then its variant
+     *  `lookup` — a value of `Op` — and only then a method (PR #1432 review,
+     *  8.10). Absent ⇒ the head must bind in scope, exactly as before. */
+    readonly resolveQualifiedClass?: (qualifiedName: string, inScope: ScopeId) => SymbolDefinition | undefined;
     /** Compact receiver chain for THIS site (`ReferenceSite.receiverChain`), when
      *  the language's capture emitter produced one. Present ⇒ the structural fold
      *  is tried before the text cascade; absent ⇒ behaviour is exactly as before.

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

@@ -21,7 +21,7 @@
  */
 import { erasedTypeApplication, matchingOpenParen, stripTemplateArguments, } from '../../utils/template-arguments.js';
 import { decodeReceiverChain } from '../../utils/receiver-chain-codec.js';
-import { findClassBindingInScope, resolveClassBindingForName, findEnclosingClassDef, findExportedDef, findExportedDefByName, findReceiverTypeBinding, isClassLike, isNamespaceNameShadowed, } from '../scope/walkers.js';
+import { findClassBindingInScope, resolveClassBindingForName, findEnclosingClassDef, findExportedDef, findExportedDefByName, findExportedDefIncludingImportedNames, findReceiverTypeBinding, isClassLike, isNamespaceNameShadowed, } from '../scope/walkers.js';
 /** Max depth for compound-receiver chain resolution (`a().b().c().d()`).
  *  Practical code rarely exceeds 3-4 _syntactic_ hops, but languages
  *  with type-binding-mediated chains (Ruby's `x = obj.method()` binds
@@ -126,7 +126,9 @@ function resolveConstructionExpressionClass(fnExpr, inScope, scopes, index, opti
             if (isNamespaceNameShadowed(namespaceName, inScope, scopes))
                 return undefined;
             const namespaceMatches = namespaceFiles
-                .map((targetFile) => findExportedDef(targetFile, exportedName, index))
+                .map((targetFile) => options.namespaceExportsIncludeImportedNames === true
+                ? findExportedDefIncludingImportedNames(targetFile, exportedName, index, scopes)
+                : findExportedDef(targetFile, exportedName, index))
                 .filter((def) => def !== undefined && isClassLike(def.type));
             return namespaceMatches.length === 1 ? namespaceMatches[0] : undefined;
         }
@@ -893,7 +895,31 @@ export function resolveCompoundReceiverClass(receiverText, inScope, scopes, inde
     if (currentClass === undefined) {
         currentClass = resolveConstructionExpressionClass(headMemberName, inScope, scopes, index, options);
     }
-    for (let i = 1; i < parts.length && currentClass !== undefined; i++) {
+    // Namespace-qualified chain head — `opmod.Op.lookup` / `hub.sub.Thing.x`:
+    // no binding and no class named `opmod`, but the LONGEST prefix the
+    // language's chain walk accepts as a class seeds the walk (the class
+    // itself, so a variant / static member hop is read off the class scope),
+    // and the remaining segments are walked as members. Longest first: the
+    // prefix is a class, not a value, and `a.B.C` must seed at `C`, not stop
+    // at `B` and read `C` as a member of it. The whole receiver may be the
+    // class (`opmod.Op` — no member segment left), exactly as a bare class
+    // name head resolves to the class constant above.
+    let firstHop = 1;
+    if (currentClass === undefined && headType === undefined && options.resolveQualifiedClass) {
+        for (let k = parts.length; k >= 2; k--) {
+            const prefix = parts.slice(0, k).join('.');
+            if (prefix.includes('('))
+                continue;
+            const seeded = options.resolveQualifiedClass(prefix, inScope);
+            if (seeded === undefined)
+                continue;
+            currentClass = seeded;
+            currentIsClassConstant = true;
+            firstHop = k;
+            break;
+        }
+    }
+    for (let i = firstHop; i < parts.length && currentClass !== undefined; i++) {
         const segment = parts[i];
         if (segment === undefined)
             break;

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

@@ -16,7 +16,7 @@
  * Generic; promoted from `languages/python/scope-resolver.ts` per the scope-resolution
  * generalization plan.
  */
-import type { ParameterTypeClass, ParsedFile, Reference, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
+import type { ParameterTypeClass, ParsedFile, Reference, ReferenceSite, ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { SemanticModel } from '../../model/semantic-model.js';
@@ -33,6 +33,9 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
     /** When true, `Type(...)` constructor calls link to the Class def
      *  itself rather than its explicit Constructor. Swift opts in. */
     readonly constructorCallTargetsClass?: boolean;
+    /** When true, a constructor-form site's edge gets ` (constructor)`
+     *  appended to its reason. See `ScopeResolver.markConstructionSites`. */
+    readonly markConstructionSites?: boolean;
     readonly isFileLocalDef?: (def: SymbolDefinition) => boolean;
     readonly isCallableVisibleFromCaller?: (ctx: {
         readonly callerParsed: ParsedFile;
@@ -79,6 +82,10 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  multi-line calls are still recorded per site. */
     readonly calleeIdSink?: CalleeIdSink;
 }): number;
+/** `reason` of a free-call edge: the legacy string, plus ` (constructor)` for
+ *  a construction site when the provider opted in
+ *  (`ScopeResolver.markConstructionSites`). */
+export declare function constructionSiteReason(base: string, site: Pick<ReferenceSite, 'callForm'>, markConstructionSites: boolean | undefined): string;
 /**
  * Build a `simpleName -> callable defs` index from `scopes.defs` once per
  * pass. Mirrors the filter the old per-site scan applied: Function /

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

@@ -79,6 +79,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
         return owners.has(instanceOwnerKey(ownerId));
     };
     for (const parsed of parsedFiles) {
+        const pending = new Map();
         const bindingCandidatesByScope = options.freeCallsRequireInstanceOwnership === true
             ? new Map()
             : undefined;
@@ -462,24 +463,49 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // SiteRecord.at: 1-based line / 0-based col).
             options.calleeIdSink?.add(parsed.filePath, site.atRange.startLine, site.atRange.startCol, tgtGraphId);
             const relId = `rel:CALLS:${callerGraphId}->${tgtGraphId}`;
+            // One edge per (caller, callee): `staticGated` is the AND over every site
+            // that collapses into it, so a callee reached from one live site and one
+            // dead site stays live whichever site the walk meets first. Emission is
+            // deferred to the end of this file's sites for that reason.
+            const pendingRel = pending.get(relId);
+            if (pendingRel !== undefined) {
+                if (site.staticGated !== true)
+                    pendingRel.gatedAll = false;
+                continue;
+            }
             if (seen.has(relId))
                 continue;
             seen.add(relId);
-            graph.addRelationship({
-                id: relId,
-                sourceId: callerGraphId,
-                targetId: tgtGraphId,
-                type: 'CALLS',
-                confidence: 0.85,
-                // Match legacy DAG's reason convention so consumers that
-                // assert `reason === 'import-resolved'` keep working.
-                reason: fnDef.filePath !== parsed.filePath ? 'import-resolved' : 'local-call',
+            pending.set(relId, {
+                gatedAll: site.staticGated === true,
+                rel: {
+                    id: relId,
+                    sourceId: callerGraphId,
+                    targetId: tgtGraphId,
+                    type: 'CALLS',
+                    confidence: 0.85,
+                    // Match legacy DAG's reason convention so consumers that
+                    // assert `reason === 'import-resolved'` keep working. The
+                    // construction-site marker is opt-in for the same reason.
+                    reason: constructionSiteReason(fnDef.filePath !== parsed.filePath ? 'import-resolved' : 'local-call', site, options.markConstructionSites),
+                },
             });
             emitted++;
         }
+        for (const { rel, gatedAll } of pending.values()) {
+            graph.addRelationship(gatedAll ? { ...rel, staticGated: true } : rel);
+        }
     }
     return emitted;
 }
+/** `reason` of a free-call edge: the legacy string, plus ` (constructor)` for
+ *  a construction site when the provider opted in
+ *  (`ScopeResolver.markConstructionSites`). */
+export function constructionSiteReason(base, site, markConstructionSites) {
+    return markConstructionSites === true && site.callForm === 'constructor'
+        ? `${base} (constructor)`
+        : base;
+}
 function siteKey(filePath, site) {
     return `${filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
 }

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

@@ -71,10 +71,7 @@ import { type HeritageTypeArguments } from '../utils/generic-instantiation.js';
 import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 import type { ReceiverOrigin } from '../resolution-outcome.js';
 import type { DecodedReceiverChain } from '../../utils/receiver-chain-codec.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' | 'elementTypeOf' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'constructionSyntax' | 'stripTypePreservingDecoration' | 'resolveQualifiedReceiverMember' | 'namespaceReceiverPaths' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly' | 'normalizeTypeArgument'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'elementTypeOf' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'constructionSyntax' | 'stripTypePreservingDecoration' | 'resolveQualifiedReceiverMember' | 'namespaceReceiverPaths' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly' | 'normalizeTypeArgument' | 'markConstructionSites' | 'namespaceExportsIncludeImportedNames' | 'resolveNamespaceChains'>;
 /**
  * Is this dropped receiver rooted inside the analyzed program?
  *

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

@@ -59,8 +59,9 @@
  * resolved to a wrong target.
  */
 import { collectNamespaceTargets } from '../scope/namespace-targets.js';
-import { bindsTypeParameter, findClassBindingInScope, findEnclosingClassDef, isReceiverOwnedButUnbound, findExportedDef, findOwnedMember, findReceiverTypeBinding, findValueBindingInScope, isClassLike, isNamespaceNameShadowed, resolveClassBindingForName, } from '../scope/walkers.js';
+import { bindsTypeParameter, findClassBindingInScope, findEnclosingClassDef, isReceiverOwnedButUnbound, findExportedDef, findExportedDefIncludingImportedNames, findOwnedMember, findReceiverTypeBinding, findValueBindingInScope, isClassLike, isNamespaceNameShadowed, resolveClassBindingForName, } from '../scope/walkers.js';
 import { tryEmitEdge, tryEmitEdgeWithExplicitTargetId, } from '../graph-bridge/edges.js';
+import { constructionSiteReason } from './free-call-fallback.js';
 import { resolveCompoundReceiverClass, resolveCompoundReceiverTyped, } from '../passes/compound-receiver.js';
 import { erasedTypeApplication, typeApplicationArguments } from '../../utils/template-arguments.js';
 import { heritageTypeArgumentsKey, stepHeritageInstantiation, } from '../utils/generic-instantiation.js';
@@ -68,6 +69,65 @@ import { resolveDefGraphId } from '../graph-bridge/ids.js';
 import { narrowOverloadCandidates, isOverloadAmbiguousAfterNormalization, } from './overload-narrowing.js';
 import { classifyReceiverShape } from '../resolution-outcome.js';
 import { decodeReceiverChain } from '../../utils/receiver-chain-codec.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. */
+/** Split `text` at the dots that sit at nesting depth 0 and outside string
+ *  literals — `@import("a.zig").Outer.Inner` → three segments, not four;
+ *  `List(u8).Node` → two. The chain walk's segmenter. */
+function splitTopLevelDots(text) {
+    const out = [];
+    let depth = 0;
+    let inString = false;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === '\\')
+                i++;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '(' || ch === '[' || ch === '<')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '>')
+            depth--;
+        else if (ch === '.' && depth === 0) {
+            out.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(text.slice(start));
+    return out.filter((s) => s.length > 0);
+}
+/** Index of the last depth-0, outside-string dot of `text`, or -1. */
+function lastTopLevelDot(text) {
+    let depth = 0;
+    let inString = false;
+    let last = -1;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === '\\')
+                i++;
+            else if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"')
+            inString = true;
+        else if (ch === '(' || ch === '[' || ch === '<')
+            depth++;
+        else if (ch === ')' || ch === ']' || ch === '>')
+            depth--;
+        else if (ch === '.' && depth === 0)
+            last = i;
+    }
+    return last;
+}
 /** A bare, undecorated identifier and nothing else — see {@link isBareTypeName}. */
 const BARE_TYPE_NAME_RE = /^[A-Za-z_$][\w$]*$/;
 /**
@@ -194,9 +254,153 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
     const fieldFallback = provider.fieldFallbackOnMethodLookup ?? true;
     const collapse = provider.collapseMemberCallsByCallerTarget === true;
     const hoistTypeBindingsToModule = provider.hoistTypeBindingsToModule === true;
+    // Namespace-member lookup for Case 1 / Case 3: local exports only, unless
+    // the provider publishes imported names too (hub modules — see
+    // `ScopeResolver.namespaceExportsIncludeImportedNames`).
+    const lookupNamespaceMember = (targetFile, name) => provider.namespaceExportsIncludeImportedNames === true
+        ? findExportedDefIncludingImportedNames(targetFile, name, index, scopes)
+        : findExportedDef(targetFile, name, index);
+    // A class-like member `name` unique across `files`, or nothing — two
+    // same-named classes behind one handle would mint a confident wrong edge.
+    const uniqueClassAcross = (files, name) => {
+        let picked;
+        for (const file of files) {
+            const def = lookupNamespaceMember(file, name);
+            if (def === undefined || !isClassLike(def.type))
+                continue;
+            if (picked !== undefined && picked.nodeId !== def.nodeId)
+                return undefined;
+            picked = def;
+        }
+        return picked;
+    };
+    // A class-like def NESTED in `owner` (`A.Item` inside `A`): its qualified
+    // name is the owner's plus the segment — the identity the structure phase
+    // and `populateClassOwnedMembers` agree on — so the qualified-name index
+    // answers directly; same file as the owner, unique or nothing. Only the
+    // chain walk reads this: `findOwnedMember` knows methods and fields, and a
+    // nested type is neither.
+    const findNestedClass = (owner, name) => {
+        if (owner.qualifiedName === undefined || owner.qualifiedName.length === 0)
+            return undefined;
+        let picked;
+        for (const id of scopes.qualifiedNames.get(`${owner.qualifiedName}.${name}`)) {
+            const def = scopes.defs.get(id);
+            if (def === undefined || !isClassLike(def.type) || def.filePath !== owner.filePath)
+                continue;
+            if (picked !== undefined && picked.nodeId !== def.nodeId)
+                return undefined;
+            picked = def;
+        }
+        return picked;
+    };
+    // Namespace CHAIN walk (`ScopeResolver.resolveNamespaceChains`): resolve
+    // every segment of a qualified prefix from its verified namespace root —
+    // or, failing a namespace, from a class binding in scope (`Outer.Inner`).
+    // The cursor is either "these module files" or "this class"; a hop from a
+    // module is a class-like member of it (→ class) or a namespace-import edge
+    // its module scope binds under the segment — a republished module,
+    // `pub const sub = @import("sub.zig");` (→ files); a hop from a class is a
+    // nested class-like. Anything ambiguous resolves nothing.
+    const walkChains = provider.resolveNamespaceChains === true;
+    const namespaceImportTargetsOf = (file, name) => {
+        const moduleScope = index.moduleScopeByFile.get(file);
+        if (moduleScope === undefined)
+            return [];
+        const out = [];
+        for (const edge of scopes.imports.get(moduleScope.id) ?? []) {
+            if (edge.kind !== 'namespace' || edge.localName !== name || edge.targetFile === null)
+                continue;
+            if (!out.includes(edge.targetFile))
+                out.push(edge.targetFile);
+        }
+        return out;
+    };
+    const resolveNamespaceChain = (prefix, inScope, namespaceTargets) => {
+        const segments = splitTopLevelDots(prefix);
+        if (segments.length === 0)
+            return undefined;
+        let cursor;
+        let rest = [];
+        // The LONGEST namespace key wins: a provider may bind dotted handles
+        // (`namespaceReceiverPaths`) and an inline `@import("x.zig")` handle
+        // carries a dot of its own inside the quotes.
+        for (let k = segments.length; k >= 1; k--) {
+            const key = segments.slice(0, k).join('.');
+            const files = namespaceTargets.get(key);
+            if (files === undefined)
+                continue;
+            if (isNamespaceNameShadowed(key, inScope, scopes))
+                return undefined;
+            cursor = { files };
+            rest = segments.slice(k);
+            break;
+        }
+        if (cursor === undefined) {
+            const head = findClassBindingInScope(inScope, segments[0], scopes);
+            if (head === undefined || !isClassLike(head.type))
+                return undefined;
+            cursor = { classDef: head };
+            rest = segments.slice(1);
+        }
+        for (const segment of rest) {
+            if (segment.includes('(') || segment.includes('['))
+                return undefined;
+            if ('files' in cursor) {
+                const asClass = uniqueClassAcross(cursor.files, segment);
+                const asModule = [];
+                for (const file of cursor.files) {
+                    for (const target of namespaceImportTargetsOf(file, segment)) {
+                        if (!asModule.includes(target))
+                            asModule.push(target);
+                    }
+                }
+                if (asClass !== undefined && asModule.length > 0)
+                    return undefined; // both — refuse
+                if (asClass !== undefined)
+                    cursor = { classDef: asClass };
+                else if (asModule.length > 0)
+                    cursor = { files: asModule };
+                else
+                    return undefined;
+            }
+            else {
+                const nested = findNestedClass(cursor.classDef, segment);
+                if (nested === undefined)
+                    return undefined;
+                cursor = { classDef: nested };
+            }
+        }
+        return cursor;
+    };
+    // `ns.Type` as a receiver, where `ns` is a verified namespace of the current
+    // file and `Type` a class-like member of it — or, with the chain walk, any
+    // `a.b.c.Type` whose prefix resolves. Unique or nothing.
+    const resolveNamespaceQualifiedClass = (receiverName, inScope, namespaceTargets) => {
+        const dot = walkChains ? lastTopLevelDot(receiverName) : receiverName.lastIndexOf('.');
+        if (dot <= 0 || dot === receiverName.length - 1)
+            return undefined;
+        const head = receiverName.slice(0, dot);
+        const tail = receiverName.slice(dot + 1);
+        if (tail.includes('(') || tail.includes('['))
+            return undefined;
+        if (walkChains) {
+            const cursor = resolveNamespaceChain(head, inScope, namespaceTargets);
+            if (cursor === undefined)
+                return undefined;
+            return 'classDef' in cursor
+                ? findNestedClass(cursor.classDef, tail)
+                : uniqueClassAcross(cursor.files, tail);
+        }
+        const files = namespaceTargets.get(head);
+        if (files === undefined || isNamespaceNameShadowed(head, inScope, scopes))
+            return undefined;
+        return uniqueClassAcross(files, tail);
+    };
     const compoundOpts = {
         fieldFallback,
         elementTypeOf: provider.elementTypeOf,
+        namespaceExportsIncludeImportedNames: provider.namespaceExportsIncludeImportedNames === true,
         hoistTypeBindingsToModule,
         stripReceiverCastExpressions: provider.stripReceiverCastExpressions === true,
         constructionSyntax: provider.constructionSyntax,
@@ -583,7 +787,15 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             receiverPaths: provider.namespaceReceiverPaths,
             moduleFileExists: (filePath) => index.moduleScopeByFile.has(filePath),
         });
-        const fileCompoundOpts = { ...compoundOpts, namespaceTargets };
+        const fileCompoundOpts = {
+            ...compoundOpts,
+            namespaceTargets,
+            ...(walkChains
+                ? {
+                    resolveQualifiedClass: (qualifiedName, inScope) => resolveNamespaceQualifiedClass(qualifiedName, inScope, namespaceTargets),
+                }
+                : {}),
+        };
         // Per-file resolved-callee-id capture context (#2227 U2). Built once per
         // file; `undefined` when the sink is absent (pdg off) so the `tryEmitEdge`
         // capture is a no-op and emission stays byte-identical (R4).
@@ -946,21 +1158,34 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             // that is usually empty. Mirrors the order the compound-receiver
             // construction path already uses.
             const namespaceCandidates = namespaceTargets.get(receiverName);
-            const targetFiles = namespaceCandidates !== undefined &&
+            let targetFiles = namespaceCandidates !== undefined &&
                 !isNamespaceNameShadowed(receiverName, site.inScope, scopes)
                 ? namespaceCandidates
                 : undefined;
+            // Chain walk: `hub.sub.helper()` / `hub.sub.Thing{}` — the receiver is
+            // no handle of this file, but its segments reach a module (see
+            // `resolveNamespaceChain`). A prefix that ends in a CLASS is Case 2's.
+            if (targetFiles === undefined && walkChains && lastTopLevelDot(receiverName) > 0) {
+                const cursor = resolveNamespaceChain(receiverName, site.inScope, namespaceTargets);
+                if (cursor !== undefined && 'files' in cursor)
+                    targetFiles = cursor.files;
+            }
             if (targetFiles !== undefined && provider.resolveQualifiedReceiverMember === undefined) {
                 let found = false;
                 for (const targetFile of targetFiles) {
-                    const memberDef = findExportedDef(targetFile, memberName, index);
+                    const memberDef = lookupNamespaceMember(targetFile, memberName);
                     if (memberDef !== undefined) {
                         if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
                             handledSites.add(siteKey);
                             found = true;
                             break;
                         }
-                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 0.85, collapse, calleeCapture);
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, 
+                        // A namespace-qualified construction site (`mod.T{…}`) resolves
+                        // here like `mod.fn()` does; the provider's opt-in marker keeps
+                        // it distinguishable from an invocation (see
+                        // `ScopeResolver.markConstructionSites`).
+                        constructionSiteReason(memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', site, provider.markConstructionSites), seen, 0.85, collapse, calleeCapture);
                         if (ok)
                             emitted++;
                         handledSites.add(siteKey);
@@ -1007,7 +1232,15 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                 }
             }
             // ── Case 2: class-name receiver ──────────────────────────────
-            const classDef = findClassBindingInScope(site.inScope, receiverName, scopes);
+            // A namespace-qualified class (`stdx.PRNG.from_seed()`, `terminal
+            // .Terminal.init()`) binds nothing in the caller's scope chain; when the
+            // head names a verified namespace, the tail is looked up as that
+            // module's member — through the same lookup Case 1 / Case 3 use, so a
+            // hub module (a file made only of re-exports) answers when the provider
+            // opted in. Only a bare tail is walked here; `ns.Type.field.m()` is the
+            // compound resolver's shape.
+            const classDef = findClassBindingInScope(site.inScope, receiverName, scopes) ??
+                resolveNamespaceQualifiedClass(receiverName, site.inScope, namespaceTargets);
             if (classDef !== undefined) {
                 const chain = [classDef.nodeId, ...scopes.methodDispatch.mroFor(classDef.nodeId)];
                 let memberDef;
@@ -1040,6 +1273,24 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     handledSites.add(siteKey);
                     continue;
                 }
+                // `A.Item{}` / `mod.Outer.Inner{}` — a construction whose member is a
+                // type NESTED in the class the receiver names. Neither a method nor a
+                // field, so the owner walk above cannot see it; the chain walk's
+                // nested-class lookup can (`resolveNamespaceChains`).
+                if (memberDef === undefined && walkChains && site.callForm === 'constructor') {
+                    const nested = findNestedClass(classDef, memberName);
+                    if (nested !== undefined) {
+                        if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, nested)) {
+                            handledSites.add(siteKey);
+                            continue;
+                        }
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, nested, constructionSiteReason(nested.filePath !== parsed.filePath ? 'import-resolved' : 'global', site, provider.markConstructionSites), seen, 0.85, collapse, calleeCapture);
+                        if (ok)
+                            emitted++;
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                }
                 if (memberDef !== undefined) {
                     if (suppressDeletedCallTarget(options.recordResolutionOutcome, parsed.filePath, site, memberDef)) {
                         handledSites.add(siteKey);
@@ -1063,11 +1314,23 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             if (typeRef !== undefined && typeRef.rawName.includes('.')) {
                 const [nsName, ...classNameParts] = typeRef.rawName.split('.');
                 const className = classNameParts.join('.');
-                const targetFiles3 = namespaceTargets.get(nsName);
+                // With the chain walk the dotted type is resolved as a whole
+                // (`x: mod.Outer.Inner`, `t: hub.sub.Thing`); the candidate list then
+                // has one entry or none. Without it: the historical one-hop split.
+                const chainDef3 = walkChains
+                    ? resolveNamespaceQualifiedClass(typeRef.rawName, site.inScope, namespaceTargets)
+                    : undefined;
+                const targetFiles3 = walkChains
+                    ? chainDef3 === undefined
+                        ? undefined
+                        : [chainDef3.filePath]
+                    : namespaceTargets.get(nsName);
                 if (targetFiles3 !== undefined && className.length > 0) {
                     let found3 = false;
                     for (const targetFile3 of targetFiles3) {
-                        const classDef3 = findExportedDef(targetFile3, className, index);
+                        const classDef3 = walkChains
+                            ? chainDef3
+                            : lookupNamespaceMember(targetFile3, className);
                         if (classDef3 !== undefined) {
                             const picked = site.kind === 'call'
                                 ? pickOverload(classDef3.nodeId, memberName, site, model, provider)
@@ -1085,7 +1348,12 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                                     found3 = true;
                                     break;
                                 }
-                                const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', seen, 
+                                const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, 
+                                // Same marker rule as Case 1 / Case 2: a constructor-form site
+                                // reached through a dotted type binding keeps its
+                                // ` (constructor)` suffix when the provider opted in; for
+                                // every other provider the string is unchanged.
+                                constructionSiteReason(memberDef.filePath !== parsed.filePath ? 'import-resolved' : 'global', site, provider.markConstructionSites), seen, 
                                 // Explicit defaults so the trailing capture ctx (#2227 U2) can
                                 // be threaded without changing dedup/confidence behavior.
                                 0.85, false, calleeCapture);

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

@@ -25,6 +25,7 @@ import { cobolScopeResolver } from '../../languages/cobol/scope-resolver.js';
 import { swiftScopeResolver } from '../../languages/swift/scope-resolver.js';
 import { dartScopeResolver } from '../../languages/dart/scope-resolver.js';
 import { vueScopeResolver } from '../../languages/vue/scope-resolver.js';
+import { zigScopeResolver } from '../../languages/zig/scope-resolver.js';
 /** Map of `SupportedLanguages` → `ScopeResolver`. The scope-resolution phase
  *  iterates this map directly — every registered resolver runs. This is the
  *  single source of truth for which languages resolve via scope-resolution. */
@@ -45,4 +46,5 @@ export const SCOPE_RESOLVERS = new Map([
     [SupportedLanguages.Swift, swiftScopeResolver],
     [SupportedLanguages.Dart, dartScopeResolver],
     [SupportedLanguages.Vue, vueScopeResolver],
+    [SupportedLanguages.Zig, zigScopeResolver],
 ]);

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

@@ -49,7 +49,7 @@ import { emitReturnShapeMemberAccesses } from '../passes/return-shape-members.js
 import { emitImportedValueReferences } from '../passes/imported-value-refs.js';
 import { createCalleeIdAccumulator, } from '../graph-bridge/callee-id-sink.js';
 import { emitImportEdges } from '../graph-bridge/imports-to-edges.js';
-import { callableFlowSiteKey, collectDeferredIndirectSites, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
+import { callableFlowSiteKey, collectDeferredIndirectCollection, emitCallableValueFlow, } from '../passes/callable-value-flow.js';
 import { findEnclosingClassDef, resolveInheritanceBaseInScope } from '../scope/walkers.js';
 import { heritageTypeArgumentsKey, } from '../utils/generic-instantiation.js';
 import { buildWorkspaceResolutionIndex } from '../workspace-index.js';
@@ -614,7 +614,8 @@ export function runScopeResolution(input, provider) {
     // ── Phase 4: emit graph edges (LOAD-BEARING ORDER — see I1) ────────────
     input.onProgress?.('linking symbols', files.length, files.length);
     const handledSites = new Set(preEmittedInheritanceSites);
-    const deferredIndirectSites = collectDeferredIndirectSites(emitParsedFiles, indexes);
+    const deferredIndirectCollection = collectDeferredIndirectCollection(emitParsedFiles, indexes);
+    const deferredIndirectSites = deferredIndirectCollection.sites;
     const callableArgumentSites = new Set();
     if (input.pdg !== true && deferredIndirectSites.size > 0) {
         for (const parsed of emitParsedFiles) {
@@ -673,6 +674,7 @@ export function runScopeResolution(input, provider) {
         : emitFreeCallFallback(graph, indexes, emitParsedFiles, postHeritageNodeLookup, referenceIndex, handledSites, readonlyModel, workspaceIndex, {
             allowGlobalFallback: provider.allowGlobalFreeCallFallback === true,
             constructorCallTargetsClass: provider.constructorCallTargetsClass === true,
+            markConstructionSites: provider.markConstructionSites === true,
             isFileLocalDef: provider.isFileLocalDef,
             isBuiltInName: provider.languageProvider.isBuiltInName,
             freeCallsRequireInstanceOwnership: provider.freeCallsRequireInstanceOwnership === true,
@@ -696,7 +698,7 @@ export function runScopeResolution(input, provider) {
         // function-local", which is also what an uninspected repo means, and
         // both correctly emit. See the build site above for why the earlier
         // allowlist could not be made safe this way.
-        functionLocalValueDefIds);
+        functionLocalValueDefIds, { markConstructionSites: provider.markConstructionSites === true });
     // Last-resort property resolution by workspace-unique name (A1/A5). Runs
     // after every precise pass and only sees what they left behind, so a
     // scope-resolved target always wins. Sites the generic bridge already
@@ -788,6 +790,8 @@ export function runScopeResolution(input, provider) {
             collapseByCallerTarget: provider.collapseMemberCallsByCallerTarget === true,
             isCallableValueTarget: provider.isCallableValueTarget,
             hasFileLocalCallableLinkage: provider.hasFileLocalCallableLinkage,
+            deferredIndirectSites,
+            callSignaturesBySite: deferredIndirectCollection.callSignaturesBySite,
             onWarn: (warning) => logger.warn(warning, 'callable-value-flow: candidate set exceeded the cap; no partial CALLS emitted'),
         });
     const importsEmitted = callableFlowOnly