gitnexus 1.6.7-rc.4 → 1.6.7-rc.6

package/dist/core/ingestion/languages/cpp/capture-side-channel.d.ts

@@ -29,6 +29,7 @@ import type { ParsedFile } from '../../../../_shared/index.js';
 import { type CppAdlSideChannel } from './adl.js';
 import { type CppFileLocalSideChannel } from './file-local-linkage.js';
 import { type CppTwoPhaseSideChannel } from './two-phase-lookup.js';
+import { type CppMemberLookupSideChannel } from './member-lookup.js';
 /**
  * Plain JSON-serializable composite of every C++ capture-time side-channel
  * slice for one file. Carried opaquely on `ParsedFile.captureSideChannel`.
@@ -48,6 +49,7 @@ export interface CppCaptureSideChannel {
     readonly inlineNamespaceRanges: readonly string[];
     readonly fileLocal: CppFileLocalSideChannel;
     readonly twoPhase: CppTwoPhaseSideChannel;
+    readonly memberLookup: CppMemberLookupSideChannel;
 }
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for C++.

package/dist/core/ingestion/languages/cpp/capture-side-channel.js

@@ -29,6 +29,7 @@ import { collectCppAdlSideChannel, applyCppAdlSideChannel } from './adl.js';
 import { collectCppInlineNamespaceSideChannel, applyCppInlineNamespaceSideChannel, } from './inline-namespaces.js';
 import { collectCppFileLocalSideChannel, applyCppFileLocalSideChannel, } from './file-local-linkage.js';
 import { collectCppTwoPhaseSideChannel, applyCppTwoPhaseSideChannel, } from './two-phase-lookup.js';
+import { applyCppMemberLookupSideChannel, collectCppMemberLookupSideChannel, } from './member-lookup.js';
 /**
  * `LanguageProvider.collectCaptureSideChannel` implementation for C++.
  * Returns `undefined` when this file recorded no side-channel state at all, so
@@ -39,16 +40,19 @@ export function collectCppCaptureSideChannel(filePath) {
     const inlineNamespaceRanges = collectCppInlineNamespaceSideChannel(filePath);
     const fileLocal = collectCppFileLocalSideChannel(filePath);
     const twoPhase = collectCppTwoPhaseSideChannel(filePath);
+    const memberLookup = collectCppMemberLookupSideChannel(filePath);
     const isEmpty = adl.argInfoBySite.length === 0 &&
         adl.noAdlSites.length === 0 &&
         inlineNamespaceRanges.length === 0 &&
         fileLocal.fileLocalNames.length === 0 &&
         fileLocal.anonymousNamespaceRanges.length === 0 &&
         twoPhase.dependentBases.length === 0 &&
-        twoPhase.dependentPackBaseClasses.length === 0;
+        twoPhase.dependentPackBaseClasses.length === 0 &&
+        memberLookup.baseEdges.length === 0 &&
+        memberLookup.memberUsings.length === 0;
     if (isEmpty)
         return undefined;
-    return { kind: 'cpp', adl, inlineNamespaceRanges, fileLocal, twoPhase };
+    return { kind: 'cpp', adl, inlineNamespaceRanges, fileLocal, twoPhase, memberLookup };
 }
 /**
  * `ScopeResolver.applyCaptureSideChannel` implementation for C++. Reads the
@@ -75,4 +79,7 @@ export function applyCppCaptureSideChannel(parsed) {
         applyCppFileLocalSideChannel(parsed.filePath, data.fileLocal);
     if (data.twoPhase !== undefined)
         applyCppTwoPhaseSideChannel(parsed.filePath, data.twoPhase);
+    if (data.memberLookup !== undefined) {
+        applyCppMemberLookupSideChannel(parsed.filePath, data.memberLookup);
+    }
 }

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

@@ -10,6 +10,7 @@ import { markCppDependentBase, markCppDependentPackBase } from './two-phase-look
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
 import { markCppInlineNamespaceRange } from './inline-namespaces.js';
 import { extractCppTemplateConstraints } from './constraint-extractor.js';
+import { captureCppMemberLookupFacts } from './member-lookup.js';
 export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -354,6 +355,7 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     // and the resolver can suppress unqualified-call binding to those
     // bases per ISO C++ two-phase lookup.
     detectCppDependentBases(tree.rootNode, filePath);
+    captureCppMemberLookupFacts(tree.rootNode, filePath);
     return out;
 }
 function extractCppDeclarationReturnType(fnNode) {

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

@@ -67,6 +67,13 @@ function buildIncludeCapture(node, pathNode) {
 export function splitCppUsingDecl(node) {
     if (node.type !== 'using_declaration')
         return null;
+    // A class-scope `using Base::member;` changes the derived class's member
+    // lookup set; it is not a namespace import. The C++ member-lookup sidecar
+    // captures it separately, so suppress import decomposition here.
+    for (let parent = node.parent; parent !== null; parent = parent.parent) {
+        if (parent.type === 'class_specifier' || parent.type === 'struct_specifier')
+            return null;
+    }
     // Check for "namespace" keyword among anonymous children
     let hasNamespaceKeyword = false;
     for (let i = 0; i < node.childCount; i++) {

package/dist/core/ingestion/languages/cpp/member-lookup.d.ts

@@ -0,0 +1,32 @@
+import type { ParsedFile, ReferenceSite, SymbolDefinition } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { GraphNodeLookup } from '../../scope-resolution/graph-bridge/node-lookup.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { SemanticModel } from '../../model/semantic-model.js';
+import type { ReceiverMemberResolution } from '../../scope-resolution/contract/scope-resolver.js';
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+interface CapturedBaseEdge {
+    readonly childName: string;
+    readonly childQualifiedName?: string;
+    readonly baseName: string;
+    readonly baseQualifiedName?: string;
+    readonly isVirtual: boolean;
+}
+interface CapturedMemberUsing {
+    readonly childName: string;
+    readonly childQualifiedName?: string;
+    readonly baseName: string;
+    readonly baseQualifiedName?: string;
+    readonly memberName: string;
+}
+export interface CppMemberLookupSideChannel {
+    readonly baseEdges: readonly CapturedBaseEdge[];
+    readonly memberUsings: readonly CapturedMemberUsing[];
+}
+export declare function clearCppMemberLookupState(): void;
+export declare function captureCppMemberLookupFacts(root: SyntaxNode, filePath: string): void;
+export declare function collectCppMemberLookupSideChannel(filePath: string): CppMemberLookupSideChannel;
+export declare function applyCppMemberLookupSideChannel(filePath: string, data: CppMemberLookupSideChannel): void;
+export declare function buildCppMemberLookupMro(graph: KnowledgeGraph, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup): Map<string, string[]>;
+export declare function resolveCppReceiverMember(ownerDef: SymbolDefinition, memberName: string, callsite: ReferenceSite, _scopes: ScopeResolutionIndexes, model: SemanticModel): ReceiverMemberResolution | undefined;
+export {};

package/dist/core/ingestion/languages/cpp/member-lookup.js

@@ -0,0 +1,461 @@
+import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
+import { isClassLike } from '../../scope-resolution/scope/walkers.js';
+import { cppConstraintCompatibility } from './constraint-filter.js';
+import { cppConversionRank } from './conversion-rank.js';
+const capturedByFile = new Map();
+let directParentsByDefId = new Map();
+let virtualEdges = new Set();
+let ancestorsByDefId = new Map();
+let memberUsingsByDefId = new Map();
+let inheritedLookupCache = new Map();
+const MAX_INHERITANCE_VISITS = 4096;
+export function clearCppMemberLookupState() {
+    capturedByFile.clear();
+    directParentsByDefId = new Map();
+    virtualEdges = new Set();
+    ancestorsByDefId = new Map();
+    memberUsingsByDefId = new Map();
+    inheritedLookupCache = new Map();
+}
+export function captureCppMemberLookupFacts(root, filePath) {
+    const baseEdges = [];
+    const memberUsings = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.type === 'class_specifier' || node.type === 'struct_specifier') {
+            const childName = classNameOf(node);
+            const childQualifiedName = classQualifiedNameOf(node);
+            if (childName !== '') {
+                const baseClause = directChildOfType(node, 'base_class_clause');
+                if (baseClause !== null) {
+                    captureBaseEdges(baseClause, childName, childQualifiedName, baseEdges);
+                }
+                const body = directChildOfType(node, 'field_declaration_list');
+                if (body !== null) {
+                    for (let i = 0; i < body.namedChildCount; i++) {
+                        const child = body.namedChild(i);
+                        if (child?.type !== 'using_declaration')
+                            continue;
+                        const parsed = parseMemberUsing(child, childName, childQualifiedName);
+                        if (parsed !== undefined)
+                            memberUsings.push(parsed);
+                    }
+                }
+            }
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child !== null)
+                stack.push(child);
+        }
+    }
+    if (baseEdges.length === 0 && memberUsings.length === 0) {
+        capturedByFile.delete(filePath);
+    }
+    else {
+        capturedByFile.set(filePath, { baseEdges, memberUsings });
+    }
+}
+export function collectCppMemberLookupSideChannel(filePath) {
+    return capturedByFile.get(filePath) ?? { baseEdges: [], memberUsings: [] };
+}
+export function applyCppMemberLookupSideChannel(filePath, data) {
+    if (!Array.isArray(data.baseEdges) || !Array.isArray(data.memberUsings))
+        return;
+    if (data.baseEdges.length === 0 && data.memberUsings.length === 0) {
+        capturedByFile.delete(filePath);
+        return;
+    }
+    capturedByFile.set(filePath, {
+        baseEdges: data.baseEdges.slice(),
+        memberUsings: data.memberUsings.slice(),
+    });
+}
+export function buildCppMemberLookupMro(graph, parsedFiles, nodeLookup) {
+    populateResolvedHierarchy(graph, parsedFiles, nodeLookup);
+    return buildMro(graph, parsedFiles, nodeLookup, defaultLinearize);
+}
+export function resolveCppReceiverMember(ownerDef, memberName, callsite, _scopes, model) {
+    if (callsite.kind !== 'call')
+        return undefined;
+    const ownMethods = model.methods.lookupAllByOwner(ownerDef.nodeId, memberName);
+    const introduced = introducedDefinitions(ownerDef.nodeId, memberName, model);
+    if (introduced.length > 0) {
+        return chooseOverload(uniqueDefinitions([...ownMethods, ...introduced]), callsite);
+    }
+    // Direct declarations hide every base declaration. Let the shared path
+    // retain its existing overload/static filtering for this common case.
+    if (ownMethods.length > 0)
+        return undefined;
+    const lookup = inheritedLookupSet(ownerDef.nodeId, memberName, model);
+    if (lookup.kind === 'none')
+        return undefined;
+    if (lookup.kind === 'ambiguous')
+        return lookup;
+    return chooseOverload(lookup.definitions, callsite);
+}
+function collectInheritedOccurrences(ownerDefId, memberName, model, path, virtualAnchor, active, budget) {
+    if (budget.remaining <= 0) {
+        budget.truncated = true;
+        return [];
+    }
+    budget.remaining--;
+    if (active.has(ownerDefId))
+        return [];
+    const nextActive = new Set(active);
+    nextActive.add(ownerDefId);
+    const definitions = uniqueDefinitions([
+        ...model.methods.lookupAllByOwner(ownerDefId, memberName),
+        ...introducedDefinitions(ownerDefId, memberName, model),
+    ]);
+    if (definitions.length > 0) {
+        return [{ ownerDefId, definitions, path, virtualAnchor }];
+    }
+    const results = [];
+    for (const parentDefId of directParentsByDefId.get(ownerDefId) ?? []) {
+        const edgeKey = `${ownerDefId}\0${parentDefId}`;
+        results.push(...collectInheritedOccurrences(parentDefId, memberName, model, [...path, parentDefId], virtualEdges.has(edgeKey) ? parentDefId : virtualAnchor, nextActive, budget));
+    }
+    return results;
+}
+function inheritedLookupSet(ownerDefId, memberName, model) {
+    const cacheKey = `${ownerDefId}\0${memberName}`;
+    const cached = inheritedLookupCache.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const budget = { remaining: MAX_INHERITANCE_VISITS, truncated: false };
+    const occurrences = collectInheritedOccurrences(ownerDefId, memberName, model, [], undefined, new Set(), budget);
+    if (budget.truncated) {
+        const conservative = {
+            kind: 'ambiguous',
+            candidateIds: uniqueDefinitions(occurrences.flatMap((entry) => entry.definitions)).map((definition) => definition.nodeId),
+        };
+        inheritedLookupCache.set(cacheKey, conservative);
+        return conservative;
+    }
+    if (occurrences.length === 0) {
+        const none = { kind: 'none' };
+        inheritedLookupCache.set(cacheKey, none);
+        return none;
+    }
+    // A declaration can dominate another lookup set only when the latter is
+    // reached through a shared virtual subobject. Ordinary ancestry alone is
+    // insufficient: declarations in one non-virtual branch do not hide members
+    // reached through a sibling base subobject.
+    const undominated = occurrences.filter((candidate) => !(candidate.virtualAnchor !== undefined &&
+        occurrences.some((other) => other.ownerDefId !== candidate.ownerDefId &&
+            isAncestor(candidate.ownerDefId, other.ownerDefId))));
+    const groups = new Map();
+    for (const occurrence of undominated) {
+        const key = occurrence.virtualAnchor !== undefined
+            ? `virtual:${occurrence.virtualAnchor}:${occurrence.ownerDefId}`
+            : `path:${occurrence.path.join('>')}:${occurrence.ownerDefId}`;
+        const bucket = groups.get(key);
+        if (bucket === undefined)
+            groups.set(key, [occurrence]);
+        else
+            bucket.push(occurrence);
+    }
+    let result;
+    if (groups.size !== 1) {
+        result = {
+            kind: 'ambiguous',
+            candidateIds: uniqueDefinitions(undominated.flatMap((entry) => entry.definitions)).map((definition) => definition.nodeId),
+        };
+    }
+    else {
+        result = {
+            kind: 'candidates',
+            definitions: groups.values().next().value?.[0]?.definitions ?? [],
+        };
+    }
+    inheritedLookupCache.set(cacheKey, result);
+    return result;
+}
+function introducedDefinitions(ownerDefId, memberName, model) {
+    const definitions = [];
+    for (const entry of memberUsingsByDefId.get(ownerDefId) ?? []) {
+        if (entry.memberName !== memberName)
+            continue;
+        definitions.push(...model.methods.lookupAllByOwner(entry.baseDefId, memberName));
+    }
+    return definitions;
+}
+function uniqueDefinitions(definitions) {
+    return [...new Map(definitions.map((definition) => [definition.nodeId, definition])).values()];
+}
+function chooseOverload(candidates, callsite) {
+    if (candidates.length === 0)
+        return undefined;
+    const narrowed = narrowOverloadCandidates(candidates, callsite.arity, callsite.argumentTypes, {
+        argumentTypeClasses: callsite.argumentTypeClasses,
+        conversionRankFn: cppConversionRank,
+        constraintCompatibility: cppConstraintCompatibility,
+    });
+    if (narrowed.length === 1)
+        return { kind: 'resolved', definition: narrowed[0] };
+    if (narrowed.length > 1 || isOverloadAmbiguousAfterNormalization(narrowed, callsite.arity)) {
+        return {
+            kind: 'ambiguous',
+            candidateIds: narrowed.map((candidate) => candidate.nodeId),
+        };
+    }
+    return undefined;
+}
+function populateResolvedHierarchy(graph, parsedFiles, nodeLookup) {
+    const defByGraphId = new Map();
+    const defById = new Map();
+    const defsByFileAndName = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!isClassLike(def.type))
+                continue;
+            const graphId = resolveDefGraphId(parsed.filePath, def, nodeLookup);
+            if (graphId === undefined)
+                continue;
+            defByGraphId.set(graphId, def);
+            defById.set(def.nodeId, def);
+            const names = new Set([simpleName(def), definitionQualifiedName(def)]);
+            for (const name of names) {
+                if (name === '')
+                    continue;
+                const key = `${parsed.filePath}\0${name}`;
+                const bucket = defsByFileAndName.get(key);
+                if (bucket === undefined)
+                    defsByFileAndName.set(key, [def]);
+                else
+                    bucket.push(def);
+            }
+        }
+    }
+    const parents = new Map();
+    for (const rel of graph.iterRelationshipsByType('EXTENDS')) {
+        const child = defByGraphId.get(rel.sourceId);
+        const parent = defByGraphId.get(rel.targetId);
+        if (child === undefined || parent === undefined)
+            continue;
+        const bucket = parents.get(child.nodeId);
+        if (bucket === undefined)
+            parents.set(child.nodeId, [parent.nodeId]);
+        else
+            bucket.push(parent.nodeId);
+    }
+    directParentsByDefId = parents;
+    ancestorsByDefId = buildAncestorClosure(parents);
+    inheritedLookupCache = new Map();
+    const nextVirtualEdges = new Set();
+    const nextUsings = new Map();
+    for (const parsed of parsedFiles) {
+        const captured = capturedByFile.get(parsed.filePath);
+        if (captured === undefined)
+            continue;
+        for (const edge of captured.baseEdges) {
+            if (!edge.isVirtual)
+                continue;
+            for (const child of matchingChildren(parsed.filePath, edge.childName, edge.childQualifiedName, defsByFileAndName)) {
+                const parent = findCapturedParent(parents.get(child.nodeId) ?? [], edge.baseName, edge.baseQualifiedName, defById);
+                if (parent !== undefined)
+                    nextVirtualEdges.add(`${child.nodeId}\0${parent.nodeId}`);
+            }
+        }
+        for (const using of captured.memberUsings) {
+            const children = matchingChildren(parsed.filePath, using.childName, using.childQualifiedName, defsByFileAndName);
+            for (const child of children) {
+                const baseDef = findCapturedParent(parents.get(child.nodeId) ?? [], using.baseName, using.baseQualifiedName, defById);
+                if (baseDef === undefined)
+                    continue;
+                const bucket = nextUsings.get(child.nodeId);
+                const entry = { baseDefId: baseDef.nodeId, memberName: using.memberName };
+                if (bucket === undefined)
+                    nextUsings.set(child.nodeId, [entry]);
+                else
+                    bucket.push(entry);
+            }
+        }
+    }
+    virtualEdges = nextVirtualEdges;
+    memberUsingsByDefId = nextUsings;
+}
+function captureBaseEdges(baseClause, childName, childQualifiedName, output) {
+    let segmentStart = 0;
+    for (let i = 0; i < baseClause.childCount; i++) {
+        const child = baseClause.child(i);
+        if (child === null)
+            continue;
+        if (child.type === ',' || child.text === ',') {
+            segmentStart = i + 1;
+            continue;
+        }
+        if (child.type !== 'type_identifier' &&
+            child.type !== 'template_type' &&
+            child.type !== 'qualified_identifier') {
+            continue;
+        }
+        let isVirtual = false;
+        for (let j = segmentStart; j < i; j++) {
+            const modifier = baseClause.child(j);
+            if (modifier?.text === 'virtual')
+                isVirtual = true;
+        }
+        const baseQualifiedName = qualifiedTypeName(child.text);
+        const baseName = baseQualifiedName.split('.').at(-1) ?? '';
+        if (baseName !== '') {
+            output.push({
+                childName,
+                ...(childQualifiedName !== childName ? { childQualifiedName } : {}),
+                baseName,
+                ...(baseQualifiedName !== baseName ? { baseQualifiedName } : {}),
+                isVirtual,
+            });
+        }
+    }
+}
+function parseMemberUsing(node, childName, childQualifiedName) {
+    const qualified = node.namedChildren.find((child) => child.type === 'qualified_identifier');
+    if (qualified === undefined)
+        return undefined;
+    const parts = splitQualifiedSegments(qualified.text);
+    if (parts.length < 2)
+        return undefined;
+    const memberName = stripTemplateSuffix(parts.at(-1) ?? '');
+    const baseParts = parts.slice(0, -1).map(stripTemplateSuffix).filter(Boolean);
+    const baseName = baseParts.at(-1) ?? '';
+    const baseQualifiedName = baseParts.join('.');
+    if (baseName === '' || memberName === '')
+        return undefined;
+    return {
+        childName,
+        ...(childQualifiedName !== childName ? { childQualifiedName } : {}),
+        baseName,
+        ...(baseQualifiedName !== baseName ? { baseQualifiedName } : {}),
+        memberName,
+    };
+}
+function classNameOf(node) {
+    const name = node.childForFieldName?.('name');
+    return name === null || name === undefined ? '' : trailingIdentifier(name.text);
+}
+function classQualifiedNameOf(node) {
+    const parts = [classNameOf(node)];
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_specifier' || current.type === 'struct_specifier') {
+            const name = classNameOf(current);
+            if (name !== '')
+                parts.unshift(name);
+        }
+        else if (current.type === 'namespace_definition') {
+            const name = current.childForFieldName?.('name');
+            if (name !== null && name !== undefined) {
+                parts.unshift(...splitQualifiedSegments(name.text).map(stripTemplateSuffix).filter(Boolean));
+            }
+        }
+        current = current.parent;
+    }
+    return parts.filter(Boolean).join('.');
+}
+function directChildOfType(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+}
+function trailingIdentifier(value) {
+    return stripTemplateSuffix(splitQualifiedSegments(value).at(-1) ?? '');
+}
+function qualifiedTypeName(value) {
+    return splitQualifiedSegments(value).map(stripTemplateSuffix).filter(Boolean).join('.');
+}
+function splitQualifiedSegments(value) {
+    const parts = [];
+    let angleDepth = 0;
+    let segmentStart = 0;
+    for (let i = 0; i < value.length; i++) {
+        const char = value[i];
+        if (char === '<')
+            angleDepth++;
+        else if (char === '>' && angleDepth > 0)
+            angleDepth--;
+        else if (char === ':' && value[i + 1] === ':' && angleDepth === 0) {
+            const segment = value.slice(segmentStart, i).trim();
+            if (segment !== '')
+                parts.push(segment);
+            segmentStart = i + 2;
+            i++;
+        }
+    }
+    const tail = value.slice(segmentStart).trim();
+    if (tail !== '')
+        parts.push(tail);
+    return parts;
+}
+function stripTemplateSuffix(value) {
+    const templateStart = value.indexOf('<');
+    return (templateStart >= 0 ? value.slice(0, templateStart) : value).trim();
+}
+function simpleName(def) {
+    return def.qualifiedName?.split('.').at(-1) ?? '';
+}
+function definitionQualifiedName(def) {
+    const name = def.qualifiedName ?? '';
+    if (name === '' || def.namespacePrefix === undefined || def.namespacePrefix === '')
+        return name;
+    return name.startsWith(`${def.namespacePrefix}.`) ? name : `${def.namespacePrefix}.${name}`;
+}
+function matchingChildren(filePath, childName, childQualifiedName, defsByFileAndName) {
+    if (childQualifiedName !== undefined) {
+        const qualified = defsByFileAndName.get(`${filePath}\0${childQualifiedName}`) ?? [];
+        if (qualified.length > 0)
+            return qualified;
+    }
+    const simple = defsByFileAndName.get(`${filePath}\0${childName}`) ?? [];
+    return simple.length === 1 ? simple : [];
+}
+function findCapturedParent(parentIds, baseName, baseQualifiedName, defById) {
+    const candidates = parentIds
+        .map((id) => defById.get(id))
+        .filter((definition) => definition !== undefined);
+    if (baseQualifiedName !== undefined) {
+        const qualified = candidates.filter((definition) => {
+            const name = definitionQualifiedName(definition);
+            return name === baseQualifiedName || name.endsWith(`.${baseQualifiedName}`);
+        });
+        if (qualified.length === 1)
+            return qualified[0];
+        return undefined;
+    }
+    const simple = candidates.filter((definition) => simpleName(definition) === baseName);
+    return simple.length === 1 ? simple[0] : undefined;
+}
+function buildAncestorClosure(parents) {
+    const closure = new Map();
+    const visiting = new Set();
+    const ancestorsOf = (defId) => {
+        const cached = closure.get(defId);
+        if (cached !== undefined)
+            return cached;
+        if (visiting.has(defId))
+            return new Set();
+        visiting.add(defId);
+        const ancestors = new Set();
+        for (const parent of parents.get(defId) ?? []) {
+            ancestors.add(parent);
+            for (const ancestor of ancestorsOf(parent))
+                ancestors.add(ancestor);
+        }
+        visiting.delete(defId);
+        closure.set(defId, ancestors);
+        return ancestors;
+    };
+    for (const defId of parents.keys())
+        ancestorsOf(defId);
+    return closure;
+}
+function isAncestor(ancestorDefId, descendantDefId) {
+    return ancestorsByDefId.get(descendantDefId)?.has(ancestorDefId) === true;
+}

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

@@ -1,6 +1,5 @@
 import { findClassBindingInScope, findEnclosingClassDef, } from '../../scope-resolution/scope/walkers.js';
 import { SupportedLanguages } from '../../../../_shared/index.js';
-import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
 import { populateClassOwnedMembers, tagNamespacePrefixes, } from '../../scope-resolution/scope/walkers.js';
 import { cppProvider } from '../c-cpp.js';
 import { cppArityCompatibility } from './arity.js';
@@ -16,6 +15,7 @@ import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQ
 import { populateCppRangeBindings } from './range-bindings.js';
 import { cppConstraintCompatibility } from './constraint-filter.js';
 import { clearCppUserDefinedConversions, populateCppUserDefinedConversions, } from './user-defined-conversions.js';
+import { buildCppMemberLookupMro, clearCppMemberLookupState, resolveCppReceiverMember, } from './member-lookup.js';
 /**
  * Per-pass memo of the augmented `#include`-resolution file set
  * (`allFilePaths` ∪ header paths), keyed on the two stable source sets.
@@ -69,6 +69,7 @@ export const cppScopeResolver = {
         clearCppAdlState();
         clearCppInlineNamespaces();
         clearCppUserDefinedConversions();
+        clearCppMemberLookupState();
         return scanCppHeaderFiles(repoPath);
     },
     resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
@@ -91,7 +92,7 @@ export const cppScopeResolver = {
     // C++20 `requires P`) provably fail at the call site. Three-valued —
     // `'unknown'` keeps the candidate, preserving "degrade not lie".
     constraintCompatibility: cppConstraintCompatibility,
-    buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
+    buildMro: buildCppMemberLookupMro,
     // Worker-boundary restore (see `ScopeResolver.applyCaptureSideChannel`).
     // `emitCppScopeCaptures` records per-file ADL call-site arg shapes
     // (`markCppAdlSiteArgs`/`markCppAdlSiteNoAdl`), inline-/anonymous-namespace
@@ -212,6 +213,7 @@ export const cppScopeResolver = {
     hoistTypeBindingsToModule: true,
     // Enable receiver-bound explicit-`this` fallback only for C++.
     resolveThisViaEnclosingClass: true,
+    resolveReceiverMember: resolveCppReceiverMember,
     // The `isFileLocalDef` hook on the global free-call fallback names
     // file-local linkage historically, but semantically gates "logically
     // invisible cross-file" defs. C++ extends this to also reject class-

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

@@ -261,7 +261,7 @@
  * Plan that introduced most of these invariants:
  * `docs/plans/2026-04-20-001-refactor-emit-pipeline-generalization-plan.md`.
  */
