@aroman22/codegraph-vba-darwin-arm64 1.5.1 → 1.6.0

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

@@ -2,962 +2,14 @@ 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);
+    private ctx;
+    private vbaTargets?;
+    constructor(filePath: string, source: string, vbaTargets?: Record<string, boolean>);
     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;
-    /** `[visibility] Event <Name>(...)` custom event declaration. */
-    private static readonly EVENT_DECL_RE;
-    /** `[visibility] Type <Name>` user-defined type block start. */
-    private static readonly TYPE_START_RE;
-    /** `End Type` user-defined type block end. */
-    private static readonly TYPE_END_RE;
-    /** `<MemberName> As <Type>` inside a user-defined type block. */
-    private static readonly TYPE_MEMBER_RE;
-    /** `[visibility] Declare [PtrSafe] Sub|Function <Name> Lib "dll" [Alias "x"] ...` */
-    private static readonly DLL_DECLARE_RE;
-    /**
-     * Roadmap #26 declaration sweep:
-     * - Event declarations become `event` nodes and `RaiseEvent` can point to them.
-     * - Type...End Type blocks become `type` + `type_member` nodes.
-     * - Win32 API Declare statements become `declare` nodes, while still being
-     *   cached by name so normal call-site scanning can emit `calls` edges.
-     */
-    private sweepEventsTypesAndDeclares;
-    /** 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.
-     * Issue #47: now also accepts `Global` (module-level typed instance) and
-     * `Static` (procedure-local retention modifier) so they emit the same
-     * `references` edge and `localVarTypeMap` registration as their `Dim`
-     * siblings today. The negative lookahead is unchanged: `Const` is still
-     * routed to `sweepEnumsAndConsts`.
-     */
-    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) bracketed outer type, (3) unbracketed
-     * outer type, (4) bracketed inner type (if qualified), (5) unbracketed
-     * inner type. The variable name is always bare (`Dim` cannot declare a
-     * bracketed variable). The TYPE position accepts BOTH bracketed names
-     * with spaces (e.g. `[Clase Con Espacios]`) and bare identifiers — the
-     * bracketed capture wins when present. Only one of (2)/(3) and one of
-     * (4)/(5) is ever populated per match.
-     * `(?:New\s+)?` consumes the VBA auto-instantiation keyword so it is
-     * never captured as the type name (Fix 1).
-     *
-     * Issue #54: extends the type alternative to accept `[Name With Spaces]`
-     * so `Dim x As [Clase Con Espacios]` emits a `references` edge to
-     * `Clase Con Espacios` (brackets unwrapped). The unwrap is applied in
-     * the sweep loop by picking the bracketed capture group when present.
-     */
-    private static readonly DIM_ALL_VARS_RE;
-    /**
-     * Bare-declared variable capture for the `Dim|Private|Public|Global|Static`
-     * prefix. Captures (1) the variable name. Used to register bare `Dim x`
-     * (no `As` clause) and explicit-primitive `Dim x As Long|String|...`
-     * declarations into `localVarTypeMap` so the type tracking is consistent
-     * across all three Dim shapes:
-     *
-     *   `Dim x`                → outer = 'variant' (VBA default)
-     *   `Dim x As Variant`     → outer = 'variant'  (PRIMITIVE_TYPES member)
-     *   `Dim x As Long`        → outer = 'long'     (PRIMITIVE_TYPES member)
-     *   `Dim x As Foo`         → outer = 'foo'      (project class — non-primitive)
-     *
-     * Antigravity audit Task 3: the previous `DIM_ALL_VARS_RE` only matched
-     * the `... As <Type>` form, so a bare `Dim x` was invisible to
-     * `isLocalProjectClassVar` / `scanCallSites` and `x.Method(1)` produced
-     * a dead-end `calls` edge to a stub named `x.Method` that no resolver
-     * could repoint. Registering bare Dim with `outer = 'variant'` closes
-     * the gate, so `scanCallSites` skips ONLY when the receiver is mapped
-     * as a primitive — leaving the "undeclared receiver → stub → resolver
-     * repoints" path intact for cross-module qualified calls like
-     * `modUtils.Foo(1)` (`modUtils` is not in `localVarTypeMap`).
-     */
-    private static readonly BARE_DIM_VAR_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/Global/Static 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;
-    /**
-     * Issue #52: shared `End Sub` / `End Function` / `End Property` marker.
-     * Promoted from a local regex in `sweepCallsAndSql` so `sweepEnumsAndConsts`
-     * can walk the same proc boundaries and decide Const scope per line.
-     * The `(?:^|:\s*)` prefix tolerates colon-separated single-line procs
-     * (`Public Sub X(): ... : End Sub`) so the proc stack pops on the same
-     * physical line.
-     */
-    private static readonly PROCEDURE_END_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 captures either `Name(...)` (same-file candidate) or
-     * `Receiver.Member(...)` (qualified — emit a synthetic node + heuristic
-     * edge). The receiver AND member alternatives accept BOTH the bare form
-     * (`Foo`) and the VBA bracketed form (`[Foo Bar]`) — bracketed captures
-     * win when present. Only one of (1)/(2) and one of (3)/(4) is ever
-     * populated per match. Brackets are stripped by the regex itself (the
-     * capture groups hold the inner content), so callers receive unwrapped
-     * identifiers and the `${name}.${proc}` stub shape stays canonical.
-     *
-     * Issue #54: the bracketed alternative was previously absent, so
-     * `[FUNCIONES UTILES].FormatearFecha(fecha)` (a real Dysflow-exported
-     * idiom for modules with spaces in their names) was silently dropped.
-     */
-    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 literal and bare-identifier forms):
-     *   `DoCmd.OpenForm "MyForm"`
-     *   `DoCmd.OpenForm FORM_MY_FORM`
-     *   `DoCmd.OpenForm "MyForm", acNormal, , , acFormEdit`
-     *
-     * Captures the first argument (group 1). String literals are unwrapped;
-     * bare identifiers resolve against local Const declarations, falling back
-     * to the identifier name when unknown. The trailing positional args
-     * (`acNormal`, `acFormEdit`, etc.) are intentionally NOT captured.
-     *
-     * 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_ARG_RE;
-    /**
-     * Issue #48: `DoCmd.OpenReport "<ReportName>"` modelling regex — sibling
-     * of `OPEN_FORM_ARG_RE` (hueco 6 expanded). Same literal-or-bare-id argument
-     * capture (group 1) and same trailing positional-args drop. The dispatch
-     * table `DOCMD_OPEN_DISPATCH` (below) carries the per-method metadata so
-     * OpenForm and OpenReport share the same scan/emit pipeline while their
-     * edge kinds (`opens-form` vs `opens-report`), stub node kinds
-     * (`form-layout` vs `report-layout`), synthetic file-path prefixes, and
-     * qualifiedName prefixes (`Form_<Name>` vs `Report_<Name>`) stay
-     * distinct.
-     */
-    private static readonly OPEN_REPORT_ARG_RE;
-    /**
-     * Issue #48 dispatch table — shared literal-or-Const argument resolution
-     * for `DoCmd.OpenForm` and `DoCmd.OpenReport`. Each entry is everything
-     * `scanDoCmdOpenCalls` + `emitOpensStubEdge` need to share the pipeline
-     * between methods while keeping the per-method names distinct.
-     *
-     * OpenQuery is intentionally NOT in this dispatch — it emits an
-     * `UnresolvedReference` (not a stub + edge), resolution to the REAL
-     * `query` node emitted by `SqlQueryExtractor`. See
-     * `OPEN_QUERY_ARG_RE` + `scanDoCmdOpenQuery`.
-     *
-     * Why a separate dispatch: `DoCmd` is in `RUNTIME_RECEIVER_BLACKLIST`
-     * (R4 invariant), so ALL of these methods are intentionally SKIPPED by
-     * the generic `CALL_RE` path that would otherwise emit a junk `calls`
-     * edge to a synthetic `function` node for `DoCmd.OpenX`. This dispatch
-     * matches BEFORE the call-site scan and uses its own emission path.
-     */
-    private static readonly DOCMD_OPEN_DISPATCH;
-    /**
-     * Issue #48: `DoCmd.OpenQuery "<QueryName>"` modelling regex. Emits an
-     * `UnresolvedReference` (NOT a stub + edge) so the resolver binds to the
-     * REAL `query` node `SqlQueryExtractor` emits for `queries/<Name>.sql`
-     * — the same shape as `vba-me-control` and `vba-forms-bang`. The query
-     * may not yet exist in the index when the .bas is parsed; the resolver
-     * does the binding when the .sql is later indexed.
-     *
-     * Argument shape: identical to OpenForm/OpenReport — literal `"..."` or
-     * bare identifier resolved against local `Const` declarations, falling
-     * back to the bare identifier when unknown.
-     */
-    private static readonly OPEN_QUERY_ARG_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;
-    /**
-     * Issue #42: `DoCmd.RunSQL <identifier>` (variable form) — the dominant
-     * Access idiom for executing a dynamically-built SQL string. Today only
-     * the literal form `DoCmd.RunSQL "DELETE FROM X"` is tracked via the
-     * `SQL_WRAPPERS` regex at line 1108; the variable form silently dropped
-     * table impact for every procedure that builds SQL in a string and runs
-     * it through `DoCmd.RunSQL`.
-     *
-     * This regex is the DoCmd.RunSQL analogue of `SQL_VAR_EXEC_RE` above and
-     * is iterated by `scanSqlInLine` (lines 2051+). When a match is found,
-     * the captured identifier is resolved against `sqlVariables` (populated
-     * by `trackSqlVariableAssignment` with `&`-accumulate semantics — Issue
-     * #13) and the resulting SQL string drives `emitSqlTableReferences`.
-     *
-     * The optional `(?:\(\))?` + `\s*\(?` shape lets the regex match both
-     * the parenthesised form `DoCmd.RunSQL(strSQL)` and the no-paren form
-     * `DoCmd.RunSQL strSQL` that the existing SQL_WRAPPERS literal regex
-     * does not cover. The captured identifier is the only thing we need —
-     * we DO NOT try to parse what the variable points at; that's the
-     * existing `sqlVariables` map's job.
-     */
-    private static readonly SQL_VAR_DOCMD_RUNSQL_RE;
-    /**
-     * SQL table-name regex scoped to the clauses that introduce a table
-     * reference: `FROM <t>`, `JOIN <t>`, `INTO <t>`, `UPDATE <t>`. Adding
-     * `JOIN` lets the scanner pick up tables from joined fragments that
-     * arrive via `&`-concatenated wrapper literals (e.g.
-     * `db.Execute "FROM A" & " JOIN B"`); without it the second literal's
-     * table was silently dropped even though the wrapper regex now matches
-     * the chain.
-     *
-     * The captured table name is an optional bracketed/unbracketed schema
-     * prefix followed by a `.`, then a bracketed-or-bare identifier — so
-     * `FROM dbo.tblCustomers` and `FROM [My Schema].[My Table]` come
-     * through as one composite reference. Without the prefix the regex
-     * still matches a single identifier byte-identical to the old shape.
-     * Brackets in the captured composite are stripped by
-     * `emitSqlTableReferences` (`replace(/[\[\]]/g, '')`), so the public
-     * node name is the unwrapped form `dbo.tblCustomers` /
-     * `My Schema.My Table` — matching how plain `[Order Details]` is also
-     * unwrapped to `Order Details`. The identifier class
-     * `\[[^\]]+\]|\p{L}[\p{L}\p{N}_]*` (same as the saved-queries
-     * `TABLE_RE` in `sql-query-extractor.ts`) ensures bracketed names
-     * with spaces — `[Order Details]`, `[My Schema]`, `[My Table]` —
-     * are captured whole.
-     */
-    private static readonly SQL_TABLE_RE;
-    /**
-     * Issue #50: TempVars — Access's global key-value store for cross-form
-     * state. We model each STATIC-LITERAL key as a synthetic `class` placeholder
-     * (same NodeKind as SQL table refs, see `emitReference`) and emit one
-     * `references` edge per reading/writing procedure with
-     * `metadata.synthesizedBy: 'vba-tempvar'` and `metadata.access` ∈
-     * `{'read','write'}` (the user-facing enum; lowercase single-tokens).
-     *
-     * Three scanner surfaces cover the four real idioms:
-     *   - `TEMP_VAR_BANG_RE`  — `TempVars!clave`         (no parens; write or read)
-     *   - `TEMP_VAR_PAREN_RE` — `TempVars("clave")`      (parens; write or read)
-     *   - `TEMP_VAR_ADD_RE`   — `TempVars.Add "clave", v` (always a write)
-     *
-     * Bang vs paren split by line-source: the bang form has no string literals
-     * in scope, so we scan the MASKED line (`maskStringContent` replaces
-     * `"…"` content with spaces — same line source the call-site / With
-     * event scanners consume). The paren and Add forms have their key INSIDE
-     * a `"…"` literal that gets blanked by the masker, so those regexes scan
-     * the ORIGINAL (unmasked) line — same split the SQL_TABLE_RE/OpenForm
-     * literal scanners already use.
-     *
-     * Dynamic-key forms — `TempVars(strNombre)`,
-     * `TempVars("clave" & suffix)` — are silently unmatched by all three
-     * regexes (none of them tolerate a function-call or `&` arg). REQ-CODE-4
-     * "unresolvable is silent" applies: these stay silent by design to
-     * prevent placeholder-node explosion.
-     */
-    private static readonly TEMP_VAR_BANG_RE;
-    /**
-     * Issue #50 (cont.):
-     * `TempVars("clave")` / `TempVars(  "clave"  )` capture. Scanned
-     * over the original (unmasked) line — the literal lives INSIDE a
-     * string and would be stripped by `maskStringContent`.
-     */
-    private static readonly TEMP_VAR_PAREN_RE;
-    /**
-     * Issue #50 (cont.):
-     * `TempVars.Add "clave", value` capture. Always a write (the
-     * `.Add` method inserts/updates the entry). Scanned over the
-     * original (unmasked) line for the same string-literal reason as
-     * `TEMP_VAR_PAREN_RE`.
-     */
-    private static readonly TEMP_VAR_ADD_RE;
-    /**
-     * `Me.<ControlName>` / `Me!<ControlName>` reference capture — hole 1
-     * of VBA control-modeling. Extended by Issue #44 to accept the bang
-     * form (the default-collection shortcut Access VBA inherits from VB).
-     *
-     * Real VBA idioms:
-     *   `Me.lblTitulo.Caption = "Hello"`            ← dot form, property assignment
-     *   `Me.txtDescripcion.Value = "World"`          ← dot form, property assignment
-     *   `Me.ComandoGrabar.Enabled = True`           ← dot form, property assignment
-     *   `Me!txtNombre = "Hello"`                    ← BANG form (default collection)
-     *   `Me!txtEstado.Value = 1`                    ← BANG form, then property
-     *   `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.` or `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. The bang (`!`) is the default-collection
-     * shortcut: `Me!txtFoo` is semantically identical to `Me.txtFoo` and
-     * produces a byte-identical UnresolvedReference (same `referenceName`,
-     * `referenceKind`, and `metadata.synthesizedBy`) — the regression test
-     * in `__tests__/extraction-vba.test.ts` pins this parity.
-     *
-     * 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;
-    /**
-     * Issue #44: `Forms!<FormName>` / `Forms("<FormName>")!<Ctl>` cross-form
-     * reference capture — companion to `ME_CONTROL_RE` above. Access VBA's
-     * default-collection shortcut for cross-form control access, captured
-     * BEFORE the generic call-site scan and emitted as its own
-     * `UnresolvedReference` family.
-     *
-     * Real VBA idioms:
-     *   `Forms!FormX!txtY.Value = 1`         — bang form, with control segment
-     *   `Forms!FormX.Recordsource = "..."`   — bang form, trailing property access
-     *   `Set f = Forms!FormX`                — bang form, no control segment
-     *   `Forms("FormX")!txtY.Value = 1`      — paren form, with control
-     *   `Forms![Mi Formulario]!txtY`         — bracketed form name (#54 mirror)
-     *
-     * Why a dedicated scanner (mirroring `OPEN_FORM_ARG_RE` / B4 / DoCmd.OpenForm):
-     *   `Forms` is in `RUNTIME_RECEIVER_BLACKLIST`, so the generic CALL_RE
-     *   path silently skips both `Forms!X` and `Forms("X")!Y`. Without this
-     *   scanner, cross-form UI traffic from `Forms!FormX!txtY.Value` would
-     *   never surface the form → control binding that the resolver needs to
-     *   glue form `form-layout` nodes to control `form-instance-control`
-     *   nodes. The dedicated dispatch fires BEFORE the call-site scan and
-     *   uses its own emission path; the runtime-blacklist constraint is
-     *   preserved (we intentionally do not rewrite CALL_RE).
-     *
-     * What this scanner emits per match:
-     *   - ONE `UnresolvedReference` whose `referenceName` is the form's
-     *     identifier (stripped of any surrounding quote or bracket
-     *     decoration), tagged `metadata.synthesizedBy = 'vba-forms-bang'`
-     *     and `referenceKind = 'references'`. The control segment (if
-     *     present) is consumed by the regex so `Forms!FormX!txtY.Value` is
-     *     captured as a single match, but the control name is NOT emitted
-     *     as its own reference — control emission is the form's
-     *     responsibility downstream.
-     *   - NO synthetic `function` node (W4 graph-pollution invariant — the
-     *     form is a real `.cls` / `.form.txt` pair the resolver already
-     *     picks up via the `vba-form-binding` path). Without this guard the
-     *     bang form would synthesize one stub per cross-form reference
-     *     site, identical to what `bumpShapes` from #43 audited out.
-     *
-     * What this scanner does NOT match (intentional, pinned by tests):
-     *   - `Forms!FormX.Foo`           — the trailing `.Foo` IS a property
-     *     access on the form (e.g. `Recordsource`), NOT a control access.
-     *     The bang alternative carries a `(?![.\w])` negative-lookahead
-     *     after the form identifier to drop this shape. The "W4
-     *     no-synthetic-fn" test pins both halves of this contract.
-     *   - `rs!Campo`                  — recordset field access (DAO/ADO
-     *     default-member field read) is explicitly out of scope for the
-     *     current change. The runtime-receiver blacklist plus the absence
-     *     of any `Forms`/`Me` prefix means the existing scanners already
-     *     skip it cleanly; the "STRETCH SCOPE" test pins that behaviour
-     *     so a future change to bring recordset bangs in is reviewed
-     *     explicitly against the bang-form scope decision.
-     *
-     * Operates on the ORIGINAL (unmasked) line — the paren form
-     * `Forms("FormX")!txtY` has the form name INSIDE a string literal, so
-     * masking string content would destroy the form identifier. Same
-     * unmasked-line constraint as `scanOpenFormCalls`.
-     */
-    private static readonly FORMS_BANG_RE;
-    /**
-     * Issue #46: scan `Set <var> = New <Type>[.<Inner>]` lines — the dominant
-     * VBA late-instantiation idiom. Run inside `sweepCallsAndSql`'s proc-stack
-     * loop so the surrounding procedure is known. For each match:
-     *   - register `<var>` in `localVarTypeMap` with `outer=<Type>`,
-     *     `qualified=<hasInner>`, `assignedWithSet=true` so the PR #61 refined
-     *     gate lets subsequent `<var>.Member ...` qualified calls resolve via
-     *     the resolved class name;
-     *   - emit a `references` edge from the module/class node to a synthetic
-     *     node named `<Type>`, tagged `synthesizedBy: 'vba-set-new'`.
-     *
-     * Groups: (1) variable name, (2) outer type, (3) optional inner type.
-     * Operates on the MASKED line (string-literal content already replaced
-     * with spaces) so `Set x = New Foo` inside a string literal never matches.
-     */
-    private static readonly SET_NEW_RE;
-    /** Issue #43: track the receiver for `With <expr>` / `End With` blocks. */
-    private static readonly WITH_START_RE;
-    private static readonly WITH_END_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.
-     *
-     * Issue #54 (defensive): brackets are stripped from the lookup key, so a
-     * caller that forgets to unwrap a bracketed name still finds the
-     * corresponding entry. This is a no-op when the name is already bare —
-     * the unwrap pattern only matches an opening `[` at the start and a
-     * closing `]` at the end. Today's call sites (`scanCallSites`,
-     * `detectQualifiedStatementCall`) already unwrap in the regex captures,
-     * so this defensive strip is a belt-and-braces guard for any future
-     * caller that forgets.
-     */
-    private isLocalProjectClassVar;
-    /**
-     * Qualified-call eligibility is intentionally shared by paren-form
-     * (`Receiver.Member(...)`) and statement-form (`Receiver.Member args`) scans:
-     * project-class locals are processed after type resolution, declared
-     * primitive/external locals are silent, and undeclared receivers remain
-     * candidate module names.
-     */
-    private shouldProcessQualifiedCall;
-    /**
-     * #12a: resolve the "receiver type" used to build a qualified call-stub's
-     * name/qualifiedName. When `receiverName` is a file-local variable typed
-     * as a candidate project class (`isLocalProjectClassVar`), returns the
-     * RESOLVED CLASS NAME from `localVarTypeMap` (e.g. `m_NCOp` typed
-     * `As NCOperaciones` → `'NCOperaciones'`) so the stub's qualifiedName
-     * matches the real `.cls` method's `${className}.${proc}` shape and the
-     * post-extraction resolver (#12b) can find it via an exact qualifiedName
-     * match. Otherwise returns `receiverName` unchanged — this is the case
-     * for `.bas`-qualified module calls (`modUtils.Foo`), where the receiver
-     * IS already the target module's name and no resolution is needed.
-     */
-    private resolveReceiverType;
-    private normalizeWithReceiver;
-    private detectWithMemberCall;
-    private sweepCallsAndSql;
-    private static readonly RAISE_EVENT_RE;
-    private scanRaiseEvents;
-    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) extended by Issue #48: cache of stub node ids we've already
-     * emitted for a given (method, target name) pair in this file. Avoids
-     * emitting duplicate stubs when `DoCmd.OpenForm "FormTest"` or
-     * `DoCmd.OpenReport "InformeMensual"` shows up N times across N calls.
-     * Keyed by `${cacheKey}:${lowerName}` so the OpenForm and OpenReport
-     * de-dup buckets stay disjoint — `OpenForm:Form1` ≠ `OpenReport:Form1`.
-     * The name part is lowercased so `FormTest` / `formtest` collapse.
-     */
-    private opensStubIdsByKey;
-    /**
-     * Hueco 1: scan a line for `Me.<ControlName>` / `Me!<ControlName>`
-     * patterns and emit one UnresolvedReference per occurrence, tagged
-     * `metadata.synthesizedBy: 'vba-me-control'`. Issue #44 extended
-     * `ME_CONTROL_RE` from `Me\.` to `Me[.!]` so the bang form (default-
-     * collection shortcut) is captured byte-identically to the dot form.
-     *
-     * 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 = …`).
-     * The +3 column offset remains correct under Issue #44's regex change
-     * because both `Me.` and `Me!` are 3-character prefixes.
-     */
-    private scanMeControlReferences;
-    /**
-     * Issue #44: scan a line for cross-form bang references
-     * (`Forms!<FormName>[!<Ctl>]` and `Forms("<FormName>")!<Ctl>`) and
-     * emit ONE UnresolvedReference per match with `metadata.synthesizedBy
-     * = 'vba-forms-bang'`. Companion to `scanMeControlReferences` above;
-     * shares the emission shape (a single `UnresolvedReference` per match,
-     * `referenceKind: 'references'`), keeping the W4 invariant that we
-     * synthesize NO `function` node for forms.
-     *
-     * Operates on the ORIGINAL (unmasked) line — the paren form
-     * `Forms("FormX")!txtY` carries the form name INSIDE a string literal
-     * and would be destroyed by `maskStringContent`. Mirrors
-     * `scanOpenFormCalls`'s unmasked-line constraint.
-     *
-     * Regex alternatives (see `FORMS_BANG_RE`):
-     *   1. `Forms!<FormName>` (bare or `[bracketed]`, NOT followed by `.X`)
-     *      — bang form, may have a trailing `!<Ctl>[.<Prop>]` that is
-     *      consumed but NOT emitted.
-     *   2. `Forms("<FormName>")!<Ctl>` (quoted or bare/bracketed form arg)
-     *      — paren form, ALWAYS with a control segment.
-     *
-     * Stripping: the form's identifier is unwrapped of `"` quotes (string
-     * literals) and `[…]` brackets (Issue #54 reserved-identifier shape) so
-     * the public `referenceName` is the bare form name. Bracketed forms
-     * (`Forms![Mi Formulario]`) follow the same strip rules as the paren
-     * form so the resolver sees `Mi Formulario` either way.
-     */
-    private scanFormsBang;
-    private findOrCreateFunctionNodeId;
-    private findFunctionNodeByName;
-    /**
-     * Issue #45: split a single-line VBA `If <cond> Then <body>` into one or
-     * more statement-clause fragments that the existing `detectStatementCall`
-     * and `detectQualifiedStatementCall` detectors can process. Handles:
-     *
-     *   - `If x Then Foo`             → `['Foo']`
-     *   - `If x Then Foo Else Bar`    → `['Foo', 'Bar']`
-     *   - `If x Then DoA: DoB`        → `['DoA', 'DoB']` (colon-separated multi-statement)
-     *   - `If x Then Foo Else A: B`   → `['Foo', 'A', 'B']`
-     *   - `If x Then GoTo fin`        → `[]` (GoTo clause filtered out)
-     *   - `If x Then Exit Sub`        → `[]` (Exit clause filtered out)
-     *
-     * When the line does NOT match a single-line `If … Then` shape — for
-     * instance a block-form `If x Then` whose body lives on subsequent
-     * lines — the splitter returns `[<line>]` (the original input) so
-     * callers can use this method unconditionally and let the existing
-     * per-line scan pick up the body on a separate line.
-     *
-     * `GoTo`, `Exit`, and `Resume` clauses are filtered at the fragment
-     * level (defense in depth): even though `emitStatementCallEdge` already
-     * drops these via the `CALL_KEYWORD_BLACKLIST`, filtering here prevents
-     * any chance of `detectStatementCall`'s generic identifier extractor
-     * matching a substring (e.g. an identifier like `GoToFinishingTouches`)
-     * as a side effect of a richer clause where the keyword happens to be
-     * the leading token.
-     *
-     * `line` is the string-literal-masked scan line. The mask makes global
-     * `:` splitting safe: real VBA colons never appear inside string
-     * literals (already masked to spaces) and never inside expressions
-     * inside parens at the source level (a colon ends a statement in VBA,
-     * so it cannot appear inside a parenthesised argument list either).
-     * The `Else` keyword is a VBA statement-level separator and is
-     * forbidden inside parens or expressions, so splitting on
-     * `\s+Else\s+` does not need paren tracking either.
-     */
-    private splitSingleLineIfClauses;
-    /**
-     * 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) extended by Issue #48: scan one line of VBA source for
-     * `DoCmd.OpenX "Target"` calls where X ∈ {Form, Report} (see the
-     * `DOCMD_OPEN_DISPATCH` table). For each match, emit:
-     *  - a stub node (form-layout / report-layout) for the target, cached
-     *    per-(method, name) so the same target referenced from N sites
-     *    emits exactly ONE stub,
-     *  - an `opens-form` / `opens-report` 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/report lives in a
-     * DIFFERENT file (its own `.form.txt` / `.report.txt`), and the extractor
-     * doesn't have DB access at parse time. The stub's synthetic file path
-     * (`synthetic:opensFormStub/<Name>.form.txt` /
-     * `synthetic:opensReportStub/<Name>.form.txt`) guarantees a deterministic
-     * node id so re-indexes collapse to the same stub. When the consumer's
-     * `.form.txt` / `.report.txt` is later indexed, the real
-     * `form-layout` / `report-layout` node carries a different id (it uses
-     * the real file path); the stub and the real coexist harmlessly.
-     *
-     * Why a separate dispatch from CALL_RE: `DoCmd` is in
-     * `RUNTIME_RECEIVER_BLACKLIST` (R4 invariant), so `DoCmd.OpenForm` /
-     * `DoCmd.OpenReport` are intentionally SKIPPED by the generic CALL_RE
-     * path that would otherwise emit a junk `calls` edge to a synthetic
-     * `function` node for `DoCmd.OpenX`. The dispatch below matches BEFORE
-     * the call-site scan and uses its own emission path.
-     *
-     * Scope note: literal-string and bare-identifier argument forms are
-     * supported. Bare identifiers resolve only through local `Const`
-     * declarations; arbitrary variable data-flow remains intentionally
-     * out of scope.
-     */
-    private scanDoCmdOpenCalls;
-    /**
-     * B4 (hueco 6) extended by Issue #48: emit a stub `form-layout` /
-     * `report-layout` node for `targetName` (cached per dispatch entry so
-     * duplicates collapse and OpenForm/OpenReport de-dup buckets stay
-     * disjoint) and a single `opens-form` / `opens-report` heuristic edge
-     * from `caller` to that stub.
-     *
-     * The edge carries:
-     *  - `kind` — dispatch-specific (`opens-form` / `opens-report`)
-     *  - `provenance: 'heuristic'` — synthesized, not parsed
-     *  - `metadata.<dispatchTargetKey>` (e.g. `targetFormName`) — the resolved name
-     *  - `metadata.synthesizedBy` — dispatch-specific (`vba-opens-form` /
-     *    `vba-opens-report`); distinguishes this synthesis from the
-     *    dim/sql/event-handler families
-     *
-     * The stub's `metadata.stub: true` flag lets downstream UI render
-     * stubs 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 emitOpensStubEdge;
-    /**
-     * Issue #48: scan one line of VBA source for `DoCmd.OpenQuery "X"` calls.
-     * Each match emits ONE `UnresolvedReference` (NOT a stub + edge) so the
-     * resolver binds to the REAL `query` node that `SqlQueryExtractor`
-     * produces for `queries/<Name>.sql` (dysflow exports every saved QueryDef
-     * + `queries.json` manifest). Falls back to silent when the .sql is not
-     * yet in the index — the resolver does the binding when it's later
-     * indexed, exactly like `vba-me-control` and `vba-forms-bang`.
-     *
-     * Companion to `scanDoCmdOpenCalls` but intentionally NOT in the
-     * dispatch table — OpenQuery's emission shape (`UnresolvedReference`)
-     * is structurally different from OpenForm/OpenReport's (synthetic node
-     * + heuristic edge). The two pipelines share the literal-vs-Const
-     * argument resolution pattern via `localConstants.get(...)` but emit
-     * via two different branches of `unresolvedReferences` vs
-     * `nodes`/`edges`.
-     *
-     * UnresolvedReference shape (per Issue #48 spec — must match
-     * SqlQueryExtractor's query node name exactly):
-     *   - `referenceName`                 = resolved query name
-     *   - `referenceKind: 'references'`    = same kind the resolver binds
-     *   - `metadata.synthesizedBy: 'vba-opens-query'`
-     *   - NO synthetic `function` node (W4 graph-pollution invariant — the
-     *     real `query` node already exists in the index once `.sql` is
-     *     processed, and creating stubs would compete with the binding).
-     */
-    private scanDoCmdOpenQuery;
-    /**
-     * Regex matching the chained `& "..."` literals that may follow a
-     * wrapper's first literal on the same physical line. Captures the
-     * literal CONTENT (group 1); the surrounding `&` and quotes are
-     * structural, not data. VBA allows whitespace around `&` and around
-     * the inner quotes — handled with `\s*`. The `((?:[^"]|"")*)` body
-     * mirrors the wrapper regex so a `""` inside a chained literal still
-     * decodes to a single `"`.
-     *
-     * Cross-physical-line concat via `_` continuation is OUT OF SCOPE for
-     * v1 (deferred; see commit message).
-     */
-    private static readonly SQL_WRAPPER_CHAIN_RE;
-    /**
-     * Given the text that follows a SQL wrapper's first literal on the same
-     * physical line, return the contents of every `& "..."` chained literal
-     * in source order. Operates per-physical-line only — VBA `_` line
-     * continuation across physical lines is handled separately by
-     * `collectStringLiteralText` for the variable-assignment path.
-     */
-    private collectSqlWrapperChain;
-    private scanSqlInLine;
-    /**
-     * #13 fix: `sql = sql & "..."` (self-referential concatenation) must
-     * ACCUMULATE the new fragment onto whatever was already tracked for
-     * `varName`, not overwrite it. Overwriting silently dropped earlier
-     * fragments' tables — typically the initial `FROM <table>` in
-     * `sql = "SELECT * FROM tblA"` followed by `sql = sql & " WHERE x=1"`.
-     *
-     * Detection: the RHS (`m[2]`, trimmed) starts with `<varName> &`,
-     * case-insensitively — matching VBA's case-insensitive identifiers (`Sql`
-     * and `sql` are the same variable). A genuine fresh assignment (RHS does
-     * NOT start with the self-reference) still RESETS tracking — that
-     * behavior is unchanged.
-     */
-    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;
-    /**
-     * Issue #50: TempVars placeholder-node de-dup cache. Keys are the
-     * deterministic node ids produced by `emitTempVarReference` — those
-     * ids intentionally ignore `this.filePath` (use a synthetic
-     * `synthetic:tempvar/<key>` path instead) so the SAME key referenced
-     * from Form_A.cls AND Form_B.cls collapses to ONE placeholder node.
-     * Cross-file id stability is the cross-form state premise that makes
-     * `codegraph_explore` connect producer ⇄ consumer in one hop.
-     */
-    private synthTempVarNodeIds;
-    /**
-     * Issue #50: emit one TempVar reading/writing site. Per call:
-     *   - placeholder `class` node keyed on the synthetic
-     *     `synthetic:tempvar/<key>` file path so cross-file extraction
-     *     calls collapse to one node per key,
-     *   - `references` edge from the calling `function` node
-     *     (via `findOrCreateFunctionNodeId` — same access pattern as
-     *     `scanDoCmdOpenCalls` / `scanDoCmdOpenQuery`) carrying
-     *     `metadata.synthesizedBy: 'vba-tempvar'` AND
-     *     `metadata.access: 'read' | 'write'`.
-     *
-     * Reuses the synthetic-`class`-placeholder shape established by
-     * `emitReference` for SQL tables, events, Dim types, etc. — so every
-     * synthesized `references` edge in the file already carries the same
-     * `kind: 'class'` target, and downstream consumers (UI, resolvers,
-     * search queries) filter on `metadata.synthesizedBy` rather than
-     * NodeKind anyway. The `metadata.synthesizedBy` tag cleanly distinguishes
-     * TempVars refs from SQL-table refs inside the same NodeKind bucket.
-     *
-     * Skips when stack is empty (the writer/reader is module-level code
-     * — REQ-CODE-4 "unresolvable/runtime reference is silent"). The
-     * spec wires this per-proc only; the module-level shape would need
-     * a different emission (no procedure source) and is out of scope.
-     */
-    private emitTempVarReference;
-    /**
-     * Issue #50: scan one line of VBA source for TempVars access sites and
-     * emit one `references` edge per site. Three regex runs:
-     *   - bang form `TempVars!x` over the MASKED line (`!` itself never
-     *     lives inside a string literal, so masked == unmasked here — using
-     *     the masked line is conservative against false positives in
-     *     concatenated string content),
-     *   - paren form `TempVars("x")` over the ORIGINAL line (the literal is
-     *     inside a string — masked would strip the key),
-     *   - Add form `TempVars.Add "x", v` over the ORIGINAL line (same reason),
-     *     always classified as a write.
-     *
-     * Each match classifies access by looking at the LINE SUFFIX (after the
-     * closing paren / bang-key) on the SAME line: if `=` (and not the
-     * nonexistent `==`) is the next non-whitespace character, it's a write.
-     * VBA has no `==` so a bare `=` suffix check is safe.
-     *
-     * The caller parameter comes from `stack[stack.length - 1]` in
-     * `sweepCallsAndSql`. Pass `undefined` for module-level access — we
-     * drop the edge (per REQ-CODE-4 spirit, runtime references have no
-     * static source to anchor against).
-     */
-    private sweepTempVars;
-    /**
-     * Maps `variableName.toLowerCase()` → declared type info.
-     * Built by `sweepDimsAndWithEvents`; consulted by the unified qualified-call
-     * gate (`shouldProcessQualifiedCall`) so declared project-class locals emit
-     * edges, declared primitive/external locals stay silent, and undeclared
-     * receivers remain module-name candidates for the resolver (Fix 2 / Issue #2).
-     */
-    private localVarTypeMap;
-    /**
-     * Issue #52: Const resolution buckets, scoped per procedure. Key is
-     * `'module'` for module-level Consts, or the procedure's `startLine`
-     * (stringified) for proc-local Consts. Each bucket maps the lowercase
-     * constant name to its simple-literal value (used by `DoCmd.OpenForm` /
-     * `OpenReport` / `OpenQuery` argument resolution via `resolveLocalConst`).
-     *
-     * Two procs declaring the same Const name with different values stay
-     * isolated (each in its own bucket); reads look up the current proc's
-     * bucket first and fall back to the module bucket. The bucket-per-proc
-     * model was chosen over a single file-wide Map (the pre-fix shape) so
-     * `DoCmd.OpenForm FORM_DESTINO` resolves to the proc-local value, not
-     * whichever was written last.
-     */
-    private localConstants;
-    /**
-     * Issue #52: shared lookup helper for `scanDoCmdOpenCalls` and
-     * `scanDoCmdOpenQuery`. The current scope is the procedure whose
-     * `startLine` is on top of `procStack` (or `'module'` when the stack is
-     * empty). Per-proc bucket first; module bucket is the fallback.
-     */
-    private resolveLocalConst;
-    /**
-     * Issue #52: shared writer. `scopeKey` is `'module'` or the procedure's
-     * startLine-as-string. Creates the bucket lazily so callers do not have
-     * to pre-allocate per proc. Returns the bucket the value was written to
-     * (mostly useful for tests; production code ignores it).
-     */
-    private setLocalConstInScope;
-    /**
-     * Issue #52: the current Const-lookup scope. `'module'` when no procedure
-     * is open, otherwise the top-of-stack proc's `startLine` as a string.
-     * Both `sweepEnumsAndConsts` (to decide whether to emit a `constant`
-     * node) and `sweepCallsAndSql` (to drive OpenForm/OpenQuery resolution)
-     * keep this in sync with their per-line stack walk by pushing/popping
-     * `procStack` and writing the new top's key here.
-     */
-    private currentProcKey;
-    /**
-     * Issue #52: per-extraction proc-stack shared between `sweepEnumsAndConsts`
-     * and `sweepCallsAndSql`. Each sweep clears it at the start so the file's
-     * mid-proc structural state never leaks across sweeps. Holds the
-     * `startLine` (1-based, matches `ProcInfo.startLine`) of every procedure
-     * whose body the sweep has not yet emitted `End Sub`/`End Function`/
-     * `End Property` for.
-     */
-    private procStack;
-    /** Local event name (lowercase) → event node for `RaiseEvent` edge emission. */
-    private localEvents;
 }
 //# sourceMappingURL=vba-extractor.d.ts.map