cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/c/interpret.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretCImport = interpretCImport;
+exports.interpretCTypeBinding = interpretCTypeBinding;
+exports.normalizeCTypeName = normalizeCTypeName;
+/**
+ * Interpret a C #include capture into a ParsedImport.
+ * C includes are always wildcard imports (all symbols from the header).
+ */
+function interpretCImport(captures) {
+    const source = captures['@import.source']?.text;
+    if (source === undefined)
+        return null;
+    // System headers (e.g. <stdio.h>) are not resolved to local files
+    if (captures['@import.system'] !== undefined)
+        return null;
+    return { kind: 'wildcard', targetRaw: source };
+}
+/**
+ * Interpret a C type-binding capture into a ParsedTypeBinding.
+ */
+function interpretCTypeBinding(captures) {
+    const name = captures['@type-binding.name']?.text;
+    const type = captures['@type-binding.type']?.text;
+    if (name === undefined || type === undefined)
+        return null;
+    let source = 'annotation';
+    if (captures['@type-binding.parameter'] !== undefined) {
+        source = 'parameter-annotation';
+    }
+    else if (captures['@type-binding.assignment'] !== undefined) {
+        source = 'assignment-inferred';
+    }
+    return { boundName: name, rawTypeName: normalizeCTypeName(type), source };
+}
+/**
+ * Normalize a C type name: strip pointer/array syntax, qualifiers.
+ */
+function normalizeCTypeName(text) {
+    let t = text.trim();
+    // Strip const, volatile, restrict qualifiers
+    t = t.replace(/\b(const|volatile|restrict|static|extern|inline)\b/g, '').trim();
+    // Strip pointer stars
+    while (t.endsWith('*'))
+        t = t.slice(0, -1).trim();
+    while (t.startsWith('*'))
+        t = t.slice(1).trim();
+    // Strip array brackets
+    t = t.replace(/\[.*?\]/g, '').trim();
+    // Strip struct/union/enum prefixes
+    t = t.replace(/^(struct|union|enum)\s+/, '');
+    return t;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cMergeBindings = cMergeBindings;
+const TIER = {
+    local: 0,
+    namespace: 1,
+    import: 2,
+    reexport: 3,
+    wildcard: 4,
+};
+/**
+ * C merge bindings: simple first-wins by tier (local > import > wildcard).
+ * C has no namespaces or reexports, but the tiers are defined for
+ * compatibility with the shared infrastructure.
+ */
+function cMergeBindings(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;
+    });
+}

package/dist/core/code/engine/core/ingestion/languages/c/query.js

