@aroman22/codegraph-vba-darwin-arm64 1.3.3

package/lib/dist/extraction/vba-extractor.d.ts

@@ -0,0 +1,394 @@
+import { ExtractionResult } from '../types';
+export declare class VbaExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private errors;
+    private unresolvedReferences;
+    private moduleOrClassNode;
+    /**
+     * Class-name prefix for `qualifiedName` composition.
+     *
+     * B3 (hueco 5): for `.cls` files every function node's `qualifiedName`
+     * is composed as `${className}.${procName}` (e.g. `Form_TestForm.Form_Load`)
+     * so cross-class callers can disambiguate which form each `Form_Load`
+     * belongs to. For `.bas` files this is `null` — module-scoped procs
+     * keep their bare-name `qualifiedName` (e.g. `DoThing`), preserving
+     * the pre-hueco-5 behavior and every existing qualifiedName-based
+     * assertion in `extraction-vba.test.ts`.
+     *
+     * Resolved once per `extract()` from `isCls` + `vbName` (both already
+     * computed for `createModuleOrClassNode`); `sweepProcedures` reads it
+     * to set `ProcInfo.qualifiedName` and the function node's qualifiedName.
+     */
+    private classNamePrefix;
+    /**
+     * Map of procedure name (within this file) → list of ProcInfo. The list
+     * (rather than a single value) is needed because VBA allows multiple
+     * Property accessors with the same name: `Property Get Foo`, `Property
+     * Let Foo`, and `Property Set Foo` all share the name `Foo`. Audit W6
+     * (June 2026): the previous Map<string, ProcInfo> kept only the last
+     * accessor, breaking same-file call resolution and emitting the wrong
+     * `findFunctionNodeByName` match.
+     */
+    private localProcs;
+    /**
+     * Cache: procedure name → first matching function node emitted for that
+     * name. Audit S2 (June 2026): the previous implementation did an O(n)
+     * linear scan of all nodes for every call site; with W6's multimap
+     * the same-name collision can return multiple matches but bare-name
+     * call resolution only needs the first.
+     */
+    private functionNodeByName;
+    /**
+     * Cache: startLine → function node emitted for that line. Used by Fix 1
+     * (June 2026): when Property Get/Let/Set share a name, we need to find
+     * the SPECIFIC accessor's node by its declaration line rather than relying
+     * on `functionNodeByName` which only stores the first accessor.
+     */
+    private functionNodeByStartLine;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private result;
+    private isFormOrReportFile;
+    private createFileNode;
+    private detectVbName;
+    private createModuleOrClassNode;
+    /** Sub/Function/Property regex — captures visibility prefix, kind, and name. */
+    private static readonly PROC_RE;
+    /**
+     * Walk the (uncommented, line-joined) source and emit one `function` node
+     * per `Sub` / `Function` / `Property` declaration. Also records the proc
+     * in `localProcs` so call-site resolution can distinguish same-file from
+     * cross-module calls.
+     */
+    private sweepProcedures;
+    /** Implements regex. */
+    private static readonly IMPLEMENTS_RE;
+    /** Edges whose source needs to be set to the module/class id once it exists. */
+    private pendingModuleOrClassSource;
+    private sweepImplements;
+    /**
+     * Check that a line is a variable declaration and NOT a Sub/Function/
+     * Property/Const/WithEvents header (those have their own sweeps).
+     * Fix 1+3 (Issues #1,#3): replaced the old single-match DIM_QUAL_RE /
+     * DIM_UNQUAL_RE pair with a prefix-check + global scan that handles
+     * `As New <Type>`, multi-variable `Dim a As Foo, b As Bar`, and all
+     * visibility keywords in one pass.
+     */
+    private static readonly DIM_DECL_PREFIX_RE;
+    /**
+     * Globally scan all `identifier As [New] TypePart1[.TypePart2]` on a
+     * variable declaration line. Run with /g after confirming DIM_DECL_PREFIX_RE.
+     *
+     * Groups: (1) variable name, (2) type outer part, (3) type inner part (if qualified).
+     * `(?:New\s+)?` consumes the VBA auto-instantiation keyword so it is
+     * never captured as the type name (Fix 1).
+     */
+    private static readonly DIM_ALL_VARS_RE;
+    /**
+     * VBA primitive type names — skipped when emitted as Dim targets so
+     * we don't pollute the graph with `As Long` / `As String` references.
+     * Fix 4: all entries are LOWERCASE and the lookup lowercases the
+     * captured type name so `As long`, `As LONG`, `As Long` all match.
+     * Fix 1 (Issue #1): added `'new'` as a backstop so that if the `As New`
+     * pattern is ever captured as a type name it is silently skipped.
+     */
+    private static readonly PRIMITIVE_TYPES;
+    /** `WithEvents m_X As Form_Foo` — Dim/Private/Public prefix is optional. */
+    private static readonly WITHEVENTS_RE;
+    private sweepDimsAndWithEvents;
+    /** `[visibility] Enum <Name>` — opens an enum block. */
+    private static readonly ENUM_START_RE;
+    /** `End Enum` — closes the current enum block. */
+    private static readonly ENUM_END_RE;
+    /**
+     * An enum member line: a leading identifier optionally followed by `=
+     * <value>`. Runs only inside an open Enum block, on the (already
+     * comment-stripped) source, so a trailing `'comment` never reaches here.
+     * `\p{L}` covers accented member names (e.g. `Sí`).
+     */
+    private static readonly ENUM_MEMBER_RE;
+    /** `[visibility] Const <decls>` — captures visibility (1) and the rest (2). */
+    private static readonly CONST_DECL_RE;
+    /**
+     * One declared name inside a `Const` body. A name sits at a declaration
+     * boundary (start-of-body or after a comma), optionally followed by
+     * `As <Type>`, then `=`. Run with /g over the CONST_DECL_RE group 2 so
+     * multi-name lines (`Const A = 1, B = 2`) emit one node per name.
+     */
+    private static readonly CONST_NAME_RE;
+    /**
+     * Fold a VBA visibility keyword to the canonical lowercase enum, matching
+     * the procedure convention: `Private` → 'private'; `Public`, `Global`,
+     * `Friend`, or none → 'public' (VBA's default module-level `Const`/`Enum`
+     * is Private, but we follow the same broader-than-private fold the proc
+     * sweep uses so visibility is consistent across symbol kinds).
+     */
+    private static foldVisibility;
+    /**
+     * Walk the (uncommented, line-joined) source and emit:
+     *  - one `enum` node per `Enum <Name>` block, with one `enum_member` node
+     *    per member and a `contains` edge enum→member;
+     *  - one `constant` node per name declared on a `Const` line (multi-name
+     *    lines emit one node per name);
+     *  - a `contains` edge from the module/class node to each enum and constant
+     *    (held in `pendingModuleOrClassSource` until the module node exists).
+     *
+     * Returns the number of top-level symbols (enums + constants) emitted so
+     * the caller can flip `hasAnySymbols`.
+     */
+    private sweepEnumsAndConsts;
+    /**
+     * Emit a `contains` edge from the (lazily-created) module/class node to
+     * `targetId`. Mirrors the pending-source pattern the procedure and
+     * implements sweeps use: the module node doesn't exist yet, so the edge's
+     * source is rewritten once `extract()` creates it.
+     */
+    private pushContainsFromModule;
+    /**
+     * Walk the (uncommented) source per line. For each line:
+     *  - If it starts a `Sub`/`Function`/`Property`, push the proc onto a stack.
+     *  - If it ends one (`End Sub` / `End Function` / `End Property`), pop.
+     *  - While inside a procedure, scan the line for call-site patterns and
+     *    SQL-wrapper patterns.
+     *
+     * Call-site regex: `(?<!\w)([A-Za-z_]\w*)(?:\.([A-Za-z_]\w*))?\s*\(` —
+     * captures either `Name(...)` (same-file candidate) or `Receiver.Member(...)`
+     * (qualified — emit a synthetic node + heuristic edge).
+     */
+    private static readonly CALL_RE;
+    /** SQL wrapper helpers — order matters because `db.Execute` is a suffix of others. */
+    private static readonly SQL_WRAPPERS;
+    /**
+     * `DoCmd.OpenForm "<FormName>"` modelling regex — B4 (hueco 6).
+     *
+     * Real VBA idiom (matches both forms):
+     *   `DoCmd.OpenForm "MyForm"`
+     *   `DoCmd.OpenForm "MyForm", acNormal, , , acFormEdit`
+     *
+     * Captures the form NAME (group 1) so the extractor can synthesize an
+     * `opens-form` heuristic edge from the calling Sub to a stub for the
+     * target form. The trailing positional args (`acNormal`, `acFormEdit`,
+     * etc.) are intentionally NOT captured — the orchestrator's scope decision
+     * was to cover ONLY `OpenForm` for this commit; `OpenReport`, `OpenQuery`,
+     * `OpenTable`, … are flagged in the commit body as follow-up work.
+     *
+     * Why a separate dispatch: `DoCmd` is in `RUNTIME_RECEIVER_BLACKLIST`
+     * (R4 invariant), so `DoCmd.OpenForm` is intentionally SKIPPED by the
+     * generic `CALL_RE` path that would otherwise emit a junk `calls` edge
+     * to a synthetic `function` node for `DoCmd.OpenForm`. This regex
+     * matches BEFORE the call-site scan and uses its own dispatch to emit
+     * the `opens-form` edge instead — sharing no logic with CALL_RE.
+     */
+    private static readonly OPEN_FORM_RE;
+    /** SQL assigned to a local variable, e.g. `m_SQL = "SELECT ..." & ...`. */
+    private static readonly SQL_VAR_ASSIGN_RE;
+    /** SQL wrapper called with a variable, e.g. `getdb().Execute m_SQL`. */
+    private static readonly SQL_VAR_EXEC_RE;
+    /** SQL table-name regex scoped to FROM / INTO / UPDATE. */
+    private static readonly SQL_TABLE_RE;
+    /**
+     * `Me.<ControlName>` reference capture — hole 1 of VBA control-modeling.
+     *
+     * Real VBA idiom:
+     *   `Me.lblTitulo.Caption = "Hello"`            ← property assignment
+     *   `Me.txtDescripcion.Value = "World"`          ← property assignment
+     *   `Me.ComandoGrabar.Enabled = True`           ← property assignment
+     *   `If Nz(Me.MotivoBorrado, "") = "" Then`      ← read in expression
+     *
+     * The existing call-site scanner (CALL_RE) only fires on `Name(`
+     * (paren form) and `Me` is in its keyword blacklist anyway, so
+     * `Me.<Control>` references are silently invisible. This regex matches
+     * the FIRST identifier after `Me.` regardless of what follows (a
+     * property, an index, an assignment, a call argument, etc.) so the
+     * form → control binding is surfaced as an UnresolvedReference for the
+     * resolver to pick up later. Subsequent segments (`.Caption`, `.Value`,
+     * `.Enabled`) are intentionally NOT captured — they are properties of
+     * the control, not new symbols.
+     *
+     * Provenance: `metadata.synthesizedBy = 'vba-me-control'`. Mirrors the
+     * `vba-form-binding` (form→sibling-`.cls`) and `vba-name-resolution`
+     * (qualified Dim) patterns already documented on `UnresolvedReference.metadata`
+     * in `src/types.ts`.
+     */
+    private static readonly ME_CONTROL_RE;
+    /** Keywords we never want to match as call receivers. */
+    private static readonly CALL_KEYWORD_BLACKLIST;
+    /**
+     * Access runtime objects and singletons. Calls on these receivers are
+     * real VBA calls but the targets are NOT user-defined modules or
+     * classes — they're Access/DAO/ADO runtime types. Synthesizing a
+     * `function` node for each would pollute the graph with ~20+ junk
+     * nodes per real-world file (audit W4, June 2026). Skip synthesis
+     * for any receiver or member in this set.
+     *
+     * Note: `DoCmd.RunSQL`, `DoCmd.OpenForm`, etc. still get SQL/edge
+     * tracking via the dedicated `SQL_WRAPPERS` regex path (REQ-CODE-8),
+     * which fires BEFORE this scan and uses its own dispatch — so
+     * blacklisting DoCmd here doesn't lose the SQL-flow edges.
+     */
+    private static readonly RUNTIME_RECEIVER_BLACKLIST;
+    /**
+     * Fix 2 (Issue #2): replace string-literal content with spaces so that
+     * call-site patterns inside `"..."` spans are invisible to CALL_RE and
+     * the statement-form detectors.  Column positions are preserved (each
+     * character is replaced 1-for-1) so any col-based metadata stays correct.
+     */
+    private static maskStringContent;
+    /**
+     * Fix 2 (Issue #2): return true iff `receiverName` is a file-local variable
+     * (appears in `localVarTypeMap`) whose declared type is a SIMPLE (non-
+     * qualified, non-primitive) identifier — a candidate project-defined class.
+     * Qualified types (e.g. `DAO.Recordset`) and primitives (`String`, `Long`)
+     * return false so runtime/DAO calls are suppressed.
+     */
+    private isLocalProjectClassVar;
+    private sweepCallsAndSql;
+    private scanCallSites;
+    /** Cache so we don't re-emit the same proc function node per call site. */
+    private procNodeIdCache;
+    private callDedupe;
+    private synthFunctionNodeIds;
+    /**
+     * B4 (hueco 6): cache of stub `form-layout` node ids we've already emitted
+     * for a given target form name in this file. Avoids emitting duplicate
+     * stubs when `DoCmd.OpenForm "FormTest"` shows up N times across N calls.
+     * Keyed by the lowercased form name so `FormTest` / `formtest` collapse.
+     */
+    private opensFormStubIdsByName;
+    /**
+     * Hueco 1: scan a line for `Me.<ControlName>` patterns and emit one
+     * UnresolvedReference per occurrence, tagged
+     * `metadata.synthesizedBy: 'vba-me-control'`.
+     *
+     * Operates on the masked `callScanLine` (string-literal content already
+     * replaced with spaces) so `Me.X` inside a string literal is not falsely
+     * captured. Per-site emission — every `Me.lblTitulo` reference site
+     * produces its own UnresolvedReference carrying the line/column; the
+     * resolver fans them out into multiple `references` edges at index time
+     * once the matching `form-instance-control` node exists.
+     *
+     * `fromNodeId` is the current procedure's function node — that's the
+     * "owner" of the reference (the Sub body that wrote `Me.lblTitulo = …`).
+     */
+    private scanMeControlReferences;
+    private findOrCreateFunctionNodeId;
+    private findFunctionNodeByName;
+    /**
+     * H1: detect a statement-form Sub call.
+     *
+     * Real VBA idioms:
+     *   `MySub`                           — bare no-argument statement call
+     *   `MySub arg1, Nz(x, 0)`            — bare statement call
+     *   `Call MySub arg1, Nz(x, 0)`       — Call keyword, no parens around call
+     *   `MySub(arg1, arg2)`               — parens call (handled by CALL_RE)
+     *   `Call MySub(arg1, arg2)`          — Call keyword + parens (also CALL_RE)
+     *
+     * Returns the called proc name if the line matches the statement form
+     * AND the proc name is in localProcs (same-file resolution). Returns
+     * null for declarations, assignments, comments, keyword lines, etc.
+     *
+     * The `Call` keyword form is handled by stripping `Call ` and
+     * running the same logic on the remainder — they're structurally the
+     * same call after the keyword.
+     */
+    private detectStatementCall;
+    /**
+     * H1: emit a same-file `calls` edge for a statement-form Sub call.
+     * `caller` is the current procedure (from the stack); `procName` is
+     * the called procedure name. Emits a plain `calls` edge to the
+     * already-emitted function node.
+     */
+    private emitStatementCallEdge;
+    /**
+     * Fix 7: detect a qualified statement-form call — `Receiver.Member <args>`
+     * where `Receiver.Member` is NOT followed by `(`.
+     *
+     * Real VBA idioms this covers:
+     *   `m_NCOp.Registrar m_ARAlInicio, p_Error`
+     *   `m_Obj.Init`
+     *
+     * These are distinct from the paren form (`m_NCOp.Registrar(...)`) which is
+     * already handled by `CALL_RE`. Returns `{receiver, member}` or `null`.
+     *
+     * Property assignments (`Receiver.Prop = value`) are excluded via the `=`
+     * guard — consistent with `detectStatementCall`'s same-file assignment skip.
+     * Blacklisted receivers (runtime objects, keywords) are excluded too.
+     */
+    private detectQualifiedStatementCall;
+    /**
+     * Fix 7: emit a heuristic `calls` edge for a qualified statement-form call.
+     * Same shape as the qualified-paren path in `scanCallSites` — reuses the
+     * same `callDedupe` / `synthFunctionNodeIds` sets for de-duplication so a
+     * paren and non-paren form on the same line don't create duplicate edges.
+     */
+    private emitQualifiedStatementCallEdge;
+    /**
+     * B4 (hueco 6): scan one line of VBA source for `DoCmd.OpenForm "X"`
+     * calls. For each match, emit:
+     *  - a stub `form-layout` node for the target form (cached by name so
+     *    the same form referenced from N sites emits exactly ONE stub),
+     *  - an `opens-form` heuristic edge from the calling Sub to that stub.
+     *
+     * Both endpoints are pushed into `this.nodes` / `this.edges`, so the
+     * per-file edge filter at `index.ts:insertedIds.has(source) &&
+     * insertedIds.has(target)` passes the edge naturally without any
+     * exemption to the filter.
+     *
+     * Why a stub and not a direct lookup: the target form lives in a
+     * DIFFERENT file (its own `.form.txt`), and the extractor doesn't have
+     * DB access at parse time. The stub's synthetic file path
+     * (`synthetic:opensFormStub/<FormName>.form.txt`) guarantees a
+     * deterministic node id so re-indexes collapse to the same stub.
+     * When the consumer's `.form.txt` is later indexed, the real
+     * `form-layout` node carries a different id (it uses the real file
+     * path); the stub and the real coexist harmlessly. The orchestrator
+     * flagged this as acceptable for B4 — only `OpenForm` is in scope.
+     * `OpenReport`, `OpenQuery`, `OpenTable`, … are follow-up work.
+     *
+     * Scope note: this regex matches ONLY the literal-string form
+     * `DoCmd.OpenForm "X"`. Variable-form calls like
+     * `DoCmd.OpenForm m_FormName` are intentionally NOT captured here
+     * because resolving the variable to a concrete form name would
+     * require data-flow analysis that is out of scope.
+     */
+    private scanOpenFormCalls;
+    /**
+     * B4 (hueco 6): emit a stub `form-layout` node for `targetFormName`
+     * (cached so duplicates collapse) and an `opens-form` heuristic edge
+     * from `caller` to that stub.
+     *
+     * The edge carries:
+     *  - `kind: 'opens-form'`                — new cross-file edge kind
+     *  - `provenance: 'heuristic'`           — synthesized, not parsed
+     *  - `metadata.targetFormName`           — the captured literal
+     *  - `metadata.synthesizedBy: 'vba-opens-form'` — distinguishes this
+     *    synthesis from the dim/sql/event-handler families
+     *
+     * The stub's `metadata.stub: true` flag lets downstream UI render
+     * unresolved references distinctly (e.g. with a dashed border) and
+     * gives later re-resolution pass a hook for collapse. The stub is
+     * line-independent (`line = 0`) so re-indexes produce identical ids.
+     */
+    private emitOpensFormEdge;
+    private scanSqlInLine;
+    private trackSqlVariableAssignment;
+    private collectStringLiteralText;
+    private emitSqlTableReferences;
+    /**
+     * Emit a `references` edge from the file's module/class node to a synthetic
+     * node named `targetName`. Used by Dim, WithEvents, Implements, and SQL.
+     */
+    private emitReference;
+    private synthClassNodeIds;
+    /**
+     * Fix 2 (Issue #2): maps `variableName.toLowerCase()` → declared type info.
+     * Built by `sweepDimsAndWithEvents`; consulted by `sweepCallsAndSql` to gate
+     * qualified statement-form calls — only receivers that are file-local variables
+     * typed as a SIMPLE (non-qualified, non-primitive) identifier emit edges.
+     */
+    private localVarTypeMap;
+}
+//# sourceMappingURL=vba-extractor.d.ts.map

package/lib/dist/extraction/vba-extractor.d.ts.map

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