cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Extract TypeScript arity metadata from a method-like tree-sitter node —
+ * `method_definition`, `method_signature`, `abstract_method_signature`,
+ * `function_declaration`, `generator_function_declaration`, or
+ * `function_signature` (overload signature).
+ *
+ * Reuses `typescriptMethodConfig.extractParameters` so scope-extracted defs
+ * carry the same arity semantics as the legacy parse-worker path:
+ *   - Rest parameters (`...args: T[]`) collapse `parameterCount` to
+ *     `undefined`, which `typescriptArityCompatibility` treats as
+ *     "max unknown" — the candidate stays eligible at
+ *     `argCount >= required` (mirrors Python `*args` / C# `params`).
+ *   - Optional (`p?: T`) and defaulted (`p: T = …`) parameters both
+ *     contribute to `optionalCount`;
+ *     `requiredParameterCount = total − optionalCount`.
+ *   - `parameterTypes` collects declared type-annotation text for
+ *     overload narrowing; TypeScript supports function overloading
+ *     (`function f(x: string); function f(x: number); function f(x) {}`),
+ *     so populated types let the registry disambiguate same-arity
+ *     siblings by declared types.
+ *   - A literal `'params'` marker is appended for variadic methods so
+ *     `typescriptArityCompatibility` can detect rest params without
+ *     re-reading the AST.
+ *
+ * ## Generics stripping
+ *
+ * TypeScript parameter types frequently contain generic instantiations
+ * (`User<string>`, `Array<User>`, `Promise<User[]>`). For overload
+ * narrowing by declared type, we want the "head" name — `User`,
+ * `Array`, `Promise` — so `arity-metadata` applies a light strip to
+ * each `parameterTypes[i]`:
+ *
+ *   - `Foo<Bar>`          → `Foo`
+ *   - `Foo<Bar, Baz>`     → `Foo`
+ *   - `Foo[]`             → `Foo`
+ *   - `Foo<Bar>[]`        → `Foo`
+ *   - `Foo<Bar<Baz>>`     → `Foo`   (greedy — strip the outermost once)
+ *   - plain `Foo`         → `Foo`
+ *
+ * We do NOT strip unions / intersections at this layer — those stay
+ * intact because the registry's overload narrowing is a string
+ * equality check; union types shouldn't match anything and we prefer
+ * "unknown" to "accidental match". `undefined` / `null` in unions
+ * (TS strict mode) is handled by `interpret.ts`'s `stripNullableUnion`
+ * when the name would be consumed as a receiver type — that path is
+ * separate from this arity-metadata path.
+ *
+ * Generic type parameters on the function itself (`function f<T>(x: T)`)
+ * do NOT enter here — the method extractor reads the `parameters`
+ * field only, which contains value parameters, not type parameters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeTsArityMetadata = computeTsArityMetadata;
+const typescript_javascript_js_1 = require("../../method-extractors/configs/typescript-javascript.js");
+function computeTsArityMetadata(fnNode) {
+    const params = typescript_javascript_js_1.typescriptMethodConfig.extractParameters?.(fnNode) ?? [];
+    let hasRest = false;
+    let optionalCount = 0;
+    const types = [];
+    for (const p of params) {
+        if (p.isVariadic)
+            hasRest = true;
+        else if (p.isOptional)
+            optionalCount++;
+        const t = p.type !== null && p.type !== undefined ? stripGenericsAndArraySuffix(p.type) : '';
+        types.push(t);
+    }
+    if (hasRest)
+        types.push('params');
+    const total = params.length;
+    const parameterCount = hasRest ? undefined : total;
+    const requiredParameterCount = hasRest ? undefined : total - optionalCount;
+    // Only emit parameterTypes when at least one param carries a non-
+    // empty type name. An array of all empty strings adds noise to the
+    // registry without aiding narrowing — callers treat absence as
+    // "types unknown".
+    const hasAnyType = types.some((t) => t !== '' && t !== 'params');
+    const parameterTypes = hasAnyType || hasRest ? (types.length > 0 ? types : undefined) : undefined;
+    return {
+        parameterCount,
+        requiredParameterCount,
+        parameterTypes,
+    };
+}
+/**
+ * Light generic + array-suffix strip used only for registry overload
+ * narrowing. See file-level JSDoc for the exact transformation table.
+ *
+ * Handles nesting greedily at the outermost level:
+ *   `Foo<Bar<Baz>>[]` — strip `[]` → `Foo<Bar<Baz>>`, then strip
+ *   outermost `<>` → `Foo`.
+ */
+function stripGenericsAndArraySuffix(raw) {
+    let t = raw.trim();
+    // Repeatedly peel trailing `[]` pairs, then peel the outermost `<…>`
+    // block once. We don't loop the `<>` peel since nesting is rare and
+    // the head name is already reached after one peel.
+    while (t.endsWith('[]'))
+        t = t.slice(0, -2).trim();
+    const lt = t.indexOf('<');
+    if (lt > 0 && t.endsWith('>')) {
+        t = t.slice(0, lt).trim();
+    }
+    return t;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * TypeScript arity check, accommodating rest parameters and optional
+ * (`p?: T`) / defaulted (`p: T = …`) parameters.
+ *
+ * TypeScript-specific semantics vs C#:
+ *
+ *   - **Optional** — `p?: T` collapses to `isOptional` in the extractor
+ *     and contributes to `optionalCount`, so `requiredParameterCount`
+ *     excludes it. Same wire shape as a default-valued parameter.
+ *   - **Rest** — `...args: T[]` makes `parameterCount` undefined (max
+ *     unknown) and `parameterTypes` carries a literal `'params'` marker
+ *     so this hook can detect variadic calls without re-reading the AST
+ *     (mirrors the C# convention for cross-language consistency).
+ *   - **Generics** — function-level generic type parameters (`<T, U>`)
+ *     do NOT count toward arity; the method-extractor reads the
+ *     `parameters` field and ignores `type_parameters`, so generic
+ *     count never enters the metadata.
+ *
+ * The metadata shape (`parameterCount`, `requiredParameterCount`,
+ * `parameterTypes`) is synthesized by `arity-metadata.ts` and stored
+ * on `SymbolDefinition`. This file consumes that metadata.
+ *
+ * Verdicts:
+ *   - `'compatible'`   — `requiredParameterCount <= argCount <=
+ *                        parameterCount`, OR the def has rest params
+ *                        (any `argCount >= required`).
+ *   - `'incompatible'` — argCount is below required, OR above max with
+ *                        no rest params.
+ *   - `'unknown'`      — metadata is absent / incomplete (treated as
+ *                        neutral by the registry).
+ *
+ * `'incompatible'` is a soft signal in `Registry.lookup` (penalized
+ * but still considered when no compatible candidate exists), per
+ * RFC §4.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptArityCompatibility = typescriptArityCompatibility;
+function typescriptArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    const argCount = callsite.arity;
+    if (!Number.isFinite(argCount) || argCount < 0)
+        return 'unknown';
+    // Variadic detection: the `arity-metadata` synthesizer appends the
+    // literal `'params'` marker to `parameterTypes` when the def has a
+    // rest parameter, to avoid re-parsing the AST here.
+    const hasRest = def.parameterTypes !== undefined &&
+        def.parameterTypes.some((t) => t === 'params' || t.startsWith('params '));
+    if (min !== undefined && argCount < min)
+        return 'incompatible';
+    if (max !== undefined && argCount > max && !hasRest)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/code/engine/core/ingestion/languages/typescript/array-callback.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Array higher-order-method callback detection (issue #1876).
+ *
+ * The HOC-wrapped-arrow declaration pattern in the JS/TS scope queries
+ * (`const X = call((args) => …)`) was added for React idioms
+ * (`forwardRef` / `memo` / `useCallback`). It has the same AST shape as
+ * an array higher-order-method call (`const x = arr.map(a => …)`), so
+ * those callbacks also match and produce a spurious `@declaration.function`
+ * named after the binding — duplicating the `@declaration.const` /
+ * `@declaration.variable` def that the same binding already gets.
+ *
+ * For an array-method callback the binding holds a *value* (the method's
+ * result), not a callable, so the `Function` def is semantically wrong.
+ * `isArrayMethodCallbackArrow` lets the emitter (`captures.ts`) drop that
+ * `@declaration.function` match, leaving only the value def.
+ *
+ * Shared by both the JavaScript and TypeScript capture emitters — the
+ * relevant grammar nodes (`arrow_function`, `function_expression`,
+ * `arguments`, `call_expression`, `member_expression`,
+ * `property_identifier`) are identical across `tree-sitter-javascript`
+ * and `tree-sitter-typescript`.
+ *
+ * Pure given the input node. No I/O, no globals.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrayMethodCallbackArrow = isArrayMethodCallbackArrow;
+const ts_js_hoc_utils_js_1 = require("../../ts-js-hoc-utils.js");
+/**
+ * True when `node` (an `arrow_function` / `function_expression`) is the
+ * callback argument of an array higher-order-method call, i.e. the
+ * enclosing call's callee is a `member_expression` whose property is one
+ * of {@link ARRAY_CALLBACK_METHODS}.
+ *
+ * Returns false for direct assignments (`const fn = () => {}` — parent is
+ * `variable_declarator`, not `arguments`) and for identifier-callee HOCs
+ * (`forwardRef(() => …)` — callee is an `identifier`, not a
+ * `member_expression`), so neither is ever suppressed.
+ *
+ * The helper itself only handles direct `member_expression` callees. Broader
+ * shapes like `(arr.map)(cb)` and `arr['map'](cb)` are now filtered at the
+ * query layer, so this emit-side check stays focused on the direct fallback.
+ */
+function isArrayMethodCallbackArrow(node) {
+    const args = node.parent;
+    if (args === null || args.type !== 'arguments')
+        return false;
+    const call = args.parent;
+    if (call === null || call.type !== 'call_expression')
+        return false;
+    const callee = call.childForFieldName('function');
+    if (callee === null || callee.type !== 'member_expression')
+        return false;
+    const property = callee.childForFieldName('property');
+    if (property === null || property.type !== 'property_identifier')
+        return false;
+    return ts_js_hoc_utils_js_1.ARRAY_CALLBACK_METHODS.has(property.text);
+}

package/dist/core/code/engine/core/ingestion/languages/typescript/cache-stats.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Dev-mode counters for the TypeScript cross-phase scope-captures parse cache.
+ *
+ * Gated by `PROF_SCOPE_RESOLUTION=1`. In production the module-level `PROF`
+ * constant is `false` and V8 folds every increment site into dead code, so the
+ * hot path in `captures.ts` stays branch-free.
+ *
+ * Extracted from `captures.ts` so the production hot-path module doesn't carry
+ * a module-global counter and its reset/export surface.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordCacheHit = recordCacheHit;
+exports.recordCacheMiss = recordCacheMiss;
+exports.getTypescriptCaptureCacheStats = getTypescriptCaptureCacheStats;
+exports.resetTypescriptCaptureCacheStats = resetTypescriptCaptureCacheStats;
+const PROF = process.env.PROF_SCOPE_RESOLUTION === '1';
+let CACHE_HITS = 0;
+let CACHE_MISSES = 0;
+function recordCacheHit() {
+    if (PROF)
+        CACHE_HITS++;
+}
+function recordCacheMiss() {
+    if (PROF)
+        CACHE_MISSES++;
+}
+function getTypescriptCaptureCacheStats() {
+    return { hits: CACHE_HITS, misses: CACHE_MISSES };
+}
+function resetTypescriptCaptureCacheStats() {
+    CACHE_HITS = 0;
+    CACHE_MISSES = 0;
+}