@@ -0,0 +1,210 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCParser = getCParser;
+exports.getCScopeQuery = getCScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const index_js_1 = require("../../../../../shared/index.js");
+// `tree-sitter-c` is vendored prebuild-only (#2116) and may be absent on a
+// toolchain-less / `--ignore-scripts` install. It is loaded lazily + guarded via
+// parser-loader rather than statically imported: this module is pulled onto the
+// main thread eagerly by the scope-resolution registry and the language-provider
+// index, so a top-level `import C from 'tree-sitter-c'` would throw
+// ERR_MODULE_NOT_FOUND at module-load and crash `analyze` even for repos with no
+// C files (#2091, #2093). The grammar is only ever needed inside the lazy getters
+// below, and the main-thread `isLanguageAvailable` filter ensures they are
+// reached only when the binding is present.
+const parser_loader_js_1 = require("../../../tree-sitter/parser-loader.js");
+const C_SCOPE_QUERY = `
+;; Scopes
+(translation_unit) @scope.module
+(struct_specifier) @scope.class
+(union_specifier) @scope.class
+(function_definition) @scope.function
+(compound_statement) @scope.block
+(if_statement) @scope.block
+(for_statement) @scope.block
+(while_statement) @scope.block
+(do_statement) @scope.block
+(switch_statement) @scope.block
+(case_statement) @scope.block
+
+;; Declarations — struct (named)
+(struct_specifier
+  name: (type_identifier) @declaration.name
+  body: (field_declaration_list)) @declaration.struct
+
+;; Declarations — struct (typedef struct { ... } Name)
+(type_definition
+  type: (struct_specifier
+    body: (field_declaration_list))
+  declarator: (type_identifier) @declaration.name) @declaration.struct
+
+;; Declarations — union (named)
+(union_specifier
+  name: (type_identifier) @declaration.name
+  body: (field_declaration_list)) @declaration.union
+
+;; Declarations — union (typedef union { ... } Name)
+(type_definition
+  type: (union_specifier
+    body: (field_declaration_list))
+  declarator: (type_identifier) @declaration.name) @declaration.union
+
+;; Declarations — enum
+(enum_specifier
+  name: (type_identifier) @declaration.name) @declaration.enum
+
+;; Declarations — enum (typedef enum { ... } Name)
+(type_definition
+  type: (enum_specifier
+    body: (enumerator_list))
+  declarator: (type_identifier) @declaration.name) @declaration.enum
+
+;; Declarations — function definition
+(function_definition
+  declarator: (function_declarator
+    declarator: (identifier) @declaration.name)) @declaration.function
+
+;; Declarations — function definition with pointer return
+(function_definition
+  declarator: (pointer_declarator
+    declarator: (function_declarator
+      declarator: (identifier) @declaration.name))) @declaration.function
+
+;; Declarations — function declaration (prototype)
+;; Note: Both prototypes and definitions are captured as @declaration.function.
+;; This may produce duplicate Function nodes in the knowledge graph when a
+;; function is declared in a header and defined in a .c file. CALLS edges
+;; resolve correctly through scope-based wildcard import chains; the
+;; duplication is a graph-quality concern only (no false edges).
+(declaration
+  declarator: (function_declarator
+    declarator: (identifier) @declaration.name)) @declaration.function
+
+;; Declarations — function declaration with pointer return (prototype)
+(declaration
+  declarator: (pointer_declarator
+    declarator: (function_declarator
+      declarator: (identifier) @declaration.name))) @declaration.function
+
+;; Declarations — typedef
+(type_definition
+  declarator: (type_identifier) @declaration.name) @declaration.typedef
+
+;; Declarations — typedef for function pointers: typedef void (*callback)(int, int)
+(type_definition
+  declarator: (function_declarator
+    declarator: (parenthesized_declarator
+      (pointer_declarator
+        declarator: (type_identifier) @declaration.name)))) @declaration.typedef
+
+;; Declarations — struct fields
+(field_declaration
+  declarator: (field_identifier) @declaration.name) @declaration.field
+
+;; Declarations — struct fields (pointer)
+(field_declaration
+  declarator: (pointer_declarator
+    declarator: (field_identifier) @declaration.name)) @declaration.field
+
+;; Declarations — variables (with initializer)
+(declaration
+  declarator: (init_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
+;; Declarations — variables (without initializer), including non-leading
+;; declarators in mixed declaration lists.
+(declaration
+  declarator: (identifier) @declaration.name) @declaration.variable
+
+(declaration
+  declarator: (pointer_declarator
+    declarator: (identifier) @declaration.name)) @declaration.variable
+
+;; Declarations — function-pointer variables (\`void (*fp)(int);\`), with and
+;; without initializer. Without these the file-scope pointer has no scope-tree
+;; binding, so callable-flow cells written in one function and read in another
+;; canonicalize to different keys and never join (#2522 review, H1).
+(declaration
+  declarator: (function_declarator
+    declarator: (parenthesized_declarator
+      (pointer_declarator
+        declarator: (identifier) @declaration.name)))) @declaration.variable
+
+(declaration
+  declarator: (init_declarator
+    declarator: (function_declarator
+      declarator: (parenthesized_declarator
+        (pointer_declarator
+          declarator: (identifier) @declaration.name))))) @declaration.variable
+
+;; Declarations — macro definitions
+(preproc_def
+  name: (identifier) @declaration.name) @declaration.macro
+
+(preproc_function_def
+  name: (identifier) @declaration.name) @declaration.macro
+
+;; Declarations — enum constants
+(enumerator
+  name: (identifier) @declaration.name) @declaration.const
+
+;; Imports
+(preproc_include) @import.statement
+
+;; Type bindings — parameter annotations
+(parameter_declaration
+  type: (_) @type-binding.type
+  declarator: (identifier) @type-binding.name) @type-binding.parameter
+
+;; Type bindings — variable with type (init_declarator)
+(declaration
+  type: (_) @type-binding.type
+  declarator: (init_declarator
+    declarator: (identifier) @type-binding.name)) @type-binding.assignment
+
+;; References — free calls
+;; Note: This also captures calls through function pointer variables (e.g. fp(x))
+;; since tree-sitter-c produces structurally identical AST nodes for both direct
+;; function calls and function-pointer-variable calls. A type-based guard to
+;; distinguish variable-calls from function-calls is not implemented — this is a
+;; known architectural trade-off shared with the Go resolver. The uniqueness
+;; constraint in pickUniqueGlobalCallable limits false edge exposure.
+(call_expression
+  function: (identifier) @reference.name) @reference.call.free
+
+;; References — member calls via pointer (ptr->func())
+(call_expression
+  function: (field_expression
+    argument: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.call.member
+
+;; References — field reads
+(field_expression
+  argument: (_) @reference.receiver
+  field: (field_identifier) @reference.name) @reference.read
+
+;; References — field writes (assignment)
+(assignment_expression
+  left: (field_expression
+    argument: (_) @reference.receiver
+    field: (field_identifier) @reference.name)) @reference.write
+`;
+let _parser = null;
+let _query = null;
+function getCParser() {
+    if (_parser === null) {
+        _parser = new tree_sitter_1.default();
+        _parser.setLanguage((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.C));
+    }
+    return _parser;
+}
+function getCScopeQuery() {
+    if (_query === null) {
+        _query = new tree_sitter_1.default.Query((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.C), C_SCOPE_QUERY);
+    }
+    return _query;
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const c_cpp_js_1 = require("../c-cpp.js");
+const index_js_2 = require("./index.js");
+const header_scan_js_1 = require("./header-scan.js");
+const static_linkage_js_1 = require("./static-linkage.js");
+const capture_side_channel_js_1 = require("./capture-side-channel.js");
+/**
+ * Per-pass memo of the augmented `#include`-resolution file set
+ * (`allFilePaths` ∪ header `.h` paths), keyed on the two stable source sets.
+ *
+ * `resolveImportTarget` is called once per C `#include`; the old code rebuilt
+ * a fresh ~F-entry `Set` on EVERY call (O(R × (F+H)) inserts + GC churn) and,
+ * worse, defeated `resolveCImportTarget`'s own per-set suffix-index memo by
+ * handing it a new set identity each time. Both `allFilePaths` (built once in
+ * scope-resolution `run.ts`) and the header set (`loadResolutionConfig`
+ * result) are stable per pass, so the union is built once and reused.
+ * `WeakMap`-keyed → reclaimed with the pass (no cross-pass staleness).
+ */
+const augmentedPathsByPass = new WeakMap();
+function augmentedFilePaths(allFilePaths, headerPaths) {
+    let byHeaders = augmentedPathsByPass.get(allFilePaths);
+    if (byHeaders === undefined) {
+        byHeaders = new WeakMap();
+        augmentedPathsByPass.set(allFilePaths, byHeaders);
+    }
+    let augmented = byHeaders.get(headerPaths);
+    if (augmented === undefined) {
+        const set = new Set(allFilePaths);
+        for (const h of headerPaths)
+            set.add(h);
+        augmented = set;
+        byHeaders.set(headerPaths, augmented);
+    }
+    return augmented;
+}
+/**
+ * C `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
+ *
+ * C is a structurally simple language for scope resolution:
+ * - No classes (structs are value types, no method dispatch)
+ * - No inheritance (no MRO needed beyond the shared first-wins default)
+ * - No overloading (arity check is simple: variadic detection only)
+ * - `#include` is wildcard import (all symbols from header are visible)
+ * - `static` functions are file-local (not exported)
+ */
+exports.cScopeResolver = {
+    language: index_js_1.SupportedLanguages.C,
+    languageProvider: c_cpp_js_1.cProvider,
+    importEdgeReason: 'c-scope: include',
+    loadResolutionConfig: (repoPath) => {
+        // Clear stale static-linkage data from any previous invocation to
+        // prevent cross-repo contamination in server-mode scenarios.
+        (0, static_linkage_js_1.clearStaticNames)();
+        return (0, header_scan_js_1.scanHeaderFiles)(repoPath);
+    },
+    // Worker-boundary restore (see `ScopeResolver.applyCaptureSideChannel`).
+    // `emitCScopeCaptures` records per-file `static`-linkage names
+    // (`markStaticName` → `staticNames`) as a SIDE EFFECT — that state is NOT
+    // serialized onto the returned ParsedFile's scopes/defs. On the worker path
+    // those marks are populated in the worker process and lost across the
+    // MessageChannel / disk store; the main thread reuses the serialized
+    // ParsedFile and skips `extractParsedFile`, so `isStaticName` (read by
+    // `isFileLocalDef` and `expandCWildcardNames`) sees an empty map and C
+    // `static` functions leak into cross-file global free-call resolution
+    // (false CALLS edges) and `#include` wildcard imports. The worker stashed a
+    // plain-data snapshot on `parsed.captureSideChannel` via
+    // `cProvider.collectCaptureSideChannel`; this restores it into the module
+    // map WITHOUT any tree-sitter re-parse (the #1983 fix). The
+    // freshly-extracted leg never calls this — its marks were just populated in
+    // this process. Runs BEFORE `populateOwners`.
+    applyCaptureSideChannel: capture_side_channel_js_1.applyCStaticLinkageSideChannel,
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => {
+        // Augment allFilePaths with .h files discovered via loadResolutionConfig
+        // since the phase only passes .c files to the C resolver but #include
+        // targets .h files classified as C++ in language detection.
+        const headerPaths = resolutionConfig;
+        if (headerPaths !== undefined && headerPaths.size > 0) {
+            return (0, index_js_2.resolveCImportTarget)(targetRaw, fromFile, augmentedFilePaths(allFilePaths, headerPaths));
+        }
+        return (0, index_js_2.resolveCImportTarget)(targetRaw, fromFile, allFilePaths);
+    },
+    expandsWildcardTo: (targetModuleScope, parsedFiles) => (0, static_linkage_js_1.expandCWildcardNames)(targetModuleScope, parsedFiles),
+    mergeBindings: (existing, incoming, scopeId) => (0, index_js_2.cMergeBindings)(existing, incoming, scopeId),
+    arityCompatibility: (callsite, def) => (0, index_js_2.cArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize),
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    isSuperReceiver: () => false,
+    // C is statically typed — disable field fallback heuristic
+    fieldFallbackOnMethodLookup: false,
+    // C has no method return types to propagate
+    propagatesReturnTypesAcrossImports: false,
+    // C #include brings in all symbols — enable global free call fallback
+    allowGlobalFreeCallFallback: true,
+    // C `static` functions have file-local (translation-unit) linkage —
+    // exclude them from global free-call fallback cross-file resolution.
+    isFileLocalDef: (def) => {
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        return (0, static_linkage_js_1.isStaticName)(def.filePath, simple);
+    },
+    // Precise linkage-only variant used to associate a visible prototype with
+    // its implementation during callable-value actual-to-formal propagation.
+    hasFileLocalCallableLinkage: (def) => {
+        const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+        return (0, static_linkage_js_1.isStaticName)(def.filePath, simple);
+    },
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cBindingScopeFor = cBindingScopeFor;
+exports.cImportOwningScope = cImportOwningScope;
+exports.cReceiverBinding = cReceiverBinding;
+/**
+ * C binding scope: always use default auto-hoist (null).
+ * C has no self/receiver bindings that need special scoping.
+ */
+function cBindingScopeFor(_decl, _innermost, _tree) {
+    return null;
+}
+/**
+ * C import owning scope: always use default (null).
+ */
+function cImportOwningScope(_imp, _innermost, _tree) {
+    return null;
+}
+/**
+ * C receiver binding: always null. C has no methods or receivers.
+ */
+function cReceiverBinding(_functionScope) {
+    return null;
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.markStaticName = markStaticName;
+exports.isStaticName = isStaticName;
+exports.getStaticNamesForFile = getStaticNamesForFile;
+exports.clearStaticNames = clearStaticNames;
+exports.expandCWildcardNames = expandCWildcardNames;
+/**
+ * Per-file set of function names declared with `static` storage class.
+ * Populated during `emitCScopeCaptures` and consumed by `expandCWildcardNames`
+ * to exclude file-local symbols from cross-file wildcard import visibility.
+ *
+ * NOTE: module-level state, single-process-single-repo use only.
+ * For server-mode or multi-repo-in-one-process use cases, call
+ * `clearStaticNames()` at the start of each resolution pass to avoid
+ * stale static-linkage data from a previous invocation.
+ *
+ * Key: filePath, Value: Set of static function names.
+ */
+const staticNames = new Map();
+/** Record a symbol name as `static` (file-local linkage) for the given file. */
+function markStaticName(filePath, name) {
+    let names = staticNames.get(filePath);
+    if (names === undefined) {
+        names = new Set();
+        staticNames.set(filePath, names);
+    }
+    names.add(name);
+}
+/** Check whether a symbol name has `static` linkage in the given file. */
+function isStaticName(filePath, name) {
+    return staticNames.get(filePath)?.has(name) ?? false;
+}
+/**
+ * Return the `static` (file-local) names recorded for the given file as a
+ * plain array (empty when none). Used to snapshot the per-file slice of the
+ * module-level `staticNames` map into `ParsedFile.captureSideChannel` so it
+ * survives the worker→main boundary (#1983 — the worker is the sole parse
+ * path). See `c/capture-side-channel.ts`.
+ */
+function getStaticNamesForFile(filePath) {
+    const names = staticNames.get(filePath);
+    return names === undefined ? [] : [...names];
+}
+/** Clear tracked static names (for testing). */
+function clearStaticNames() {
+    staticNames.clear();
+}
+/**
+ * Per-pass memo: `moduleScope` → owning `ParsedFile`, keyed on the
+ * `parsedFiles` array identity.
+ *
+ * The shared finalize Phase-4 loop calls `expandsWildcardTo`
+ * (→ `expandCWildcardNames`) ONCE PER RESOLVED `#include` edge, every time
+ * with the SAME `parsedFiles` reference (wired at scope-resolution
+ * `run.ts` — `allFilePaths`/`parsedFiles` are built once per pass). The old
+ * `parsedFiles.find(...)` therefore did a full O(F) scan per edge →
+ * O(R_include × F) overall; at Linux-kernel scale (F ≈ 63k C files, tens of
+ * thousands of resolved includes) that is ~10^10+ comparisons on a single
+ * thread — the dominant term in the scope-resolution finalize grind.
+ *
+ * Building the lookup once collapses it to O(R_include + F). `WeakMap`-keyed
+ * on the array so the index is reclaimed with the pass — no cross-pass
+ * staleness (mirrors the {@link clearStaticNames} discipline for server-mode
+ * / multi-repo reuse), and a fresh array transparently rebuilds.
+ */
+const moduleScopeIndexByPass = new WeakMap();
+function moduleScopeIndex(parsedFiles) {
+    let index = moduleScopeIndexByPass.get(parsedFiles);
+    if (index === undefined) {
+        index = new Map();
+        // First-wins to preserve `Array.find` semantics (returns the first match).
+        // `moduleScope` is unique per file in practice, so collisions are absent;
+        // the guard only formalises identical behaviour to the prior `.find`.
+        for (const p of parsedFiles) {
+            if (!index.has(p.moduleScope))
+                index.set(p.moduleScope, p);
+        }
+        moduleScopeIndexByPass.set(parsedFiles, index);
+    }
+    return index;
+}
+/**
+ * Return the names visible through a C wildcard import (`#include`).
+ * All module-scope defs from the target file are visible EXCEPT those
+ * declared with `static` storage class (file-local linkage in C).
+ */
+function expandCWildcardNames(targetModuleScope, parsedFiles) {
+    const target = moduleScopeIndex(parsedFiles).get(targetModuleScope);
+    if (target === undefined)
+        return [];
+    const seen = new Set();
+    const names = [];
+    for (const def of target.localDefs) {
+        const name = simpleName(def);
+        if (name === '')
+            continue;
+        if (isStaticName(target.filePath, name))
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        names.push(name);
+    }
+    return names;
+}
+function simpleName(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}