@zuvia-software-solutions/code-mapper 1.4.0

package/dist/core/ingestion/mro-processor.js

@@ -0,0 +1,343 @@
+// code-mapper/src/core/ingestion/mro-processor.ts
+/**
+ * @file mro-processor.ts
+ * @description Walks the inheritance DAG, collects methods from ancestors via HAS_METHOD
+ * edges, detects method-name collisions, and emits OVERRIDES edges using language-specific
+ * resolution rules (C++ leftmost base, C#/Java class-over-interface, Python C3 linearization,
+ * Rust requires qualified syntax). OVERRIDES edge direction: Class -> winning ancestor Method
+ */
+import { generateId } from '../../lib/utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/** Collect EXTENDS, IMPLEMENTS, and HAS_METHOD adjacency from the graph */
+function buildAdjacency(graph) {
+    // childId -> parentIds[] (in declaration order)
+    const parentMap = new Map();
+    // classId -> methodIds[]
+    const methodMap = new Map();
+    // Track which edge type each parent link came from
+    const parentEdgeType = new Map();
+    graph.forEachRelationship((rel) => {
+        if (rel.type === 'EXTENDS' || rel.type === 'IMPLEMENTS') {
+            let parents = parentMap.get(rel.sourceId);
+            if (!parents) {
+                parents = [];
+                parentMap.set(rel.sourceId, parents);
+            }
+            parents.push(rel.targetId);
+            let edgeTypes = parentEdgeType.get(rel.sourceId);
+            if (!edgeTypes) {
+                edgeTypes = new Map();
+                parentEdgeType.set(rel.sourceId, edgeTypes);
+            }
+            edgeTypes.set(rel.targetId, rel.type);
+        }
+        if (rel.type === 'HAS_METHOD') {
+            let methods = methodMap.get(rel.sourceId);
+            if (!methods) {
+                methods = [];
+                methodMap.set(rel.sourceId, methods);
+            }
+            methods.push(rel.targetId);
+        }
+    });
+    return { parentMap, methodMap, parentEdgeType };
+}
+/** Gather all ancestor IDs in BFS order, excluding the class itself */
+function gatherAncestors(classId, parentMap) {
+    const visited = new Set();
+    const order = [];
+    const queue = [...(parentMap.get(classId) ?? [])];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        order.push(id);
+        const grandparents = parentMap.get(id);
+        if (grandparents) {
+            for (const gp of grandparents) {
+                if (!visited.has(gp))
+                    queue.push(gp);
+            }
+        }
+    }
+    return order;
+}
+/**
+ * Compute C3 linearization for Python MRO
+ *
+ * Returns ancestor IDs in C3 order, or null if linearization fails (cycle/inconsistency)
+ */
+function c3Linearize(classId, parentMap, cache, inProgress) {
+    if (cache.has(classId))
+        return cache.get(classId);
+    // Cycle detection: if we're already computing this class, the hierarchy is cyclic
+    const visiting = inProgress ?? new Set();
+    if (visiting.has(classId)) {
+        cache.set(classId, null);
+        return null;
+    }
+    visiting.add(classId);
+    const directParents = parentMap.get(classId);
+    if (!directParents || directParents.length === 0) {
+        visiting.delete(classId);
+        cache.set(classId, []);
+        return [];
+    }
+    // Compute linearization for each parent first
+    const parentLinearizations = [];
+    for (const pid of directParents) {
+        const pLin = c3Linearize(pid, parentMap, cache, visiting);
+        if (pLin === null) {
+            visiting.delete(classId);
+            cache.set(classId, null);
+            return null;
+        }
+        parentLinearizations.push([pid, ...pLin]);
+    }
+    // Add the direct parents list as the final sequence
+    const sequences = [...parentLinearizations, [...directParents]];
+    const result = [];
+    while (sequences.some(s => s.length > 0)) {
+        // Find a good head: one that doesn't appear in the tail of any other sequence
+        let head = null;
+        for (const seq of sequences) {
+            if (seq.length === 0)
+                continue;
+            const candidate = seq[0];
+            const inTail = sequences.some(other => other.length > 1 && other.indexOf(candidate, 1) !== -1);
+            if (!inTail) {
+                head = candidate;
+                break;
+            }
+        }
+        if (head === null) {
+            // Inconsistent hierarchy
+            visiting.delete(classId);
+            cache.set(classId, null);
+            return null;
+        }
+        result.push(head);
+        // Remove the chosen head from all sequences
+        for (const seq of sequences) {
+            if (seq.length > 0 && seq[0] === head) {
+                seq.shift();
+            }
+        }
+    }
+    visiting.delete(classId);
+    cache.set(classId, result);
+    return result;
+}
+/** Resolve by MRO order — first ancestor in linearized order wins */
+function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
+    for (const ancestorId of mroOrder) {
+        const match = defs.find(d => d.classId === ancestorId);
+        if (match) {
+            return {
+                resolvedTo: match.methodId,
+                reason: `${reasonPrefix}: ${match.className}::${methodName}`,
+            };
+        }
+    }
+    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` };
+}
+function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
+    const classDefs = [];
+    const interfaceDefs = [];
+    for (const def of defs) {
+        const edgeType = parentEdgeTypes?.get(def.classId);
+        if (edgeType === 'IMPLEMENTS') {
+            interfaceDefs.push(def);
+        }
+        else {
+            classDefs.push(def);
+        }
+    }
+    if (classDefs.length > 0) {
+        return {
+            resolvedTo: classDefs[0].methodId,
+            reason: `class method wins: ${classDefs[0].className}::${methodName}`,
+        };
+    }
+    if (interfaceDefs.length > 1) {
+        return {
+            resolvedTo: null,
+            reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`,
+        };
+    }
+    if (interfaceDefs.length === 1) {
+        return {
+            resolvedTo: interfaceDefs[0].methodId,
+            reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`,
+        };
+    }
+    return { resolvedTo: null, reason: 'no resolution found' };
+}
+export function computeMRO(graph) {
+    const { parentMap, methodMap, parentEdgeType } = buildAdjacency(graph);
+    const c3Cache = new Map();
+    const entries = [];
+    let overrideEdges = 0;
+    let ambiguityCount = 0;
+    // Process every class that has at least one parent
+    for (const [classId, directParents] of parentMap) {
+        if (directParents.length === 0)
+            continue;
+        const classNode = graph.getNode(classId);
+        if (!classNode)
+            continue;
+        const language = classNode.properties.language;
+        if (!language)
+            continue;
+        const className = classNode.properties.name;
+        // Compute linearized MRO depending on language
+        let mroOrder;
+        if (language === SupportedLanguages.Python) {
+            const c3Result = c3Linearize(classId, parentMap, c3Cache);
+            mroOrder = c3Result ?? gatherAncestors(classId, parentMap);
+        }
+        else {
+            mroOrder = gatherAncestors(classId, parentMap);
+        }
+        // Get the parent names for the MRO entry
+        const mroNames = mroOrder
+            .map(id => graph.getNode(id)?.properties.name)
+            .filter((n) => n !== undefined);
+        // Collect methods from all ancestors, grouped by method name
+        const methodsByName = new Map();
+        for (const ancestorId of mroOrder) {
+            const ancestorNode = graph.getNode(ancestorId);
+            if (!ancestorNode)
+                continue;
+            const methods = methodMap.get(ancestorId) ?? [];
+            for (const methodId of methods) {
+                const methodNode = graph.getNode(methodId);
+                if (!methodNode)
+                    continue;
+                // Properties don't participate in MRO
+                if (methodNode.label === 'Property')
+                    continue;
+                const methodName = methodNode.properties.name;
+                let defs = methodsByName.get(methodName);
+                if (!defs) {
+                    defs = [];
+                    methodsByName.set(methodName, defs);
+                }
+                // Avoid duplicates (same method seen via multiple paths)
+                if (!defs.some(d => d.methodId === methodId)) {
+                    defs.push({
+                        classId: ancestorId,
+                        className: ancestorNode.properties.name,
+                        methodId,
+                    });
+                }
+            }
+        }
+        // Detect collisions: methods defined in 2+ different ancestors
+        const ambiguities = [];
+        // Compute transitive edge types once per class (only needed for C#/Java)
+        const needsEdgeTypes = language === SupportedLanguages.CSharp || language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin;
+        const classEdgeTypes = needsEdgeTypes
+            ? buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType)
+            : undefined;
+        for (const [methodName, defs] of methodsByName) {
+            if (defs.length < 2)
+                continue;
+            // Own method shadows inherited — no ambiguity
+            const ownMethods = methodMap.get(classId) ?? [];
+            const ownDefinesIt = ownMethods.some(mid => {
+                const mn = graph.getNode(mid);
+                return mn?.properties.name === methodName;
+            });
+            if (ownDefinesIt)
+                continue;
+            let resolution;
+            switch (language) {
+                case SupportedLanguages.CPlusPlus:
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C++ leftmost base');
+                    break;
+                case SupportedLanguages.CSharp:
+                case SupportedLanguages.Java:
+                case SupportedLanguages.Kotlin:
+                    resolution = resolveCsharpJava(methodName, defs, classEdgeTypes);
+                    break;
+                case SupportedLanguages.Python:
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'Python C3 MRO');
+                    break;
+                case SupportedLanguages.Rust:
+                    resolution = {
+                        resolvedTo: null,
+                        reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`,
+                    };
+                    break;
+                default:
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'first definition');
+                    break;
+            }
+            const ambiguity = {
+                methodName,
+                definedIn: defs,
+                resolvedTo: resolution.resolvedTo,
+                reason: resolution.reason,
+            };
+            ambiguities.push(ambiguity);
+            if (resolution.resolvedTo === null) {
+                ambiguityCount++;
+            }
+            // Emit OVERRIDES edge if resolution found
+            if (resolution.resolvedTo !== null) {
+                graph.addRelationship({
+                    id: generateId('OVERRIDES', `${classId}->${resolution.resolvedTo}`),
+                    sourceId: classId,
+                    targetId: resolution.resolvedTo,
+                    type: 'OVERRIDES',
+                    confidence: 1.0,
+                    reason: resolution.reason,
+                });
+                overrideEdges++;
+            }
+        }
+        entries.push({
+            classId,
+            className,
+            language,
+            mro: mroNames,
+            ambiguities,
+        });
+    }
+    return { entries, overrideEdges, ambiguityCount };
+}
+/**
+ * Build transitive edge types for a class via BFS to all ancestors
+ *
+ * Known limitation: BFS first-reach heuristic can misclassify an interface as
+ * EXTENDS if reachable via a class chain before IMPLEMENTS in rare diamond hierarchies
+ */
+function buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType) {
+    const result = new Map();
+    const directEdges = parentEdgeType.get(classId);
+    if (!directEdges)
+        return result;
+    // BFS: propagate edge type from direct parents
+    const queue = [];
+    const directParents = parentMap.get(classId) ?? [];
+    for (const pid of directParents) {
+        const et = directEdges.get(pid) ?? 'EXTENDS';
+        if (!result.has(pid)) {
+            result.set(pid, et);
+            queue.push({ id: pid, edgeType: et });
+        }
+    }
+    while (queue.length > 0) {
+        const { id, edgeType } = queue.shift();
+        const grandparents = parentMap.get(id) ?? [];
+        for (const gp of grandparents) {
+            if (!result.has(gp)) {
+                result.set(gp, edgeType);
+                queue.push({ id: gp, edgeType });
+            }
+        }
+    }
+    return result;
+}

