@aroman22/codegraph-vba-darwin-arm64 1.14.0 → 1.16.0

package/lib/dist/extraction/vba/options.d.ts

@@ -0,0 +1,88 @@
+/**
+ * `VbaExtractionOptions` — the single object that carries every VBA
+ * extraction knob from `codegraph.json` down to `VbaExtractor` (issue #243).
+ *
+ * ## Why this module exists
+ *
+ * The knobs used to travel as positional parameters through five files:
+ *
+ * ```
+ * project-config.ts  loadVbaConfig()
+ *   -> extraction/index.ts     reads vbaConfig
+ *     -> extraction/parse-pool.ts  ParseTask fields
+ *       -> extraction/parse-worker.ts  message shape
+ *         -> extraction/tree-sitter.ts extractFromSource(..., vbaTargets, maxRaiseFanout, ...)
+ *           -> new VbaExtractor(filePath, source, vbaTargets, maxRaiseFanout)
+ * ```
+ *
+ * Every new knob meant editing all five signatures and every call site. One
+ * object collapses that to "add a field here, read it in the extractor".
+ *
+ * ## Worker-boundary constraint — READ BEFORE ADDING A FIELD
+ *
+ * This object crosses the `parse-pool` -> `parse-worker` boundary through
+ * `worker.postMessage`, which is `structuredClone`-based. Every field MUST be
+ * plain, structured-cloneable data: primitives, plain objects, and arrays of
+ * those. NO functions, NO `RegExp`, NO `Map`/`Set`, NO class instances — a
+ * function throws `DataCloneError` at the boundary and a `RegExp` silently
+ * loses its `lastIndex`/identity semantics.
+ *
+ * A derived value that is not cloneable (a compiled wrapper `RegExp`, a
+ * lookup `Map`) belongs on the extractor context, built inside the extractor
+ * from the plain data in this object.
+ *
+ * This module is a LEAF: it imports nothing, so the config layer, the pool,
+ * the worker, and the extractor can all depend on it without a cycle.
+ */
+/**
+ * Every VBA-specific extraction knob, in one structured-cloneable object.
+ *
+ * All fields are optional; `{}` is the zero-config default and must behave
+ * exactly like the pre-#243 "caller passed nothing" path.
+ */
+export interface VbaExtractionOptions {
+    /**
+     * Conditional-compilation targets — the `#Const` name -> truth map used to
+     * decide which `#If` branches stay active. Sourced from `codegraph.json` ->
+     * `vba.targets`. Undefined means "no project overrides"; the preprocessor
+     * falls back to its built-in defaults.
+     */
+    targets?: Record<string, boolean>;
+    /**
+     * Issue #152: per-file fanout cap for `RaiseEvent <EventName>` edges. An
+     * event raised from more than this many sites in one file is flagged
+     * `metadata.highFanout: true` and ALL its `raises-event` edges are dropped.
+     * Undefined means the caller did not choose, so `VbaExtractor` applies
+     * `DEFAULT_MAX_RAISE_FANOUT` (50). Sourced from `codegraph.json` ->
+     * `vba.maxRaiseFanout`.
+     */
+    maxRaiseFanout?: number;
+    /**
+     * Names of project-specific procedures that wrap a SQL execution call
+     * (e.g. a shared `EjecutarSQL(sql)` helper), so a call to one of them is
+     * treated as a SQL execution site instead of an ordinary call.
+     *
+     * Declared here now and threaded end-to-end by #243; the SQL-wrapper task
+     * is the consumer. Kept as a `readonly string[]` of plain strings — the
+     * compiled matcher built from these names is NOT cloneable and therefore
+     * belongs on the extractor context, never in this object.
+     */
+    sqlWrappers?: readonly string[];
+    /**
+     * Issue #261 — the module-level variable names this project uses to carry
+     * an error message from where it happened to where the user sees it
+     * (`m_Error`, `p_Error`, a project's own `lastFailure`). A read or write of
+     * one of them is flagged `metadata.errorChannel: true`, and a handler that
+     * writes one is classified `behavior: 'channel'`.
+     *
+     * Bare VBA identifiers, matched as WHOLE names — never substrings, never
+     * user-supplied regex (this runs per identifier per line, the same reasoning
+     * `sqlWrappers` was built on). Sourced from `codegraph.json` →
+     * `vba.errorChannel`, and EXTENDS the built-in list rather than replacing
+     * it. Kept as plain strings for the same reason `sqlWrappers` is: the
+     * compiled `Set`/`RegExp` form cannot cross the `structuredClone` worker
+     * boundary, so it is built on the extractor context instead.
+     */
+    errorChannel?: readonly string[];
+}
+//# sourceMappingURL=options.d.ts.map

