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

package/lib/dist/extraction/vba-extractor.js

@@ -127,12 +127,13 @@ class VbaExtractor {
                 this.nodes.push(this.createFileNode());
                 return this.result(startTime);
             }
-            // Pre-process pipeline (per design): join continuations, strip comments,
-            // then we sweep the joined-but-uncommented source for call sites and
-            // SQL strings. Comments are gone before regex runs, so no commented
-            // SQL can match the SQL regex.
+            // Pre-process pipeline (per design): join continuations, blank inactive
+            // conditional-compilation branches, strip comments, then sweep the
+            // joined-but-uncommented source. The conditional preprocessor preserves
+            // line count by replacing directives/inactive lines with empty strings.
             const joined = (0, vba_preprocess_1.joinLineContinuations)(this.source);
-            const uncommented = (0, vba_preprocess_1.stripVbaComments)(joined);
+            const preprocessed = (0, vba_preprocess_1.preprocessConditionalCompilation)(joined);
+            const uncommented = (0, vba_preprocess_1.stripVbaComments)(preprocessed);
             // Create the file node.
             this.nodes.push(this.createFileNode());
             // Resolve the file's "kind" — .cls → class, else module (including .bas
@@ -160,6 +161,12 @@ class VbaExtractor {
             const procs = this.sweepProcedures(uncommented);
             if (procs.length > 0)
                 hasAnySymbols = true;
+            // Sweep: first-class Event / Type / Declare declarations (roadmap #26).
+            // This runs before call-site scanning so `RaiseEvent Foo` and calls to a
+            // `Declare` can resolve to real local nodes rather than fall through.
+            const declarationCount = this.sweepEventsTypesAndDeclares(uncommented);
+            if (declarationCount > 0)
+                hasAnySymbols = true;
             // Sweep: Implements (REQ-CODE-5).
             const implCount = this.sweepImplements(uncommented);
             if (implCount > 0)
@@ -477,6 +484,159 @@ class VbaExtractor {
         }
         return procs;
     }