package/dist/core/ingestion/named-binding-extraction.d.ts

@@ -0,0 +1,51 @@
+/** @file named-binding-extraction.ts @description Extracts named import bindings from AST import nodes and walks re-export chains through NamedImportMap to resolve barrel file indirection */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
+import type { NamedImportMap } from './import-processor.js';
+/**
+ * Walk a named-binding re-export chain through NamedImportMap
+ *
+ * Follows A->B->C chains until a definition is found (max depth 5)
+ * Returns null if the chain breaks (missing binding, circular reference, or depth exceeded)
+ *
+ * @param allDefs - Complete unfiltered lookupFuzzy(name) result; file-filtered subsets cause silent misses
+ */
+export declare function walkBindingChain(name: string, currentFilePath: string, symbolTable: SymbolTable, namedImportMap: NamedImportMap, allDefs: SymbolDefinition[]): SymbolDefinition[] | null;
+/**
+ * Extract named bindings from an import AST node
+ *
+ * Returns undefined for non-named imports (import *, default, side-effect)
+ * Example: `import { User, Repo as R }` -> [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
+ */
+export declare function extractNamedBindings(importNode: any, language: SupportedLanguages): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractTsNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractPythonNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractKotlinNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractRustNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractPhpNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractCsharpNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;
+export declare function extractJavaNamedBindings(importNode: any): {
+    local: string;
+    exported: string;
+}[] | undefined;