package/lib/dist/extraction/vba/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAChC;;;;;;;;;;;;;;OAcG;IACH,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC"}

package/lib/dist/extraction/vba/options.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * `VbaExtractionOptions` — the single object that carries every VBA
+ * extraction knob from `codegraph.json` down to `VbaExtractor` (issue #243).
+ *
+ * ## Why this module exists
+ *
+ * The knobs used to travel as positional parameters through five files:
+ *
+ * ```
+ * project-config.ts  loadVbaConfig()
+ *   -> extraction/index.ts     reads vbaConfig
+ *     -> extraction/parse-pool.ts  ParseTask fields
+ *       -> extraction/parse-worker.ts  message shape
+ *         -> extraction/tree-sitter.ts extractFromSource(..., vbaTargets, maxRaiseFanout, ...)
+ *           -> new VbaExtractor(filePath, source, vbaTargets, maxRaiseFanout)
+ * ```
+ *
+ * Every new knob meant editing all five signatures and every call site. One
+ * object collapses that to "add a field here, read it in the extractor".
+ *
+ * ## Worker-boundary constraint — READ BEFORE ADDING A FIELD
+ *
+ * This object crosses the `parse-pool` -> `parse-worker` boundary through
+ * `worker.postMessage`, which is `structuredClone`-based. Every field MUST be
+ * plain, structured-cloneable data: primitives, plain objects, and arrays of
+ * those. NO functions, NO `RegExp`, NO `Map`/`Set`, NO class instances — a
+ * function throws `DataCloneError` at the boundary and a `RegExp` silently
+ * loses its `lastIndex`/identity semantics.
+ *
+ * A derived value that is not cloneable (a compiled wrapper `RegExp`, a
+ * lookup `Map`) belongs on the extractor context, built inside the extractor
+ * from the plain data in this object.
+ *
+ * This module is a LEAF: it imports nothing, so the config layer, the pool,
+ * the worker, and the extractor can all depend on it without a cycle.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=options.js.map

package/lib/dist/extraction/vba/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../../src/extraction/vba/options.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG"}

package/lib/dist/extraction/vba/parameters.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Issue #257 (task T16, half A): turn a procedure's already-parsed signature
+ * into `parameter` nodes.
+ *
+ * This module is EMISSION ONLY. The signature was parsed once by
+ * `signature.ts` — after the preprocessor joined `_` line continuations — and
+ * stamped onto the `function` node's `metadata.params` by `procedures.ts`.
+ * The same `VbaParameterInfo[]` is handed here, so a continued signature and
+ * its one-line equivalent produce byte-identical nodes by construction. Never
+ * re-parse the declaration line here; that is how the two views drift.
+ */
+import { Node } from '../../types';
+import { VbaExtractorContext } from './context';
+import type { VbaParameterInfo } from './signature';
+/**
+ * Emit one `parameter` node per declared parameter of `procedureNode`, the
+ * `contains` edge that binds it to its procedure, and — for a non-primitive
+ * declared type — a `type_of` edge onto the type's node.
+ *
+ * Parameters have no line of their own: VBA writes them inside the procedure
+ * header, and after continuation joining even the physical line is a fiction.
+ * So `startLine` / `endLine` are the procedure's declaration line, and the id
+ * is disambiguated by `<Procedure>.<param>` rather than by position — two
+ * accessors of the same property (`Property Get X` / `Property Let X`) sit on
+ * different lines and therefore still get distinct ids.
+ *
+ * `qualifiedName` is `<ModuleOrClass>.<Procedure>.<param>`, using
+ * `ctx.moduleName` (the resolved `Attribute VB_Name`, or the basename) rather
+ * than `ctx.classNamePrefix` — the latter is `null` for a `.bas`, and a
+ * parameter of a module-level Sub wants the module prefix just as much as a
+ * class method's does. Same choice the module-level `variable` nodes made in
+ * issue #251.
+ */
+export declare function emitParameterNodes(ctx: VbaExtractorContext, procedureNode: Node, params: readonly VbaParameterInfo[], lineNum: number, line: string): void;
+//# sourceMappingURL=parameters.d.ts.map

package/lib/dist/extraction/vba/parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/parameters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAGnC,OAAO,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AA4BpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,mBAAmB,EACxB,aAAa,EAAE,IAAI,EACnB,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,IAAI,CAgEN"}

package/lib/dist/extraction/vba/parameters.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitParameterNodes = emitParameterNodes;
+const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
+const constants_1 = require("./constants");
+/**
+ * The type name a `type_of` edge should point at, or `null` when the
+ * declaration deserves no edge at all.
+ *
+ * This mirrors what `dims.ts` does for `Dim x As Foo`, deliberately:
+ *
+ *  - an untyped parameter (implicit `Variant`) yields nothing;
+ *  - a primitive (`Long`, `String`, `Variant`, …) yields nothing —
+ *    `PRIMITIVE_TYPES` is the same gate the Dim sweep uses;
+ *  - a qualified type (`As DAO.Recordset`) yields its OUTER segment, because
+ *    that is the name the Dim sweep resolves and the only one a project
+ *    declaration could ever match.
+ *
+ * The gate is intentionally coarse: `type_of` is emitted for anything that is
+ * not a primitive, and `resolveVbaReferenceStubs` decides afterwards whether a
+ * real project class of that name exists. A library type nobody declares keeps
+ * its stub, exactly as a `Dim r As DAO.Recordset` does today.
+ */
+function typeEdgeTarget(declaredType) {
+    if (!declaredType)
+        return null;
+    const outer = declaredType.split('.')[0] ?? '';
+    if (!outer)
+        return null;
+    if (constants_1.PRIMITIVE_TYPES.has(outer.toLowerCase()))
+        return null;
+    return outer;
+}
+/**
+ * Emit one `parameter` node per declared parameter of `procedureNode`, the
+ * `contains` edge that binds it to its procedure, and — for a non-primitive
+ * declared type — a `type_of` edge onto the type's node.
+ *
+ * Parameters have no line of their own: VBA writes them inside the procedure
+ * header, and after continuation joining even the physical line is a fiction.
+ * So `startLine` / `endLine` are the procedure's declaration line, and the id
+ * is disambiguated by `<Procedure>.<param>` rather than by position — two
+ * accessors of the same property (`Property Get X` / `Property Let X`) sit on
+ * different lines and therefore still get distinct ids.
+ *
+ * `qualifiedName` is `<ModuleOrClass>.<Procedure>.<param>`, using
+ * `ctx.moduleName` (the resolved `Attribute VB_Name`, or the basename) rather
+ * than `ctx.classNamePrefix` — the latter is `null` for a `.bas`, and a
+ * parameter of a module-level Sub wants the module prefix just as much as a
+ * class method's does. Same choice the module-level `variable` nodes made in
+ * issue #251.
+ */
+function emitParameterNodes(ctx, procedureNode, params, lineNum, line) {
+    if (params.length === 0)
+        return;
+    const procedureName = procedureNode.name;
+    const emitted = new Set();
+    for (let position = 0; position < params.length; position++) {
+        const param = params[position];
+        const name = param.name.trim();
+        // `parseSignature` never drops a fragment it cannot understand — a wrong
+        // arity is worse than a coarse one — so a nameless entry can reach here.
+        // It is not a symbol, so it gets no node.
+        if (!name)
+            continue;
+        const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(ctx.filePath, 'parameter', `${procedureName}.${name}`, lineNum);
+        // VBA forbids two parameters of the same name on one signature; this only
+        // fires if a malformed declaration parsed into a repeat. Keep the first.
+        if (emitted.has(nodeId))
+            continue;
+        emitted.add(nodeId);
+        const qualifiedPrefix = ctx.moduleName
+            ? `${ctx.moduleName}.${procedureName}`
+            : procedureName;
+        ctx.nodes.push({
+            id: nodeId,
+            kind: 'parameter',
+            name,
+            qualifiedName: `${qualifiedPrefix}.${name}`,
+            filePath: ctx.filePath,
+            language: 'vba',
+            startLine: lineNum,
+            endLine: lineNum,
+            startColumn: 0,
+            endColumn: line.length,
+            metadata: {
+                position,
+                byRef: param.byRef,
+                optional: param.optional,
+                isArray: param.isArray,
+                hasDefault: param.hasDefault,
+                // An `As`-less parameter is `Variant` per VBA semantics. Recorded as
+                // the language's own default rather than left null, matching how
+                // issue #251 stamps `declaredType` on module-level variables.
+                declaredType: param.type ?? 'Variant',
+            },
+            updatedAt: Date.now(),
+        });
+        ctx.edges.push({
+            source: procedureNode.id,
+            target: nodeId,
+            kind: 'contains',
+        });
+        const typeName = typeEdgeTarget(param.type);
+        if (typeName) {
+            ctx.emitTypeOf(nodeId, typeName, lineNum, 0, 'vba-parameter-type');
+        }
+    }
+}
+//# sourceMappingURL=parameters.js.map

package/lib/dist/extraction/vba/parameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.js","sourceRoot":"","sources":["../../../src/extraction/vba/parameters.ts"],"names":[],"mappings":"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"}

package/lib/dist/extraction/vba/procedures.d.ts

@@ -1,4 +1,4 @@
-import { VbaExtractorContext, ProcInfo, VbaClassifier } from './context';
+import { VbaClassifier } from './context';
 import { VbaExtractionRule } from './rules';
 /**
  * Issue #153: the declarative rule table for the procedures concern.
@@ -17,12 +17,4 @@ import { VbaExtractionRule } from './rules';
  */
 export declare const RULES: readonly VbaExtractionRule<unknown>[];
 export declare function createProceduresClassifier(): VbaClassifier;
-/**
- * Backward-compat wrapper: pre-#83 callers (e.g. legacy test fixtures)
- * used `sweepProcedures(ctx, src)` and got back the ProcInfo[].
- * Now it returns `ctx.procedures` (the same flat list the factory
- * appends to). The implementation still calls the classifier once per
- * pre-split line, so the count is identical to the new walker path.
- */
-export declare function sweepProcedures(ctx: VbaExtractorContext, src: string): ProcInfo[];
 //# sourceMappingURL=procedures.d.ts.map

package/lib/dist/extraction/vba/procedures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/procedures.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AACzE,OAAO,EAAyB,iBAAiB,EAAE,MAAM,SAAS,CAAC;AA0DnE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,EAAE,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAwNtD,CAAC;AAEF,wBAAgB,0BAA0B,IAAI,aAAa,CAyC1D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,GAAG,QAAQ,EAAE,CAOjF"}
+{"version":3,"file":"procedures.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/procedures.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAY,aAAa,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAwB,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAgDlE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,KAAK,EAAE,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAwVtD,CAAC;AAEF,wBAAgB,0BAA0B,IAAI,aAAa,CAS1D"}