@aroman22/codegraph-vba-darwin-arm64 1.3.5 → 1.5.0

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

@@ -94,17 +94,56 @@ export declare class VbaExtractor {
      * 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) type outer part, (3) type inner part (if qualified).
+     * 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.
@@ -114,7 +153,7 @@ export declare class VbaExtractor {
      * 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. */
+    /** `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. */
@@ -130,6 +169,15 @@ export declare class VbaExtractor {
     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`,
@@ -165,9 +213,18 @@ export declare class VbaExtractor {
      *  - 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).
+     * 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. */
@@ -193,30 +250,169 @@ export declare class VbaExtractor {
      * 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;
-    /** SQL table-name regex scoped to FROM / INTO / UPDATE. */
+    /**
+     * 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;
     /**
-     * `Me.<ControlName>` reference capture — hole 1 of VBA control-modeling.
+     * 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 idiom:
-     *   `Me.lblTitulo.Caption = "Hello"`            ← property assignment
-     *   `Me.txtDescripcion.Value = "World"`          ← property assignment
-     *   `Me.ComandoGrabar.Enabled = True`           ← property assignment
+     * 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.` regardless of what follows (a
-     * property, an index, an assignment, a call argument, etc.) so the
+     * 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 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`
@@ -224,6 +420,84 @@ export declare class VbaExtractor {
      * 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;
     /**
@@ -253,6 +527,15 @@ export declare class VbaExtractor {
      * 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;
     /**
@@ -268,6 +551,8 @@ export declare class VbaExtractor {
      * 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;
@@ -277,16 +562,21 @@ export declare class VbaExtractor {
     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.
+     * 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 opensFormStubIdsByName;
+    private opensStubIdsByKey;
     /**
-     * Hueco 1: scan a line for `Me.<ControlName>` patterns and emit one
-     * UnresolvedReference per occurrence, tagged
-     * `metadata.synthesizedBy: 'vba-me-control'`.
+     * 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
@@ -297,10 +587,76 @@ export declare class VbaExtractor {
      *
      * `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.
      *
@@ -351,51 +707,112 @@ export declare class VbaExtractor {
      */
     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.
+     * 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 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 literal-string and bare-identifier forms.
-     * Bare identifiers are resolved only through local `Const` declarations;
-     * arbitrary variable data-flow remains intentionally 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
+     * 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: '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
+     *  - `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
-     * unresolved references distinctly (e.g. with a dashed border) and
-     * gives later re-resolution pass a hook for collapse. The stub is
+     * 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 emitOpensFormEdge;
+    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
@@ -419,6 +836,64 @@ export declare class VbaExtractor {
      */
     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;
     /**
      * Fix 2 (Issue #2): maps `variableName.toLowerCase()` → declared type info.
      * Built by `sweepDimsAndWithEvents`; consulted by `sweepCallsAndSql` to gate
@@ -426,8 +901,53 @@ export declare class VbaExtractor {
      * typed as a SIMPLE (non-qualified, non-primitive) identifier emit edges.
      */
     private localVarTypeMap;
-    /** Local constant name (lowercase) → simple literal value for OpenForm resolution. */
+    /**
+     * 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;
 }