cgraphx 2.0.2 → 2.0.6

package/dist/core/code/engine/core/ingestion/languages/cpp/arity-metadata.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeCppDeclarationArity = computeCppDeclarationArity;
+exports.computeCppCallArity = computeCppCallArity;
+exports.normalizeCppParamType = normalizeCppParamType;
+exports.classifyCppParameterType = classifyCppParameterType;
+/**
+ * Compute declaration arity from a C++ function definition or declaration node.
+ * Extends the C arity computation with support for:
+ *   - optional_parameter_declaration (default parameters)
+ *   - variadic_parameter_declaration / parameter packs
+ *   - (void) explicit zero-parameter form
+ */
+function computeCppDeclarationArity(node) {
+    const funcDecl = findFuncDeclarator(node);
+    if (funcDecl === null)
+        return {};
+    const paramList = funcDecl.childForFieldName('parameters');
+    if (paramList === null)
+        return {};
+    const params = [];
+    // Track whether a C-style variadic `...` anonymous token appears.
+    // tree-sitter-cpp emits `...` as an anonymous (non-named) child of
+    // parameter_list, not as `variadic_parameter`.
+    let hasEllipsis = false;
+    for (let i = 0; i < paramList.childCount; i++) {
+        const child = paramList.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'parameter_declaration' ||
+            child.type === 'optional_parameter_declaration' ||
+            child.type === 'variadic_parameter_declaration') {
+            params.push(child);
+        }
+        else if (child.type === '...' || (!child.isNamed && child.text === '...')) {
+            hasEllipsis = true;
+        }
+    }
+    // Empty parameter list: C++ `void foo()` means zero params (unlike C)
+    if (params.length === 0 && !hasEllipsis) {
+        return { parameterCount: 0, requiredParameterCount: 0, parameterTypes: [] };
+    }
+    // (void) means zero parameters
+    if (params.length === 1 && params[0].type === 'parameter_declaration') {
+        const typeNode = params[0].childForFieldName('type');
+        const hasDeclarator = params[0].childForFieldName('declarator') !== null;
+        if (typeNode !== null && typeNode.text === 'void' && !hasDeclarator) {
+            return { parameterCount: 0, requiredParameterCount: 0, parameterTypes: [] };
+        }
+    }
+    // C-style variadic: `void foo(int x, ...)` — the `...` is an anonymous
+    // token in tree-sitter-cpp, detected via `hasEllipsis` above.
+    // C++ parameter packs: `template<typename... Ts> void foo(Ts... args)` —
+    // detected as `variadic_parameter_declaration`.
+    const isVariadic = hasEllipsis || params.some((p) => p.type === 'variadic_parameter_declaration');
+    const optionalCount = params.filter((p) => p.type === 'optional_parameter_declaration').length;
+    const requiredCount = params.filter((p) => p.type === 'parameter_declaration' ||
+        // variadic_parameter_declaration with a name is a parameter pack — counts as one
+        p.type === 'variadic_parameter_declaration').length;
+    const totalNonVariadic = requiredCount + optionalCount;
+    const types = [];
+    const typeClasses = [];
+    for (const p of params) {
+        if (p.type === 'variadic_parameter_declaration') {
+            // Parameter pack: treated as variadic
+            types.push('...');
+            typeClasses.push(unknownTypeClass('...'));
+        }
+        else {
+            const typeNode = p.childForFieldName('type');
+            const rawType = typeNode?.text ?? 'unknown';
+            types.push(normalizeCppParamType(rawType));
+            typeClasses.push(classifyCppParameterType(rawType, p.childForFieldName('declarator')?.text, p.text));
+        }
+    }
+    // Append '...' for C-style variadic if not already in types
+    if (hasEllipsis && !types.includes('...')) {
+        types.push('...');
+        typeClasses.push(unknownTypeClass('...'));
+    }
+    return {
+        parameterCount: isVariadic ? undefined : totalNonVariadic,
+        requiredParameterCount: requiredCount,
+        parameterTypes: types,
+        parameterTypeClasses: typeClasses,
+    };
+}
+/**
+ * Compute call-site arity from a call_expression node.
+ */
+function computeCppCallArity(node) {
+    const argList = node.childForFieldName('arguments');
+    if (argList === null)
+        return 0;
+    let count = 0;
+    for (let i = 0; i < argList.childCount; i++) {
+        const child = argList.child(i);
+        if (child === null)
+            continue;
+        if (child.type !== ',' && child.type !== '(' && child.type !== ')') {
+            count++;
+        }
+    }
+    return count;
+}
+/**
+ * Normalize a C++ parameter type for overload disambiguation.
+ * Maps common qualified/aliased types to their canonical short forms
+ * so that `narrowOverloadCandidates` can match against literal-inferred
+ * argument types (e.g. `inferCppLiteralType` returns `'string'` for
+ * string literals, not `'std::string'`).
+ *
+ * This intentionally remains coarse and graph-ID-stable: cv-qualifiers,
+ * reference markers, and pointer markers are stripped here. C++ callers
+ * that need those distinctions should read `parameterTypeClasses`, which
+ * is an additive sidecar and does not participate in overload node ID
+ * hashing.
+ */
+function normalizeCppParamType(raw) {
+    let t = raw.trim();
+    // Strip const, volatile, etc.
+    t = t.replace(/\b(const|volatile|restrict|mutable|constexpr)\b/g, '').trim();
+    // Strip reference/pointer markers
+    t = t.replace(/[&*]+\s*$/, '').trim();
+    // Strip template parameters (loop handles nested: Map<List<int>> → Map)
+    while (t.includes('<')) {
+        const stripped = t.replace(/<[^<>]*>/g, '');
+        if (stripped === t)
+            break; // avoid infinite loop on malformed input
+        t = stripped;
+    }
+    t = t.trim();
+    // Map std:: types to canonical short forms
+    const STD_MAP = {
+        'std::string': 'string',
+        'std::wstring': 'string',
+        'std::string_view': 'string',
+        string: 'string',
+        char: 'char',
+        int: 'int',
+        long: 'int',
+        short: 'int',
+        unsigned: 'int',
+        'unsigned int': 'int',
+        'long long': 'int',
+        size_t: 'int',
+        'std::size_t': 'int',
+        float: 'double',
+        double: 'double',
+        bool: 'bool',
+        nullptr_t: 'null',
+        'std::nullptr_t': 'null',
+    };
+    return STD_MAP[t] ?? t;
+}
+function classifyCppParameterType(rawType, declaratorText, fullParameterText) {
+    const source = fullParameterText ?? `${rawType} ${declaratorText ?? ''}`.trim();
+    if (rawType === 'unknown')
+        return unknownTypeClass('unknown');
+    const hasConst = /\bconst\b/.test(source);
+    const hasVolatile = /\bvolatile\b/.test(source);
+    const cv = hasConst && hasVolatile
+        ? 'const volatile'
+        : hasConst
+            ? 'const'
+            : hasVolatile
+                ? 'volatile'
+                : 'none';
+    const pointerDepth = (source.match(/\*/g) ?? []).length;
+    const indirection = pointerDepth > 0
+        ? 'pointer'
+        : /&&/.test(source)
+            ? 'rvalue-ref'
+            : /&/.test(source)
+                ? 'lvalue-ref'
+                : 'value';
+    return {
+        base: normalizeCppParamType(rawType),
+        cv,
+        indirection,
+        pointerDepth,
+        ...templateArgumentsFor(`${source} ${rawType} ${declaratorText ?? ''}`),
+    };
+}
+function unknownTypeClass(base) {
+    return {
+        base,
+        cv: 'unknown',
+        indirection: 'unknown',
+        pointerDepth: 0,
+    };
+}
+function templateArgumentsFor(rawType) {
+    const args = parseTopLevelTemplateArguments(rawType);
+    return args === undefined ? {} : { templateArguments: args };
+}
+function parseTopLevelTemplateArguments(rawType) {
+    const start = rawType.indexOf('<');
+    if (start < 0)
+        return undefined;
+    const args = [];
+    let depth = 0;
+    let argStart = start + 1;
+    for (let i = start + 1; i < rawType.length; i++) {
+        const ch = rawType[i];
+        if (ch === '<') {
+            depth++;
+        }
+        else if (ch === '>') {
+            if (depth === 0) {
+                const finalArg = rawType.slice(argStart, i).trim();
+                if (finalArg.length > 0)
+                    args.push(normalizeCppParamType(finalArg));
+                return args.length > 0 ? args : undefined;
+            }
+            depth--;
+        }
+        else if (ch === ',' && depth === 0) {
+            const arg = rawType.slice(argStart, i).trim();
+            if (arg.length > 0)
+                args.push(normalizeCppParamType(arg));
+            argStart = i + 1;
+        }
+    }
+    return undefined;
+}
+function findFuncDeclarator(node) {
+    let decl = node.childForFieldName('declarator');
+    if (decl === null) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator')
+                return c;
+        }
+        return null;
+    }
+    // Unwrap declarator wrappers. Deleted free functions are represented as
+    // `init_declarator(function_declarator, delete_expression)` by
+    // tree-sitter-cpp 0.23.
+    while (decl.type === 'pointer_declarator' ||
+        decl.type === 'reference_declarator' ||
+        decl.type === 'init_declarator') {
+        const next = decl.childForFieldName('declarator');
+        if (next === null) {
+            // reference_declarator may not use field name
+            for (let i = 0; i < decl.childCount; i++) {
+                const c = decl.child(i);
+                if (c?.type === 'function_declarator')
+                    return c;
+            }
+            break;
+        }
+        decl = next;
+    }
+    if (decl.type === 'function_declarator')
+        return decl;
+    return null;
+}