+    /** `[visibility] Event <Name>(...)` custom event declaration. */
+    static EVENT_DECL_RE = /^\s*((?:Public|Private|Friend)\s+)?Event\s+(\p{L}[\p{L}\p{N}_]*)\b/iu;
+    /** `[visibility] Type <Name>` user-defined type block start. */
+    static TYPE_START_RE = /^\s*((?:Public|Private|Friend)\s+)?Type\s+(\p{L}[\p{L}\p{N}_]*)\b/iu;
+    /** `End Type` user-defined type block end. */
+    static TYPE_END_RE = /^\s*End\s+Type\b/iu;
+    /** `<MemberName> As <Type>` inside a user-defined type block. */
+    static TYPE_MEMBER_RE = /^\s*(\p{L}[\p{L}\p{N}_]*)\s*(?:\([^)]*\))?\s+As\s+(.+?)\s*$/iu;
+    /** `[visibility] Declare [PtrSafe] Sub|Function <Name> Lib "dll" [Alias "x"] ...` */
+    static DLL_DECLARE_RE = /^\s*((?:Public|Private)\s+)?Declare\s+(PtrSafe\s+)?(Sub|Function)\s+(\p{L}[\p{L}\p{N}_]*)\s+Lib\s+"([^"]+)"(?:\s+Alias\s+"([^"]+)")?/iu;
+    /**
+     * 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.
+     */
+    sweepEventsTypesAndDeclares(src) {
+        const lines = src.split('\n');
+        let count = 0;
+        let currentType = null;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i] ?? '';
+            const lineNum = i + 1;
+            if (currentType) {
+                if (VbaExtractor.TYPE_END_RE.test(line)) {
+                    currentType = null;
+                    continue;
+                }
+                const member = VbaExtractor.TYPE_MEMBER_RE.exec(line);
+                if (member) {
+                    const memberName = member[1] ?? '';
+                    const memberType = (member[2] ?? '').trim();
+                    if (!memberName)
+                        continue;
+                    const memberId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'type_member', memberName, lineNum);
+                    this.nodes.push({
+                        id: memberId,
+                        kind: 'type_member',
+                        name: memberName,
+                        qualifiedName: `${currentType.name}.${memberName}`,
+                        filePath: this.filePath,
+                        language: 'vba',
+                        startLine: lineNum,
+                        endLine: lineNum,
+                        startColumn: 0,
+                        endColumn: line.length,
+                        metadata: { memberType },
+                        updatedAt: Date.now(),
+                    });
+                    this.edges.push({
+                        source: currentType.id,
+                        target: memberId,
+                        kind: 'type-member',
+                        provenance: 'parser',
+                    });
+                }
+                continue;
+            }
+            const eventDecl = VbaExtractor.EVENT_DECL_RE.exec(line);
+            if (eventDecl) {
+                const visibility = VbaExtractor.foldVisibility(eventDecl[1] ?? '');
+                const name = eventDecl[2] ?? '';
+                if (!name)
+                    continue;
+                const eventId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'event', name, lineNum);
+                const eventNode = {
+                    id: eventId,
+                    kind: 'event',
+                    name,
+                    qualifiedName: this.classNamePrefix ? `${this.classNamePrefix}.${name}` : name,
+                    filePath: this.filePath,
+                    language: 'vba',
+                    startLine: lineNum,
+                    endLine: lineNum,
+                    startColumn: 0,
+                    endColumn: line.length,
+                    visibility,
+                    updatedAt: Date.now(),
+                };
+                this.nodes.push(eventNode);
+                this.localEvents.set(name.toLowerCase(), eventNode);
+                this.pushContainsFromModule(eventId);
+                count++;
+                continue;
+            }
+            const typeStart = VbaExtractor.TYPE_START_RE.exec(line);
+            if (typeStart) {
+                const visibility = VbaExtractor.foldVisibility(typeStart[1] ?? '');
+                const name = typeStart[2] ?? '';
+                if (!name)
+                    continue;
+                const typeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'type', name, lineNum);
+                this.nodes.push({
+                    id: typeId,
+                    kind: 'type',
+                    name,
+                    qualifiedName: this.classNamePrefix ? `${this.classNamePrefix}.${name}` : name,
+                    filePath: this.filePath,
+                    language: 'vba',
+                    startLine: lineNum,
+                    endLine: lineNum,
+                    startColumn: 0,
+                    endColumn: line.length,
+                    visibility,
+                    updatedAt: Date.now(),
+                });
+                this.pushContainsFromModule(typeId);
+                currentType = { id: typeId, name };
+                count++;
+                continue;
+            }
+            const declaration = VbaExtractor.DLL_DECLARE_RE.exec(line);
+            if (declaration) {
+                const visibility = VbaExtractor.foldVisibility(declaration[1] ?? '');
+                const ptrSafe = !!declaration[2];
+                const declareKind = (declaration[3] ?? '').toLowerCase();
+                const name = declaration[4] ?? '';
+                const dll = declaration[5] ?? '';
+                const aliasName = declaration[6] ?? undefined;
+                if (!name)
+                    continue;
+                const declareId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'declare', name, lineNum);
+                const declareNode = {
+                    id: declareId,
+                    kind: 'declare',
+                    name,
+                    qualifiedName: this.classNamePrefix ? `${this.classNamePrefix}.${name}` : name,
+                    filePath: this.filePath,
+                    language: 'vba',
+                    startLine: lineNum,
+                    endLine: lineNum,
+                    startColumn: 0,
+                    endColumn: line.length,
+                    visibility,
+                    metadata: {
+                        dll,
+                        declareKind,
+                        ptrSafe,
+                        ...(aliasName ? { aliasName } : {}),
+                    },
+                    updatedAt: Date.now(),
+                };
+                this.nodes.push(declareNode);
+                if (!this.functionNodeByName.has(name)) {
+                    this.functionNodeByName.set(name, declareNode);
+                }
+                this.pushContainsFromModule(declareId);
+                count++;
+            }
+        }
+        return count;
+    }
     /** Implements regex. */
     static IMPLEMENTS_RE = /^\s*Implements\s+(\p{L}[\p{L}\p{N}_]*)/iu;
     /** Edges whose source needs to be set to the module/class id once it exists. */
