cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearCppMemberLookupState = clearCppMemberLookupState;
+exports.captureCppMemberLookupFacts = captureCppMemberLookupFacts;
+exports.collectCppMemberLookupSideChannel = collectCppMemberLookupSideChannel;
+exports.applyCppMemberLookupSideChannel = applyCppMemberLookupSideChannel;
+exports.buildCppMemberLookupMro = buildCppMemberLookupMro;
+exports.resolveCppReceiverMember = resolveCppReceiverMember;
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const overload_narrowing_js_1 = require("../../scope-resolution/passes/overload-narrowing.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const constraint_filter_js_1 = require("./constraint-filter.js");
+const conversion_rank_js_1 = require("./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;
+function clearCppMemberLookupState() {
+    capturedByFile.clear();
+    directParentsByDefId = new Map();
+    virtualEdges = new Set();
+    ancestorsByDefId = new Map();
+    memberUsingsByDefId = new Map();
+    inheritedLookupCache = new Map();
+}
+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 });
+    }
+}
+function collectCppMemberLookupSideChannel(filePath) {
+    return capturedByFile.get(filePath) ?? { baseEdges: [], memberUsings: [] };
+}
+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(),
+    });
+}
+function buildCppMemberLookupMro(graph, parsedFiles, nodeLookup) {
+    populateResolvedHierarchy(graph, parsedFiles, nodeLookup);
+    return (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+}
+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 = (0, overload_narrowing_js_1.narrowOverloadCandidates)(candidates, callsite.arity, callsite.argumentTypes, {
+        argumentTypeClasses: callsite.argumentTypeClasses,
+        conversionRankFn: conversion_rank_js_1.cppConversionRank,
+        conversionOnlyArgTypePrefixes: conversion_rank_js_1.CPP_CONVERSION_ONLY_ARG_TYPE_PREFIXES,
+        constraintCompatibility: constraint_filter_js_1.cppConstraintCompatibility,
+    });
+    if (narrowed.length === 1)
+        return { kind: 'resolved', definition: narrowed[0] };
+    if (narrowed.length > 1 || (0, overload_narrowing_js_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 (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.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/code/engine/core/ingestion/languages/cpp/merge-bindings.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppMergeBindings = cppMergeBindings;
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+/**
+ * C++ merge bindings: first-wins by tier.
+ *
+ * C++ tier precedence:
+ *   local(0) > namespace(1) > import(2) > reexport(3) > wildcard(4)
+ *
+ * Unlike C (no namespaces), C++ uses the `namespace` tier for symbols
+ * brought in via `using namespace X;` that are then locally referenced.
+ * The tier ordering ensures local definitions shadow namespace imports,
+ * which in turn shadow wildcard #include imports.
+ */
+function cppMergeBindings(existing, incoming, _scopeId) {
+    const seen = new Set();
+    return [...existing, ...incoming]
+        .sort((a, b) => (TIER[a.origin] ?? 99) - (TIER[b.origin] ?? 99) || a.def.nodeId.localeCompare(b.def.nodeId))
+        .filter((binding) => {
+        if (seen.has(binding.def.nodeId))
+            return false;
+        seen.add(binding.def.nodeId);
+        return true;
+    });
+}