package/dist/core/code/engine/core/ingestion/languages/cpp/arity.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppArityCompatibility = cppArityCompatibility;
+/**
+ * C++ arity compatibility: supports overloading and default parameters.
+ *
+ * Unlike C (no overloading, exact match only), C++ has:
+ *   - Overloaded functions (same name, different signatures)
+ *   - Default parameters (requiredParameterCount < parameterCount)
+ *   - Variadic functions (C-style `...`)
+ *   - Parameter packs (V1: treated as variadic)
+ *   - Templates: arity check on non-template params; SFINAE / `requires`
+ *     constraints are filtered separately via `constraintCompatibility`
+ *     (see `constraint-filter.ts` and issue #1579). Type-argument generic
+ *     substitution (`List<T>` ≡ `List<U>`) remains out of V1 scope.
+ *
+ * Verdict:
+ *   - 'compatible':    callsite.arity fits within [required, total] range
+ *   - 'incompatible':  callsite.arity is outside the valid range
+ *   - 'unknown':       insufficient metadata to determine
+ */
+function cppArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    if (!Number.isFinite(callsite.arity) || callsite.arity < 0)
+        return 'unknown';
+    const variadic = def.parameterTypes?.some((t) => t === '...') ?? false;
+    // Too few arguments: less than the minimum required
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    // Too many arguments: more than the maximum and not variadic
+    if (max !== undefined && callsite.arity > max && !variadic)
+        return 'incompatible';
+    return 'compatible';
+}

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

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * C++ capture-time side-channel serialization (#1983).
+ *
+ * `emitCppScopeCaptures` populates several MODULE-LEVEL maps as a side effect
+ * that are NOT part of the returned `ParsedFile`'s scopes/defs:
+ *
+ *   - `argInfoBySite` / `noAdlSites`            (adl.ts)
+ *   - `inlineNamespaceRangesByFile`             (inline-namespaces.ts)
+ *   - `fileLocalNames` / `anonymousNamespaceRangesByFile` (file-local-linkage.ts)
+ *   - `dependentBasesByFile` / `dependentPackBaseClassesByFile` (two-phase-lookup.ts)
+ *
+ * On the worker path those maps are filled in the WORKER process and lost
+ * across the worker→main MessageChannel (and the disk-backed parsedfile-store),
+ * because scope-resolution reuses the serialized `ParsedFile` and SKIPS the
+ * main-thread re-extraction — the entire point of #1983 is to avoid a
+ * main-thread tree-sitter re-parse on huge `.h`/`.cpp` repos (the OOM).
+ *
+ * This module snapshots the per-file slice of those maps into a plain,
+ * JSON-serializable object (carried on `ParsedFile.captureSideChannel`) and
+ * restores it on the main thread WITHOUT any parse. It is the data-only
+ * replacement for the removed re-parse `replayCaptureSideChannel` hook.
+ *
+ * The derived state each `populateOwners` / `populateWorkspaceOwners` pass
+ * builds (resolved scope-id Sets, `dependentBaseNodeIds`, etc.) is recomputed
+ * on the main thread from these restored capture-time maps, so only the
+ * capture-time maps need to cross the boundary.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectCppCaptureSideChannel = collectCppCaptureSideChannel;
+exports.applyCppCaptureSideChannel = applyCppCaptureSideChannel;
+const adl_js_1 = require("./adl.js");
+const inline_namespaces_js_1 = require("./inline-namespaces.js");
+const file_local_linkage_js_1 = require("./file-local-linkage.js");
+const two_phase_lookup_js_1 = require("./two-phase-lookup.js");
+const member_lookup_js_1 = require("./member-lookup.js");
+/**
+ * `LanguageProvider.collectCaptureSideChannel` implementation for C++.
+ * Returns `undefined` when this file recorded no side-channel state at all, so
+ * the produced `ParsedFile` carries the field only when there's data to ship.
+ */
+function collectCppCaptureSideChannel(filePath) {
+    const adl = (0, adl_js_1.collectCppAdlSideChannel)(filePath);
+    const inlineNamespaceRanges = (0, inline_namespaces_js_1.collectCppInlineNamespaceSideChannel)(filePath);
+    const fileLocal = (0, file_local_linkage_js_1.collectCppFileLocalSideChannel)(filePath);
+    const twoPhase = (0, two_phase_lookup_js_1.collectCppTwoPhaseSideChannel)(filePath);
+    const memberLookup = (0, member_lookup_js_1.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 &&
+        memberLookup.baseEdges.length === 0 &&
+        memberLookup.memberUsings.length === 0;
+    if (isEmpty)
+        return undefined;
+    return { kind: 'cpp', adl, inlineNamespaceRanges, fileLocal, twoPhase, memberLookup };
+}
+/**
+ * `ScopeResolver.applyCaptureSideChannel` implementation for C++. Reads the
+ * worker-serialized snapshot from `parsed.captureSideChannel` and writes it
+ * back into the module-level maps. Tolerant of `undefined` (file carried no
+ * data) and of an unexpected shape (defensive — never throws on a malformed
+ * snapshot). Does NO tree-sitter parse.
+ */
+function applyCppCaptureSideChannel(parsed) {
+    const data = parsed.captureSideChannel;
+    if (data === undefined || data === null || typeof data !== 'object')
+        return;
+    // Discriminant guard — the generic `captureSideChannel` field is shared
+    // with C (`{ kind: 'c' }`) and Kotlin (`{ kind: 'kotlin' }`); cleanly
+    // ignore a non-C++ payload rather than mis-applying it.
+    if (data.kind !== 'cpp')
+        return;
+    if (data.adl !== undefined)
+        (0, adl_js_1.applyCppAdlSideChannel)(parsed.filePath, data.adl);
+    if (data.inlineNamespaceRanges !== undefined) {
+        (0, inline_namespaces_js_1.applyCppInlineNamespaceSideChannel)(parsed.filePath, data.inlineNamespaceRanges);
+    }
+    if (data.fileLocal !== undefined)
+        (0, file_local_linkage_js_1.applyCppFileLocalSideChannel)(parsed.filePath, data.fileLocal);
+    if (data.twoPhase !== undefined)
+        (0, two_phase_lookup_js_1.applyCppTwoPhaseSideChannel)(parsed.filePath, data.twoPhase);
+    if (data.memberLookup !== undefined) {
+        (0, member_lookup_js_1.applyCppMemberLookupSideChannel)(parsed.filePath, data.memberLookup);
+    }
+}