cgraphx 2.0.2 → 2.0.3

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

@@ -0,0 +1,506 @@
+"use strict";
+/**
+ * C and C++ language providers.
+ *
+ * Both languages use wildcard import semantics (headers expose all symbols
+ * via #include). Neither language has named binding extraction.
+ *
+ * C uses 'first-wins' MRO (no inheritance). C++ uses 'leftmost-base' MRO
+ * for its left-to-right multiple inheritance resolution order.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cppProvider = exports.cProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const c_cpp_js_1 = require("../class-extractors/configs/c-cpp.js");
+const language_provider_js_1 = require("../language-provider.js");
+const c_cpp_js_2 = require("../type-extractors/c-cpp.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const c_cpp_js_3 = require("../import-resolvers/configs/c-cpp.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+/**
+ * Node types for standard function declarations that need C/C++ declarator handling.
+ * Used by cCppExtractFunctionName to determine how to extract the function name.
+ */
+const FUNCTION_DECLARATION_TYPES = new Set([
+    'function_declaration',
+    'function_definition',
+    'async_function_declaration',
+    'generator_function_declaration',
+    'function_item',
+]);
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const c_cpp_js_4 = require("../field-extractors/configs/c-cpp.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const c_cpp_js_5 = require("../method-extractors/configs/c-cpp.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const c_cpp_js_6 = require("../variable-extractors/configs/c-cpp.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const c_cpp_js_7 = require("../call-extractors/configs/c-cpp.js");
+const cpp_ue_preprocessor_js_1 = require("../cpp-ue-preprocessor.js");
+const index_js_2 = require("./c/index.js");
+const index_js_3 = require("./cpp/index.js");
+const constraint_extractor_js_1 = require("./cpp/constraint-extractor.js");
+const clone_safety_js_1 = require("../workers/clone-safety.js");
+const c_cpp_js_8 = require("../cfg/visitors/c-cpp.js");
+const C_BUILT_INS = new Set([
+    'printf',
+    'fprintf',
+    'sprintf',
+    'snprintf',
+    'vprintf',
+    'vfprintf',
+    'vsprintf',
+    'vsnprintf',
+    'scanf',
+    'fscanf',
+    'sscanf',
+    'malloc',
+    'calloc',
+    'realloc',
+    'free',
+    'memcpy',
+    'memmove',
+    'memset',
+    'memcmp',
+    'strlen',
+    'strcpy',
+    'strncpy',
+    'strcat',
+    'strncat',
+    'strcmp',
+    'strncmp',
+    'strstr',
+    'strchr',
+    'strrchr',
+    'atoi',
+    'atol',
+    'atof',
+    'strtol',
+    'strtoul',
+    'strtoll',
+    'strtoull',
+    'strtod',
+    'sizeof',
+    'offsetof',
+    'typeof',
+    'assert',
+    'abort',
+    'exit',
+    '_exit',
+    'fopen',
+    'fclose',
+    'fread',
+    'fwrite',
+    'fseek',
+    'ftell',
+    'rewind',
+    'fflush',
+    'fgets',
+    'fputs',
+    'likely',
+    'unlikely',
+    'BUG',
+    'BUG_ON',
+    'WARN',
+    'WARN_ON',
+    'WARN_ONCE',
+    'IS_ERR',
+    'PTR_ERR',
+    'ERR_PTR',
+    'IS_ERR_OR_NULL',
+    'ARRAY_SIZE',
+    'container_of',
+    'list_for_each_entry',
+    'list_for_each_entry_safe',
+    'min',
+    'max',
+    'clamp',
+    'abs',
+    'swap',
+    'pr_info',
+    'pr_warn',
+    'pr_err',
+    'pr_debug',
+    'pr_notice',
+    'pr_crit',
+    'pr_emerg',
+    'printk',
+    'dev_info',
+    'dev_warn',
+    'dev_err',
+    'dev_dbg',
+    'GFP_KERNEL',
+    'GFP_ATOMIC',
+    'spin_lock',
+    'spin_unlock',
+    'spin_lock_irqsave',
+    'spin_unlock_irqrestore',
+    'mutex_lock',
+    'mutex_unlock',
+    'mutex_init',
+    'kfree',
+    'kmalloc',
+    'kzalloc',
+    'kcalloc',
+    'krealloc',
+    'kvmalloc',
+    'kvfree',
+    'get',
+    'put',
+]);
+const cClassExtractor = (0, generic_js_1.createClassExtractor)(c_cpp_js_1.cClassConfig);
+const cppClassExtractor = (0, generic_js_1.createClassExtractor)(c_cpp_js_1.cppClassConfig);
+/**
+ * C/C++ function name extraction — unwraps pointer_declarator / reference_declarator /
+ * function_declarator / qualified_identifier chains to find the actual function name.
+ * Handles field_identifier (method inside class body) and parenthesized_declarator.
+ */
+const cCppExtractFunctionName = (node) => {
+    if (!FUNCTION_DECLARATION_TYPES.has(node.type))
+        return null;
+    let funcName = null;
+    let label = 'Function';
+    // C/C++: function_definition -> [pointer_declarator ->] function_declarator -> qualified_identifier/identifier
+    // Unwrap pointer_declarator / reference_declarator wrappers to reach function_declarator
+    let declarator = node.childForFieldName?.('declarator');
+    if (!declarator) {
+        for (let i = 0; i < node.childCount; i++) {
+            const c = node.child(i);
+            if (c?.type === 'function_declarator') {
+                declarator = c;
+                break;
+            }
+        }
+    }
+    while (declarator &&
+        (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator')) {
+        let nextDeclarator = declarator.childForFieldName?.('declarator');
+        if (!nextDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'function_declarator' ||
+                    c?.type === 'pointer_declarator' ||
+                    c?.type === 'reference_declarator') {
+                    nextDeclarator = c;
+                    break;
+                }
+            }
+        }
+        declarator = nextDeclarator;
+    }
+    if (declarator) {
+        let innerDeclarator = declarator.childForFieldName?.('declarator');
+        if (!innerDeclarator) {
+            for (let i = 0; i < declarator.childCount; i++) {
+                const c = declarator.child(i);
+                if (c?.type === 'qualified_identifier' ||
+                    c?.type === 'identifier' ||
+                    c?.type === 'field_identifier' ||
+                    c?.type === 'operator_name' ||
+                    c?.type === 'parenthesized_declarator') {
+                    innerDeclarator = c;
+                    break;
+                }
+            }
+        }
+        if (innerDeclarator?.type === 'qualified_identifier') {
+            let nameNode = innerDeclarator.childForFieldName?.('name');
+            if (!nameNode) {
+                for (let i = 0; i < innerDeclarator.childCount; i++) {
+                    const c = innerDeclarator.child(i);
+                    if (c?.type === 'identifier' || c?.type === 'operator_name') {
+                        nameNode = c;
+                        break;
+                    }
+                }
+            }
+            if (nameNode?.text) {
+                funcName = nameNode.text;
+                label = 'Method';
+            }
+        }
+        else if (innerDeclarator?.type === 'identifier' ||
+            innerDeclarator?.type === 'field_identifier' ||
+            innerDeclarator?.type === 'operator_name') {
+            // field_identifier is used for method names inside C++ class bodies
+            funcName = innerDeclarator.text;
+            if (innerDeclarator.type === 'field_identifier')
+                label = 'Method';
+        }
+        else if (innerDeclarator?.type === 'parenthesized_declarator') {
+            let nestedId = null;
+            for (let i = 0; i < innerDeclarator.childCount; i++) {
+                const c = innerDeclarator.child(i);
+                if (c?.type === 'qualified_identifier' || c?.type === 'identifier') {
+                    nestedId = c;
+                    break;
+                }
+            }
+            if (nestedId?.type === 'qualified_identifier') {
+                let nameNode = nestedId.childForFieldName?.('name');
+                if (!nameNode) {
+                    for (let i = 0; i < nestedId.childCount; i++) {
+                        const c = nestedId.child(i);
+                        if (c?.type === 'identifier' || c?.type === 'operator_name') {
+                            nameNode = c;
+                            break;
+                        }
+                    }
+                }
+                if (nameNode?.text) {
+                    funcName = nameNode.text;
+                    label = 'Method';
+                }
+            }
+            else if (nestedId?.type === 'identifier') {
+                funcName = nestedId.text;
+            }
+        }
+    }
+    // Fallback for other node types in FUNCTION_DECLARATION_TYPES (e.g. function_item for Rust in C++ tree)
+    if (!funcName) {
+        let nameNode = node.childForFieldName?.('name');
+        if (!nameNode) {
+            for (let i = 0; i < node.childCount; i++) {
+                const c = node.child(i);
+                if (c?.type === 'identifier' ||
+                    c?.type === 'property_identifier' ||
+                    c?.type === 'simple_identifier') {
+                    nameNode = c;
+                    break;
+                }
+            }
+        }
+        funcName = nameNode?.text ?? null;
+    }
+    return { funcName, label };
+};
+/** Check if a C/C++ function_definition is inside a class or struct body
+ *  (and NOT a friend declaration).
+ *  Used by cppLabelOverride to skip duplicate function captures
+ *  that are already covered by definition.method queries.
+ *  Friend functions are free functions defined inside class bodies —
+ *  they must NOT be skipped (ISO C++ hidden-friend idiom). */
+function isCppInsideClassOrStruct(functionNode) {
+    let ancestor = functionNode?.parent ?? null;
+    while (ancestor) {
+        // Friend declarations: the function_definition is wrapped in
+        // `friend_declaration` → `field_declaration_list` → class_specifier.
+        // These are free functions, not methods — don't skip them.
+        if (ancestor.type === 'friend_declaration')
+            return false;
+        if (ancestor.type === 'class_specifier' || ancestor.type === 'struct_specifier')
+            return true;
+        ancestor = ancestor.parent;
+    }
+    return false;
+}
+/** Label override shared by C and C++: skip function_definition captures inside class/struct
+ *  bodies (they're duplicates of definition.method captures). */
+const cppLabelOverride = (functionNode, defaultLabel) => {
+    if (defaultLabel !== 'Function')
+        return defaultLabel;
+    return isCppInsideClassOrStruct(functionNode) ? null : defaultLabel;
+};
+exports.cProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.C,
+    extensions: ['.c'],
+    entryPointPatterns: [
+        /^main$/,
+        /^init_/,
+        /_init$/,
+        /^start_/,
+        /_start$/,
+        /^run_/,
+        /_run$/,
+        /^stop_/,
+        /_stop$/,
+        /^open_/,
+        /_open$/,
+        /^close_/,
+        /_close$/,
+        /^create_/,
+        /_create$/,
+        /^destroy_/,
+        /_destroy$/,
+        /^handle_/,
+        /_handler$/,
+        /_callback$/,
+        /^cmd_/,
+        /^server_/,
+        /^client_/,
+        /^session_/,
+        /^window_/,
+        /^key_/,
+        /^input_/,
+        /^output_/,
+        /^notify_/,
+        /^control_/,
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.C_QUERIES,
+    typeConfig: c_cpp_js_2.typeConfig,
+    exportChecker: export_detection_js_1.cCppExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(c_cpp_js_3.cImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(c_cpp_js_7.cCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(c_cpp_js_4.cConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...c_cpp_js_5.cMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(c_cpp_js_6.cVariableConfig),
+    classExtractor: cClassExtractor,
+    // ── Doxygen doc comment → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    emitScopeCaptures: index_js_2.emitCScopeCaptures,
+    cfgVisitor: (0, c_cpp_js_8.createCCfgVisitor)(),
+    // Worker-side: snapshot the module-level `static`-linkage marks
+    // `emitCScopeCaptures` just populated for this file (`markStaticName` →
+    // `staticNames`) into plain data on `ParsedFile.captureSideChannel`, so the
+    // main thread can restore them via `applyCaptureSideChannel` WITHOUT a
+    // re-parse (#1983 — the worker is the sole parse path). Without this, C
+    // `static` functions look non-file-local on the main thread and leak into
+    // cross-file global free-call resolution / wildcard imports. See
+    // `c/capture-side-channel.ts`.
+    // `assertCloneable` is a runtime identity; it makes a future non-serializable
+    // value in the side-channel payload a compile error here, at the source, rather
+    // than a DataCloneError at the worker boundary (#2143).
+    collectCaptureSideChannel: (filePath) => (0, clone_safety_js_1.assertCloneable)((0, index_js_2.collectCStaticLinkageSideChannel)(filePath)),
+    interpretImport: index_js_2.interpretCImport,
+    interpretTypeBinding: index_js_2.interpretCTypeBinding,
+    bindingScopeFor: index_js_2.cBindingScopeFor,
+    importOwningScope: index_js_2.cImportOwningScope,
+    receiverBinding: index_js_2.cReceiverBinding,
+    arityCompatibility: index_js_2.cArityCompatibility,
+    // mergeBindings + resolveImportTarget live on ScopeResolver (see c/scope-resolver.ts).
+});
+exports.cppProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.CPlusPlus,
+    // CUDA files route through tree-sitter-cpp as a conservative C++-subset parser:
+    // definitions still extract, but CUDA launch syntax (`<<< >>>`) is not modeled as calls.
+    extensions: ['.cpp', '.cc', '.cxx', '.h', '.hpp', '.hxx', '.hh', '.cu', '.cuh'],
+    entryPointPatterns: [
+        /^main$/,
+        /^init_/,
+        /_init$/,
+        /^Create[A-Z]/,
+        /^create_/,
+        /^Run$/,
+        /^run$/,
+        /^Start$/,
+        /^start$/,
+        /^handle_/,
+        /_handler$/,
+        /_callback$/,
+        /^OnEvent/,
+        /^on_/,
+        /::Run$/,
+        /::Start$/,
+        /::Init$/,
+        /::Execute$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'qt',
+            entryPointMultiplier: 2.8,
+            reason: 'qt-macro',
+            patterns: [
+                'Q_OBJECT',
+                'Q_INVOKABLE',
+                'Q_PROPERTY',
+                'Q_SIGNALS',
+                'Q_SLOTS',
+                'Q_SIGNAL',
+                'Q_SLOT',
+                'QWidget',
+                'QApplication',
+            ],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.CPP_QUERIES,
+    preprocessSource: cpp_ue_preprocessor_js_1.stripUeMacros,
+    typeConfig: c_cpp_js_2.typeConfig,
+    exportChecker: export_detection_js_1.cCppExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(c_cpp_js_3.cppImportConfig),
+    mroStrategy: 'leftmost-base',
+    callExtractor: (0, generic_js_5.createCallExtractor)(c_cpp_js_7.cppCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(c_cpp_js_4.cppConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...c_cpp_js_5.cppMethodConfig,
+        extractFunctionName: cCppExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(c_cpp_js_6.cppVariableConfig),
+    classExtractor: cppClassExtractor,
+    // ── Doxygen doc comment → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    labelOverride: cppLabelOverride,
+    builtInNames: C_BUILT_INS,
+    extractTemplateConstraints: extractCppTemplateConstraintsForProvider,
+    // ── RFC #909 Ring 3: scope-based resolution hooks (RFC §5) ──────────
+    emitScopeCaptures: index_js_3.emitCppScopeCaptures,
+    cfgVisitor: (0, c_cpp_js_8.createCppCfgVisitor)(),
+    // Worker-side: snapshot the module-level capture marks `emitCppScopeCaptures`
+    // just populated for this file into plain data on `ParsedFile.captureSideChannel`,
+    // so the main thread can restore them via `applyCaptureSideChannel` WITHOUT a
+    // re-parse (#1983). See `cpp/capture-side-channel.ts`.
+    collectCaptureSideChannel: (filePath) => (0, clone_safety_js_1.assertCloneable)((0, index_js_3.collectCppCaptureSideChannel)(filePath)),
+    interpretImport: index_js_3.interpretCppImport,
+    interpretTypeBinding: index_js_3.interpretCppTypeBinding,
+    bindingScopeFor: index_js_3.cppBindingScopeFor,
+    importOwningScope: index_js_3.cppImportOwningScope,
+    receiverBinding: index_js_3.cppReceiverBinding,
+    arityCompatibility: index_js_3.cppArityCompatibility,
+    // mergeBindings + resolveImportTarget live on ScopeResolver (see cpp/scope-resolver.ts).
+});
+/**
+ * LanguageProvider hook: walk from a function definition node up to its
+ * enclosing `template_declaration` and extract the SFINAE / `requires`-
+ * clause constraint payload. Used by `parsing-processor` to fingerprint
+ * the graph node ID so two SFINAE overloads with identical
+ * `parameterTypes` get distinct nodes (issue #1579).
+ *
+ * Returns `undefined` for non-templated functions and for templated
+ * functions whose constraints the extractor can't model — both cases
+ * result in no constraint suffix on the node ID.
+ */
+function extractCppTemplateConstraintsForProvider(definitionNode) {
+    // Walk up to the enclosing template_declaration. Bound the walk so we
+    // can't accidentally land on a far-ancestor template_declaration that
+    // wraps an unrelated function.
+    let cur = definitionNode.parent;
+    let hops = 8;
+    let templateDecl = null;
+    while (cur !== null && hops-- > 0) {
+        if (cur.type === 'template_declaration') {
+            templateDecl = cur;
+            break;
+        }
+        if (cur.type === 'translation_unit')
+            break;
+        cur = cur.parent;
+    }
+    if (templateDecl === null)
+        return undefined;
+    // Find the function_declarator inside the function definition so the
+    // extractor can map template params to function-argument indices.
+    let declarator = definitionNode.childForFieldName('declarator');
+    let walk = 8;
+    while (declarator !== null && walk-- > 0) {
+        if (declarator.type === 'function_declarator')
+            break;
+        if (declarator.type === 'pointer_declarator' || declarator.type === 'reference_declarator') {
+            declarator = declarator.childForFieldName('declarator');
+            continue;
+        }
+        break;
+    }
+    // Guard the boundary at the source: a future non-cloneable member of the
+    // constraint payload becomes a compile error here, not a runtime
+    // DataCloneError at the worker post (#2143).
+    return (0, clone_safety_js_1.assertCloneable)((0, constraint_extractor_js_1.extractCppTemplateConstraints)(templateDecl, declarator));
+}