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

package/lib/dist/extraction/vba/error-channel.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_CHANNEL_ENTRY_RE = exports.DEFAULT_ERROR_CHANNEL_NAMES = void 0;
+exports.compileErrorChannel = compileErrorChannel;
+exports.defaultErrorChannel = defaultErrorChannel;
+exports.isErrorChannelName = isErrorChannelName;
+/**
+ * The error channel — the module-level variable this kind of Access codebase
+ * actually propagates error messages through (issue #261, task E4 of
+ * `docs/vba-error-handling-plan.md`).
+ *
+ * ## Why a whole module for four names
+ *
+ * §2.1/§2.3 of the plan measured it: **16 handlers out of 3,774 re-raise**.
+ * `Err.Raise 1000` unwinds exactly one frame and the guard
+ * `If Err.Number <> 1000` in the handler means *"an inner procedure already
+ * wrote a human-readable message — do not overwrite it"*. The MESSAGE never
+ * travels through VBA's error mechanism; it travels through a field:
+ *
+ * ```vba
+ * errores:                              ' inner procedure
+ *     If Err.Number <> 1000 Then
+ *         m_Error = "Riesgo.Guardar ha devuelto el error: " & Err.Description
+ *     End If
+ *     Me.Error = m_Error
+ * ```
+ * ```vba
+ * p_Error = m_ObjRiesgoActivo.Error      ' the form, later
+ * If p_Error <> "" Then MsgBox p_Error
+ * ```
+ *
+ * That is module-variable data flow, which issue #251 already models as
+ * `property-set` / `property-get` references onto a `variable` node. This
+ * module supplies the one thing #251 cannot know: **which** of those variables
+ * is the error channel. Nothing here emits a node, an edge or a reference — it
+ * only decides whether an existing row earns `metadata.errorChannel: true`.
+ *
+ * ## Why it is a LEAF, separate from `errors.ts`
+ *
+ * Two consumers need the same list and must never fork:
+ *
+ *   - `errors.ts` derives `errorPolicy.behavior` from a channel-WRITE matcher
+ *     (is this statement `<channel> = …`?), and
+ *   - `module-vars.ts` flags a read or a write by NAME (is this variable the
+ *     channel?).
+ *
+ * `errors.ts` owned both the names and the write matcher before this task and
+ * its own comment deferred the config knob here. Keeping the names in
+ * `errors.ts` and importing them from `module-vars.ts` would have closed a
+ * cycle the moment `errors.ts` needed the compiled, config-aware form back. So
+ * the names and both matchers live here, in a module that imports only
+ * `text-utils`, and `errors.ts` re-exports the constant for its existing
+ * consumers.
+ *
+ * ## Names, never substrings, never user regex
+ *
+ * A channel entry is a bare VBA identifier and is matched as a WHOLE name, so
+ * `ErrorCount` cannot match `Error`. `codegraph.json` → `vba.errorChannel`
+ * therefore takes identifiers, not patterns: this runs on every identifier of
+ * every line of every VBA file, which is precisely where a user-supplied regex
+ * is a catastrophic-backtracking hazard (the same reasoning `vba.sqlWrappers`
+ * was built on in #244).
+ */
+const text_utils_1 = require("./text-utils");
+/**
+ * The channel names used when `codegraph.json` → `vba.errorChannel` is absent.
+ *
+ * `m_Error` / `p_Error` are the private module-variable spellings, `g_Error`
+ * the global one, and `Error` the public field a caller reads off the object
+ * (`m_ObjRiesgoActivo.Error`). Identical to the probe's
+ * `DEFAULT_ERROR_CHANNEL_NAMES` — `scripts/vba-coverage-probe.mjs` measured
+ * the census this task is accepted against, so the two lists must agree.
+ */
+exports.DEFAULT_ERROR_CHANNEL_NAMES = [
+    'm_Error',
+    'p_Error',
+    'g_Error',
+    'Error',
+];
+/** A channel entry is a bare VBA identifier — nothing qualified, no regex. */
+exports.ERROR_CHANNEL_ENTRY_RE = /^\p{L}[\p{L}\p{N}_]*$/u;
+/**
+ * Compile the channel from the plain-string config entries.
+ *
+ * `configured` entries are APPENDED to {@link DEFAULT_ERROR_CHANNEL_NAMES},
+ * never substituted for them — same contract as `vba.sqlWrappers`: a project
+ * that names its own `lastFailure` field must not lose `m_Error` in the trade,
+ * because in a codebase this size the two conventions coexist. Blank, dotted
+ * and otherwise non-identifier entries are dropped here; `project-config.ts`
+ * has already warned about them at load time.
+ */
+function compileErrorChannel(configured) {
+    const names = [];
+    const lookup = new Set();
+    for (const raw of [...exports.DEFAULT_ERROR_CHANNEL_NAMES, ...(configured ?? [])]) {
+        const entry = (raw ?? '').trim();
+        if (!entry || !exports.ERROR_CHANNEL_ENTRY_RE.test(entry))
+            continue;
+        const key = entry.toLowerCase();
+        if (lookup.has(key))
+            continue;
+        lookup.add(key);
+        names.push(entry);
+    }
+    const writeRes = names.map((name) => new RegExp(`^\\s*(?:Set\\s+)?(?:(?:Me|\\p{L}[\\p{L}\\p{N}_]*)\\s*\\.\\s*)?${(0, text_utils_1.escapeRegExpLiteral)(name)}\\s*=(?!=)`, 'iu'));
+    return { names, lookup, writeRes };
+}
+/**
+ * The zero-config channel, compiled once.
+ *
+ * The fallback for every context that was never handed options — tests and
+ * out-of-repo callers of `VbaExtractor`. Memoised because the write regexes
+ * are the hot path's and there is exactly one correct instance of them.
+ */
+let defaultChannel = null;
+function defaultErrorChannel() {
+    if (!defaultChannel)
+        defaultChannel = compileErrorChannel();
+    return defaultChannel;
+}
+/**
+ * Is `name` the error channel? A WHOLE-name, case-insensitive test — the
+ * single reason `ErrorCount` does not match `Error`, pinned by a test.
+ */
+function isErrorChannelName(channel, name) {
+    return channel.lookup.has(name.toLowerCase());
+}
+//# sourceMappingURL=error-channel.js.map