@@ -615,9 +775,28 @@ class VbaExtractor {
                         this.localVarTypeMap.set(weVarName.toLowerCase(), {
                             outer: formType,
                             qualified: false,
+                            withEvents: true,
+                            variableName: weVarName,
                         });
                     }
                     this.emitReference(formType, lineNum, 0, 'vba-withevents');
+                    const targetId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'class', formType, 0);
+                    const subscriberEdge = {
+                        source: this.moduleOrClassNode?.id ?? '',
+                        target: targetId,
+                        kind: 'subscribes-event',
+                        provenance: 'heuristic',
+                        metadata: {
+                            synthesizedBy: 'vba-withevents',
+                            variableName: weVarName || undefined,
+                        },
+                        line: lineNum,
+                        column: 0,
+                    };
+                    this.edges.push(subscriberEdge);
+                    if (!this.moduleOrClassNode) {
+                        this.pendingModuleOrClassSource.push(subscriberEdge);
+                    }
                     count++;
                 }
             }
@@ -637,13 +816,6 @@ class VbaExtractor {
     static ENUM_MEMBER_RE = /^\s*(\p{L}[\p{L}\p{N}_]*)\s*(?:=|$)/u;
     /** `[visibility] Const <decls>` — captures visibility (1) and the rest (2). */
     static CONST_DECL_RE = /^\s*(?:(Public|Private|Friend|Global)\s+)?Const\s+(.+)$/i;
-    /**
-     * One declared name inside a `Const` body. A name sits at a declaration
-     * boundary (start-of-body or after a comma), optionally followed by
-     * `As <Type>`, then `=`. Run with /g over the CONST_DECL_RE group 2 so
-     * multi-name lines (`Const A = 1, B = 2`) emit one node per name.
-     */
-    static CONST_NAME_RE = /(?:^|,)\s*(\p{L}[\p{L}\p{N}_]*)\s*(?:As\s+[\p{L}\p{N}_.]+\s*)?=/giu;
     /**
      * Fold a VBA visibility keyword to the canonical lowercase enum, matching
      * the procedure convention: `Private` → 'private'; `Public`, `Global`,
@@ -652,7 +824,7 @@ class VbaExtractor {
      * sweep uses so visibility is consistent across symbol kinds).
      */
     static foldVisibility(raw) {
-        return raw.toLowerCase() === 'private' ? 'private' : 'public';
+        return raw.trim().toLowerCase() === 'private' ? 'private' : 'public';
     }
     /**
      * Walk the (uncommented, line-joined) source and emit:
@@ -736,12 +908,14 @@ class VbaExtractor {
             if (constDecl) {
                 const visibility = VbaExtractor.foldVisibility(constDecl[1] ?? '');
                 const body = constDecl[2] ?? '';
-                VbaExtractor.CONST_NAME_RE.lastIndex = 0;
-                let cm;
-                while ((cm = VbaExtractor.CONST_NAME_RE.exec(body)) !== null) {
-                    const constName = cm[1] ?? '';
+                const declarations = parseConstDeclarations(body);
+                for (const declaration of declarations) {
+                    const constName = declaration.name;
                     if (!constName)
                         continue;
+                    if (declaration.value !== null) {
+                        this.localConstants.set(constName.toLowerCase(), declaration.value);
+                    }
                     const constId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'constant', constName, lineNum);
                     this.nodes.push({
                         id: constId,
@@ -755,6 +929,7 @@ class VbaExtractor {
                         startColumn: 0,
                         endColumn: line.length,
                         visibility,
+                        metadata: declaration.value !== null ? { value: declaration.value } : undefined,
                         updatedAt: Date.now(),
                     });
                     this.pushContainsFromModule(constId);
@@ -798,9 +973,8 @@ class VbaExtractor {
     /** SQL wrapper helpers — order matters because `db.Execute` is a suffix of others. */
     static SQL_WRAPPERS = [
         { name: 'DoCmd.RunSQL', re: /\bDoCmd\.RunSQL\s+"((?:[^"]|"")*)"/g },