-import type { BindingRef, Callsite, ConstraintContext, ParsedFile, ScopeId, SupportedLanguages, SymbolDefinition } from '../../../../_shared/index.js';
+import type { BindingRef, Callsite, ConstraintContext, ParsedFile, ReferenceSite, ScopeId, SupportedLanguages, SymbolDefinition } from '../../../../_shared/index.js';
 import type { KnowledgeGraph } from '../../../graph/types.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { LanguageProvider } from '../../language-provider.js';
@@ -275,6 +275,13 @@ import type { ConversionRankFn } from '../passes/overload-narrowing.js';
 export type LinearizeStrategy = (classDefId: string, directParents: readonly string[], parentsByDefId: ReadonlyMap<string, readonly string[]>) => string[];
 /** Result of `ScopeResolver.arityCompatibility` — mirrors `RegistryProviders.arityCompatibility`. */
 export type ArityVerdict = 'compatible' | 'unknown' | 'incompatible';
+export type ReceiverMemberResolution = {
+    readonly kind: 'resolved';
+    readonly definition: SymbolDefinition;
+} | {
+    readonly kind: 'ambiguous';
+    readonly candidateIds: readonly string[];
+};
 /** Re-exported for ScopeResolver consumers — same shape as
  *  `RegistryProviders.constraintCompatibility`'s third parameter. */
 export type { ConstraintContext } from '../../../../_shared/index.js';