package/lib/dist/extraction/vba/error-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-channel.js","sourceRoot":"","sources":["../../../src/extraction/vba/error-channel.ts"],"names":[],"mappings":";;;AAoHA,kDAqBC;AAUD,kDAGC;AAMD,gDAKC;AAjKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,6CAAmD;AAEnD;;;;;;;;GAQG;AACU,QAAA,2BAA2B,GAAsB;IAC5D,SAAS;IACT,SAAS;IACT,SAAS;IACT,OAAO;CACR,CAAC;AAEF,8EAA8E;AACjE,QAAA,sBAAsB,GAAG,wBAAwB,CAAC;AA8B/D;;;;;;;;;GASG;AACH,SAAgB,mBAAmB,CACjC,UAA8B;IAE9B,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,MAAM,GAAG,IAAI,GAAG,EAAU,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,mCAA2B,EAAE,GAAG,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC;QAC1E,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,CAAC,KAAK,IAAI,CAAC,8BAAsB,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,SAAS;QAC5D,MAAM,GAAG,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QAChC,IAAI,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC;YAAE,SAAS;QAC9B,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAChB,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CACxB,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,MAAM,CACR,iEAAiE,IAAA,gCAAmB,EAAC,IAAI,CAAC,YAAY,EACtG,IAAI,CACL,CACJ,CAAC;IACF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC;AACrC,CAAC;AAED;;;;;;GAMG;AACH,IAAI,cAAc,GAAgC,IAAI,CAAC;AACvD,SAAgB,mBAAmB;IACjC,IAAI,CAAC,cAAc;QAAE,cAAc,GAAG,mBAAmB,EAAE,CAAC;IAC5D,OAAO,cAAc,CAAC;AACxB,CAAC;AAED;;;GAGG;AACH,SAAgB,kBAAkB,CAChC,OAA6B,EAC7B,IAAY;IAEZ,OAAO,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;AAChD,CAAC"}

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