-        { name: 'CurrentDb.OpenRecordset', re: /\bCurrentDb\.OpenRecordset\s+"((?:[^"]|"")*)"/g },
-        { name: 'CurrentDb.Execute', re: /\bCurrentDb\.Execute\s+"((?:[^"]|"")*)"/g },
-        { name: 'db.Execute', re: /\bdb\.Execute\s+"((?:[^"]|"")*)"/g },
+        { name: '*db.OpenRecordset', re: /\b(?:\p{L}[\p{L}\p{N}_]*)?db\b(?:\(\))?\.OpenRecordset\s+"((?:[^"]|"")*)"/giu },
+        { name: '*db.Execute', re: /\b(?:\p{L}[\p{L}\p{N}_]*)?db\b(?:\(\))?\.Execute\s+"((?:[^"]|"")*)"/giu },
         // Fix 4 (Issue #4): inline-literal forms `getdb().Execute "..."` and
         // `getdb().OpenRecordset "..."` — the variable form is covered by
         // SQL_VAR_EXEC_RE but the direct-literal form was missing.
@@ -810,16 +984,15 @@ class VbaExtractor {
     /**
      * `DoCmd.OpenForm "<FormName>"` modelling regex — B4 (hueco 6).
      *
-     * Real VBA idiom (matches both forms):
+     * Real VBA idiom (matches literal and bare-identifier forms):
      *   `DoCmd.OpenForm "MyForm"`
+     *   `DoCmd.OpenForm FORM_MY_FORM`
      *   `DoCmd.OpenForm "MyForm", acNormal, , , acFormEdit`
      *
-     * Captures the form NAME (group 1) so the extractor can synthesize an
-     * `opens-form` heuristic edge from the calling Sub to a stub for the
-     * target form. The trailing positional args (`acNormal`, `acFormEdit`,
-     * etc.) are intentionally NOT captured — the orchestrator's scope decision
-     * was to cover ONLY `OpenForm` for this commit; `OpenReport`, `OpenQuery`,
-     * `OpenTable`, … are flagged in the commit body as follow-up work.
+     * 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
@@ -828,11 +1001,11 @@ class VbaExtractor {
      * matches BEFORE the call-site scan and uses its own dispatch to emit
      * the `opens-form` edge instead — sharing no logic with CALL_RE.
      */
-    static OPEN_FORM_RE = /\bDoCmd\.OpenForm\s+"([^"]+)"/g;
+    static OPEN_FORM_ARG_RE = /\bDoCmd\.OpenForm\s+("(?:(?:[^"]|"")*)"|\p{L}[\p{L}\p{N}_]*)/gu;
     /** SQL assigned to a local variable, e.g. `m_SQL = "SELECT ..." & ...`. */
     static SQL_VAR_ASSIGN_RE = /^\s*(\p{L}[\p{L}\p{N}_]*)\s*=\s*(.*)$/iu;
     /** SQL wrapper called with a variable, e.g. `getdb().Execute m_SQL`. */