@@ -367,7 +374,7 @@ export interface ScopeResolver {
      * C++ is the first consumer; see `languages/cpp/constraint-filter.ts`
      * for the Tier-A predicate registry and Kleene 3-valued evaluator.
      */
-    readonly constraintCompatibility?: (callsite: Callsite, def: SymbolDefinition, ctx: ConstraintContext) => ArityVerdict;
+    readonly constraintCompatibility?: (callsite: ReferenceSite, def: SymbolDefinition, ctx: ConstraintContext) => ArityVerdict;
     /**
      * Compute the method-dispatch order for every Class def in the
      * workspace. Python uses depth-first first-seen via
@@ -730,6 +737,14 @@ export interface ScopeResolver {
      * `undefined` to fall through to the remaining cases.
      */
     readonly resolveQualifiedReceiverMember?: (receiverName: string, memberName: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], callsite?: Callsite) => SymbolDefinition | 'ambiguous' | undefined;
+    /**
+     * Optional language-specific member-lattice lookup. Runs for a resolved
+     * simple receiver type before the generic flattened-MRO walk. Languages
+     * with lookup-set semantics that cannot be represented by one linear MRO
+     * may resolve a member, report ambiguity (which suppresses fallback), or
+     * return undefined to retain the shared behavior.
+     */
+    readonly resolveReceiverMember?: (ownerDef: SymbolDefinition, memberName: string, callsite: Callsite, scopes: ScopeResolutionIndexes, model: SemanticModel) => ReceiverMemberResolution | undefined;
     /**
      * Enable the receiver-bound Case 0.5 fallback for explicit `this`
      * receivers (`this->m()` / `this.m()`) that resolves against the