@@ -0,0 +1,64 @@
+import { VbaClassifier, VbaExtractorContext, VbaErrorPolicyState } from './context';
+import { VbaExtractionRule } from './rules';
+/**
+ * The error-propagation channel this corpus actually uses: a module-level or
+ * object field the failing procedure writes and the caller reads. §2.3 of the
+ * plan measures 3,602 handlers touching it against 16 that re-raise — VBA's
+ * own error mechanism unwinds one frame, the MESSAGE travels through one of
+ * these variables.
+ *
+ * Names only, never substrings, so `ErrorCount` cannot match `Error`.
+ *
+ * Issue #261 (task E4) moved this list — and the write matcher built from it —
+ * into `./error-channel`, so the two consumers can no longer fork: this
+ * classifier asks "is this statement a channel WRITE?", `module-vars.ts` asks
+ * "is this variable the channel?", and both now read one compiled object that
+ * `codegraph.json` → `vba.errorChannel` extends. Re-exported from here because
+ * this module was its home and the probe-agreement suite imports it.
+ */
+export { DEFAULT_ERROR_CHANNEL_NAMES } from './error-channel';
+/**
+ * Calls that make an error visible to a human. `MsgBox` is the form-code
+ * shape, `Debug.Print` the developer-only one; §2.3 counts both as "display",
+ * so this list — identical to the probe's `DEFAULT_DISPLAY_CALLS` — does too.
+ */
+export declare const DEFAULT_DISPLAY_CALLS: readonly string[];
+/** A fresh accumulator for a procedure body opening at `startLine`. */
+export declare function newErrorPolicyState(startLine: number, edgeMark: number, refMark: number): VbaErrorPolicyState;
+/**
+ * Issue #259: the declarative rule table for the error-policy concern. All
+ * four rules are `scan: 'masked'` and `requires: 'inside-procedure'`.
+ *
+ * `masked` is the #209 discipline: `s = "On Error GoTo errores"` is a string
+ * assignment, and a classifier that reads it as a handler would report a
+ * protected procedure that is not protected. `inside-procedure` is what keeps
+ * module-level noise out — there is no error policy without a procedure to
+ * attach it to.
+ *
+ * The three `On Error` rules re-scan their own line globally instead of
+ * acting on the dispatcher's single match, so a colon-separated single-line
+ * procedure carrying two `On Error GoTo` statements counts two.
+ */
+export declare const RULES: readonly VbaExtractionRule<unknown>[];
+/**
+ * Fold the open accumulator into the procedure's `metadata.errorPolicy` and
+ * clear it. `endLine` is the procedure's terminating `End` line — the handler
+ * region's closing boundary.
+ *
+ * Called from three places: the `End Sub` boundary (the normal path), a new
+ * procedure declaration while a body is somehow still open (malformed VBA
+ * with no `End`), and end-of-file. All three converge on the same shape, so a
+ * truncated module still records a policy instead of silently dropping it.
+ */
+export declare function closeErrorPolicy(ctx: VbaExtractorContext, endLine: number): void;
+/**
+ * Issue #259: factory for the error-policy classifier.
+ *
+ * `count` stays at 0 for the life of the classifier, deliberately. The
+ * orchestrator derives `hasAnySymbols` from the sum of every classifier's
+ * `count`, and this one emits no symbols at all — it only annotates nodes the
+ * procedures sweep already created. Letting it count would make a file whose
+ * only content is an `On Error` line look like a file with symbols.
+ */
+export declare function createErrorPolicyClassifier(): VbaClassifier;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/extraction/vba/errors.ts"],"names":[],"mappings":"AA4EA,OAAO,EACL,aAAa,EACb,mBAAmB,EAGnB,mBAAmB,EACpB,MAAM,WAAW,CAAC;AAEnB,OAAO,EAAwB,iBAAiB,EAAE,MAAM,SAAS,CAAC;AA2ElE;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,2BAA2B,EAAE,MAAM,iBAAiB,CAAC;AAE9D;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,MAAM,EAA8B,CAAC;AAuKlF,uEAAuE;AACvE,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,GACd,mBAAmB,CAmBrB;AA6BD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,EAAE,SAAS,iBAAiB,CAAC,OAAO,CAAC,EAgKtD,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,mBAAmB,EACxB,OAAO,EAAE,MAAM,GACd,IAAI,CAgEN;AAkGD;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,IAAI,aAAa,CAuF3D"}