-    static SQL_VAR_EXEC_RE = /\b(?:getdb\(\)|CurrentDb|db)\.(?:OpenRecordset|Execute)\s*\(?\s*(\p{L}[\p{L}\p{N}_]*)\s*\)?/giu;
+    static SQL_VAR_EXEC_RE = /\b(?:\p{L}[\p{L}\p{N}_]*)?db\b(?:\(\))?\.(?:OpenRecordset|Execute)\s*\(?\s*(\p{L}[\p{L}\p{N}_]*)\s*\)?/giu;
     /** SQL table-name regex scoped to FROM / INTO / UPDATE. */
     static SQL_TABLE_RE = /\b(?:FROM|INTO|UPDATE)\s+(\[?\p{L}[\p{L}\p{N}_]*\]?)/giu;
     /**
@@ -994,6 +1167,26 @@ class VbaExtractor {
             return false;
         return true;
     }
+    /**
+     * #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.
+     */
+    resolveReceiverType(receiverName) {
+        if (this.isLocalProjectClassVar(receiverName)) {
+            const entry = this.localVarTypeMap.get(receiverName.toLowerCase());
+            if (entry)
+                return entry.outer;
+        }
+        return receiverName;
+    }
     sweepCallsAndSql(src) {
         const lines = src.split('\n');
         const procedureStartLines = new Set();
@@ -1049,7 +1242,9 @@ class VbaExtractor {
             // Don't scan call sites on the line that declares the procedure — it
             // would match the proc name itself in `Sub Outer()`.
             if (!procedureStartLines.has(lineNum) && stack.length > 0) {
-                this.scanCallSites(callScanLine, stack[stack.length - 1], lineNum);
+                const currentProc = stack[stack.length - 1];
+                this.scanRaiseEvents(callScanLine, currentProc, lineNum);
+                this.scanCallSites(callScanLine, currentProc, lineNum);
             }
             // Hueco 1: capture `Me.<Control>` references (property assignments,
             // read expressions, method calls, anything after `Me.`). Only inside
@@ -1127,6 +1322,26 @@ class VbaExtractor {
                 n.endLine = end;
         }
     }
+    static RAISE_EVENT_RE = /\bRaiseEvent\s+(\p{L}[\p{L}\p{N}_]*)\b/giu;
+    scanRaiseEvents(line, from, lineNum) {
+        VbaExtractor.RAISE_EVENT_RE.lastIndex = 0;
+        let m;
+        while ((m = VbaExtractor.RAISE_EVENT_RE.exec(line)) !== null) {
+            const eventName = m[1] ?? '';
+            const eventNode = this.localEvents.get(eventName.toLowerCase());
+            if (!eventNode)
+                continue;
+            this.edges.push({
+                source: this.findOrCreateFunctionNodeId(from),
+                target: eventNode.id,
+                kind: 'raises-event',
+                provenance: 'parser',
+                metadata: { eventName },
+                line: lineNum,
+                column: m.index,
+            });
+        }
+    }
     scanCallSites(line, from, lineNum) {
         VbaExtractor.CALL_RE.lastIndex = 0;
         let m;
@@ -1153,10 +1368,6 @@ class VbaExtractor {
             const col = m.index;
             if (!member) {
                 // Bare `Name(...)` — same-file resolution.
-                const bucket = this.localProcs.get(receiver);
-                const local = bucket?.[0];
-                if (!local)
-                    continue; // unresolvable — silent per spec R4.
                 const localFuncNode = this.findFunctionNodeByName(receiver);
                 if (!localFuncNode)
                     continue;
@@ -1170,7 +1381,13 @@ class VbaExtractor {
             }
             else {
                 // Qualified `Receiver.Member(...)` — synthesize the call target.
-                const qualified = `${receiver}.${member}`;
+                // #12a: `receiverType` resolves to the real class name when
+                // `receiver` is a declared project-class local var (matching a real
+                // `.cls` method's `${className}.${proc}` qualifiedName shape so the
+                // #12b resolver can find it by exact match); otherwise it's the raw
+                // `receiver` text unchanged (e.g. `.bas`-qualified module calls).
+                const receiverType = this.resolveReceiverType(receiver);
+                const qualified = `${receiverType}.${member}`;
                 // Avoid emitting duplicate edges for the same call (within a line).
                 const dedupeKey = `${from.name}->${qualified}@${lineNum}`;
                 if (this.callDedupe.has(dedupeKey))
@@ -1192,6 +1409,10 @@ class VbaExtractor {
                         startColumn: col,
                         endColumn: col + qualified.length,
                         visibility: 'public',
+                        // #12a: tag the stub so the post-extraction resolver (#12b)
+                        // can find and repoint it. Mirrors the DoCmd.OpenForm stub
+                        // precedent (`emitOpensFormEdge`).
+                        metadata: { stub: true },
                         updatedAt: Date.now(),
                     });
                 }
@@ -1200,7 +1421,12 @@ class VbaExtractor {
                     target: synthId,
                     kind: 'calls',
                     provenance: 'heuristic',
-                    metadata: { synthesizedBy: 'vba-name-resolution' },
+                    metadata: {
+                        synthesizedBy: 'vba-name-resolution',
+                        stub: true,
+                        receiverType,
+                        member,
+                    },
                     line: lineNum,
                     column: col,
                 });
@@ -1351,9 +1577,6 @@ class VbaExtractor {
             return;
         if (VbaExtractor.RUNTIME_RECEIVER_BLACKLIST.has(procName))
             return;
-        const bucket = this.localProcs.get(procName);
-        if (!bucket || !bucket[0])
-            return;
         const target = this.findFunctionNodeByName(procName);
         if (!target)
             return;
@@ -1440,7 +1663,15 @@ class VbaExtractor {
      * paren and non-paren form on the same line don't create duplicate edges.
      */
     emitQualifiedStatementCallEdge(caller, receiver, member, lineNum) {
-        const qualified = `${receiver}.${member}`;
+        // #12a: the caller already checked `isLocalProjectClassVar(receiver)`
+        // before calling this method, so `resolveReceiverType` always returns
+        // the RESOLVED CLASS NAME here — the stub's name/qualifiedName matches
+        // the real `.cls` method's `${className}.${proc}` shape (e.g.
+        // `m_NCOp` typed `As NCOperaciones` → `NCOperaciones.Registrar`, not
+        // `m_NCOp.Registrar`) so the #12b resolver can find it by exact
+        // qualifiedName match.
+        const receiverType = this.resolveReceiverType(receiver);
+        const qualified = `${receiverType}.${member}`;
         const dedupeKey = `${caller.name}->${qualified}@${lineNum}`;
         if (this.callDedupe.has(dedupeKey))
             return;
@@ -1460,6 +1691,7 @@ class VbaExtractor {
                 startColumn: 0,
                 endColumn: qualified.length,
                 visibility: 'public',
+                metadata: { stub: true },
                 updatedAt: Date.now(),
             });
         }
@@ -1468,7 +1700,12 @@ class VbaExtractor {
             target: synthId,
             kind: 'calls',
             provenance: 'heuristic',
-            metadata: { synthesizedBy: 'vba-name-resolution' },
+            metadata: {
+                synthesizedBy: 'vba-name-resolution',
+                stub: true,
+                receiverType,
+                member,
+            },
             line: lineNum,
             column: 0,
         });
@@ -1496,19 +1733,20 @@ class VbaExtractor {
      * flagged this as acceptable for B4 — only `OpenForm` is in scope.
      * `OpenReport`, `OpenQuery`, `OpenTable`, … are follow-up work.
      *
-     * Scope note: this regex matches ONLY the literal-string form
-     * `DoCmd.OpenForm "X"`. Variable-form calls like
-     * `DoCmd.OpenForm m_FormName` are intentionally NOT captured here
-     * because resolving the variable to a concrete form name would
-     * require data-flow analysis that is out of scope.
+     * 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.
      */
     scanOpenFormCalls(line, caller, lineNum) {
         // Each regex has /g so we MUST reset `lastIndex` before use; cloning
         // the regex is the simplest way to avoid leaking state across lines.
-        const localRe = new RegExp(VbaExtractor.OPEN_FORM_RE.source, VbaExtractor.OPEN_FORM_RE.flags);
+        const localRe = new RegExp(VbaExtractor.OPEN_FORM_ARG_RE.source, VbaExtractor.OPEN_FORM_ARG_RE.flags);
         let m;
         while ((m = localRe.exec(line)) !== null) {
-            const targetFormName = (m[1] ?? '').trim();
+            const rawArg = (m[1] ?? '').trim();
+            const targetFormName = rawArg.startsWith('"')
+                ? unwrapVbaStringLiteral(rawArg)
+                : (this.localConstants.get(rawArg.toLowerCase()) ?? rawArg);
             if (!targetFormName)
                 continue;
             this.emitOpensFormEdge(caller, targetFormName, lineNum, m.index);
@@ -1592,16 +1830,38 @@ class VbaExtractor {
             this.emitSqlTableReferences(sqlString, lineNum, dedupe);
         }
     }
+    /**
+     * #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.
+     */
     trackSqlVariableAssignment(lines, lineIndex, sqlVariables) {
         const line = lines[lineIndex] ?? '';
         const m = VbaExtractor.SQL_VAR_ASSIGN_RE.exec(line);
         if (!m)
             return;
-        const varName = (m[1] ?? '').toLowerCase();
-        const sqlText = this.collectStringLiteralText(lines, lineIndex);
-        if (!sqlText)
+        const rawVarName = m[1] ?? '';
+        const varName = rawVarName.toLowerCase();
+        const rhs = (m[2] ?? '').trim();
+        const newFragment = this.collectStringLiteralText(lines, lineIndex);
+        if (!newFragment)
             return;
-        sqlVariables.set(varName, sqlText);
+        const selfRefRe = new RegExp(`^${escapeRegExpLiteral(rawVarName)}\\s*&`, 'i');
+        const existing = sqlVariables.get(varName);
+        if (existing !== undefined && selfRefRe.test(rhs)) {
+            sqlVariables.set(varName, `${existing} ${newFragment}`);
+        }
+        else {
+            sqlVariables.set(varName, newFragment);
+        }
     }
     collectStringLiteralText(lines, startIndex) {
         const fragments = [];
@@ -1683,8 +1943,83 @@ class VbaExtractor {
      * typed as a SIMPLE (non-qualified, non-primitive) identifier emit edges.
      */
     localVarTypeMap = new Map();
+    /** Local constant name (lowercase) → simple literal value for OpenForm resolution. */
+    localConstants = new Map();
+    /** Local event name (lowercase) → event node for `RaiseEvent` edge emission. */
+    localEvents = new Map();
 }
 exports.VbaExtractor = VbaExtractor;
+/**
+ * #13 helper: escape a variable name for safe interpolation into the
+ * self-reference RegExp built by `trackSqlVariableAssignment`. VBA
+ * identifiers are alphanumeric+underscore only, so in practice nothing here
+ * ever needs escaping — this guards against regex metacharacters anyway
+ * rather than assume the input is always well-formed.
+ */
+function escapeRegExpLiteral(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function parseConstDeclarations(body) {
+    const declarations = [];
+    for (const part of splitOutsideVbaStrings(body, ',')) {
+        const m = /^\s*(\p{L}[\p{L}\p{N}_]*)\s*(?:As\s+[^=]+?)?\s*=\s*(.+?)\s*$/iu.exec(part);
+        if (!m)
+            continue;
+        const name = m[1] ?? '';
+        const rawValue = (m[2] ?? '').trim();
+        declarations.push({
+            name,
+            value: rawValue.startsWith('"') ? unwrapVbaStringLiteral(rawValue) : rawValue || null,
+        });
+    }
+    return declarations;
+}
+function splitOutsideVbaStrings(value, separator) {
+    const parts = [];
+    let current = '';
+    let inString = false;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        const next = value[i + 1];
+        if (ch === '"') {
+            current += ch;
+            if (inString && next === '"') {
+                current += next;
+                i++;
+                continue;
+            }
+            inString = !inString;
+            continue;
+        }
+        if (!inString && ch === separator) {
+            parts.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    parts.push(current);
+    return parts;
+}
+function unwrapVbaStringLiteral(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('"'))
+        return trimmed;
+    let text = '';
+    for (let i = 1; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        const next = trimmed[i + 1];
+        if (ch === '"' && next === '"') {
+            text += '"';
+            i++;
+            continue;
+        }
+        if (ch === '"')
+            break;
+        text += ch;
+    }
+    return text;
+}
 /**
  * Hueco 3 helper: parse an Access event-handler Sub name into its
  * `<ControlName>_<EventName>` components. Returns null when the name does