@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/real-vba-analyzer-HXLTTHKM.js

@@ -0,0 +1,466 @@
+import {
+  ASTEngine
+} from "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/real-vba-analyzer.ts
+var { SymbolKind, RelationshipType } = ASTEngine;
+var DECLARATIONS = /* @__PURE__ */ new Map([
+  ["sub_declaration", SymbolKind.Method],
+  ["conditional_sub_declaration", SymbolKind.Method],
+  ["function_declaration", SymbolKind.Function],
+  ["conditional_function_declaration", SymbolKind.Function],
+  ["property_get_declaration", SymbolKind.Property],
+  ["property_let_declaration", SymbolKind.Property],
+  ["property_set_declaration", SymbolKind.Property],
+  ["conditional_property_declaration", SymbolKind.Property],
+  ["type_declaration", SymbolKind.Type],
+  ["enum_declaration", SymbolKind.Enum],
+  ["enum_member", SymbolKind.EnumMember],
+  ["type_member", SymbolKind.Variable],
+  ["event_declaration", SymbolKind.Event],
+  // There is no `declare_statement` in this grammar: the name is absent from all 418
+  // node-type ids, and the live declare productions are the Function and Sub forms
+  // below. The dead literal was removed after the pinned inventory was measured — a
+  // node type the grammar does not have makes a branch that can never match, and the
+  // grammar-conformance audit cannot see it because the name exists nowhere at all.
+  ["declare_function_statement", SymbolKind.Function],
+  ["declare_sub_statement", SymbolKind.Method],
+  ["const_declaration", SymbolKind.Constant],
+  ["variable_declaration", SymbolKind.Variable]
+]);
+var BODY_NODES = /* @__PURE__ */ new Set([
+  "sub_declaration",
+  "function_declaration",
+  "property_get_declaration",
+  "property_let_declaration",
+  "property_set_declaration",
+  "declare_function_statement",
+  "declare_sub_statement",
+  "conditional_sub_declaration",
+  "conditional_function_declaration",
+  "conditional_property_declaration"
+]);
+var TYPE_NODES = /* @__PURE__ */ new Set(["type_declaration", "enum_declaration"]);
+var RealVbaAnalyzer = class {
+  symbols = [];
+  relationships = [];
+  imports = [];
+  declarations = /* @__PURE__ */ new Map();
+  owner = [];
+  callableNames = /* @__PURE__ */ new Set();
+  variableNames = /* @__PURE__ */ new Set();
+  emitted = /* @__PURE__ */ new Set();
+  nodeSymbols = /* @__PURE__ */ new Map();
+  source = "";
+  analyze(rootNode, content, _filePath, _context) {
+    this.reset(content);
+    const declarations = [];
+    this.collectDeclarations(rootNode, declarations);
+    for (const declaration of declarations) this.publishDeclaration(declaration);
+    this.walk(rootNode);
+    this.dedupe();
+    this.stampEvidence();
+    return {
+      symbols: this.symbols,
+      relationships: this.relationships,
+      imports: this.imports,
+      metadata: {
+        analysisVersion: "m1-vba-1",
+        hasTypeInference: false,
+        hasFrameworkIntelligence: false,
+        vbaGaps: {
+          extends: "VBA has no class inheritance syntax",
+          overrides: "VBA has no override modifier",
+          renders: "VBA grammar has no component-rendering construct",
+          mixes_in: "VBA grammar has no mixin construct",
+          part_of: "VBA grammar has no partial declaration construct"
+        },
+        linesOfCode: this.lineCount(content)
+      }
+    };
+  }
+  reset(content) {
+    this.symbols = [];
+    this.relationships = [];
+    this.imports = [];
+    this.declarations.clear();
+    this.owner = [];
+    this.callableNames.clear();
+    this.variableNames.clear();
+    this.emitted.clear();
+    this.nodeSymbols.clear();
+    this.source = content;
+  }
+  collectDeclarations(node, out) {
+    const kind = DECLARATIONS.get(node.type);
+    if (kind) {
+      const name = node.childForFieldName("name") ?? this.firstIdentifier(node);
+      if (name) out.push({ node, name, kind });
+    }
+    for (const child of this.children(node)) this.collectDeclarations(child, out);
+  }
+  publishDeclaration(declaration) {
+    const name = declaration.name.text.trim();
+    if (!name) return;
+    const symbol = {
+      name,
+      qualifiedName: name,
+      kind: declaration.kind,
+      range: this.range(declaration.node),
+      visibility: this.visibility(declaration.node),
+      isStatic: this.hasText(declaration.node, "static"),
+      parameters: this.parameters(declaration.node),
+      returnType: this.typeName(declaration.node),
+      metadata: {
+        grammarNode: declaration.node.type,
+        language: "vba",
+        ...this.hasNodeType(declaration.node, "with_events_modifier") ? { withEvents: true } : {}
+      }
+    };
+    this.symbols.push(symbol);
+    this.nodeSymbols.set(declaration.node.startIndex, symbol);
+    const key = this.fold(name);
+    if (!this.declarations.has(key)) this.declarations.set(key, symbol);
+    if (BODY_NODES.has(declaration.node.type)) this.callableNames.add(key);
+    if (declaration.kind === SymbolKind.Variable || declaration.kind === SymbolKind.Constant) {
+      this.variableNames.add(key);
+    }
+  }
+  walk(node, current) {
+    const declaration = this.symbolForNode(node);
+    const ownsChildren = declaration !== void 0 && (BODY_NODES.has(node.type) || TYPE_NODES.has(node.type));
+    const active = ownsChildren ? declaration : current;
+    if (declaration && current && declaration !== current) {
+      const nameNode = node.childForFieldName("name") ?? this.firstIdentifier(node) ?? node;
+      this.emit(RelationshipType.Contains, current.name, declaration.name, nameNode, 1);
+      const ownerName = current.qualifiedName ?? current.name;
+      const symbol = this.nodeSymbols.get(node.startIndex);
+      if (symbol) {
+        symbol.ownerName = ownerName;
+        symbol.ownerKind = current.kind;
+        symbol.qualifiedName = `${ownerName}.${symbol.name}`;
+      }
+    }
+    if (declaration && declaration.visibility === "public" && !current) {
+      this.emit(RelationshipType.Exports, "root", declaration.name, node, 1);
+    }
+    if (ownsChildren) this.owner.push(declaration);
+    if (node.type === "attribute_statement") this.emitAttribute(node, active);
+    else if (node.type === "call_statement" || node.type === "call_expression") {
+      this.emitCall(node, active);
+    } else if (node.type === "raise_event_statement") {
+      this.emitEventRaise(node, active);
+    } else if (node.type === "new_expression") {
+      this.emitInstantiation(node, active);
+    } else if (node.type === "with_statement") {
+      this.emitWithReceiver(node, active);
+    } else if (node.type === "on_error_statement") {
+      this.emitControlFlowRead(node.childForFieldName("target"), active, "on_error");
+    } else if (node.type === "redim_statement") {
+      this.emitControlFlowRead(node.childForFieldName("name") ?? this.firstIdentifier(node), active, "redim");
+    } else if (node.type === "for_statement" || node.type === "for_each_statement") {
+      this.emitLoopFields(node, active);
+    } else if (node.type === "select_statement") {
+      this.emitControlFlowRead(node.childForFieldName("value"), active, "select_value");
+    } else if (node.type === "case_clause") {
+      this.emitControlFlowRead(this.firstIdentifier(node), active, "case_value");
+    } else if (node.type === "qualified_member_expression") {
+      this.emitMemberReceiver(node, active);
+    } else if (node.type === "implements_statement") {
+      this.emitNamed(RelationshipType.Implements, active, node.childForFieldName("name") ?? this.firstIdentifier(node), 0.9);
+    } else if (node.type === "declare_function_statement" || node.type === "declare_sub_statement") {
+      this.emitDeclareImport(node);
+    } else if (node.type === "assignment_statement" || node.type === "set_statement") {
+      this.emitReads(node.childForFieldName("right"), active);
+    } else if (node.type === "as_type_clause" || node.type === "type_expression") {
+      if (node.parent?.type === "implements_statement") {
+        for (const child of this.children(node)) this.walk(child, active);
+        return;
+      }
+      const type = this.firstIdentifier(node);
+      if (type) this.emitNamed(RelationshipType.References, active, type, 0.6);
+    } else if (node.type === "identifier") {
+      this.emitIdentifierRead(node, active);
+    }
+    for (const child of this.children(node)) this.walk(child, active);
+    if (ownsChildren) this.owner.pop();
+  }
+  emitAttribute(node, source) {
+    const target = node.childForFieldName("name") ?? this.firstIdentifier(node);
+    if (!target) return;
+    this.emit(RelationshipType.Decorates, source?.name ?? "root", target.text, target, 0.8, {
+      attributeName: target.text,
+      attributeForm: "attribute_statement"
+    });
+  }
+  /**
+   * `Declare Function ... Lib "<library>"` / `Declare Sub ... Lib "<library>"` is how VBA
+   * binds a procedure that lives outside the project (a system DLL or a COM export). The
+   * fleet's `imports` names a unit's dependency on an external unit, so the row is
+   * root -> LIBRARY rather than root -> procedure: the procedure is declared HERE — it is
+   * a symbol of this module — while the LIBRARY is the external unit this module depends
+   * on. The target is the library text with its string delimiters removed, because a
+   * quoted target is not symbol-shaped; the written spelling rides in metadata, together
+   * with the exported alias and PtrSafe when present. Confidence is 1: the dependency is
+   * written in a live node and needs no resolution to be a fact about this file.
+   */
+  emitDeclareImport(node) {
+    const library = node.childForFieldName("library");
+    const target = library ? this.unquote(library.text) : "";
+    if (!library || !target) return;
+    const name = node.childForFieldName("name") ?? this.firstIdentifier(node);
+    const alias = node.childForFieldName("alias");
+    this.emit(RelationshipType.Imports, "root", target, library, 1, {
+      importForm: "declare-lib",
+      libraryName: target,
+      declaration: node.type,
+      ...name ? { procedure: name.text } : {},
+      ...alias ? { alias: this.unquote(alias.text) } : {},
+      ...this.children(node).some((child) => child.type === "ptrsafe_modifier") ? { ptrSafe: true } : {}
+    });
+  }
+  /**
+   * The grammar carries the library and alias as string literals; a dependency target is
+   * a NAME, so the delimiters are removed. Done without a regex deliberately: this
+   * analyzer stays regex-free, and a two-character trim needs none.
+   */
+  unquote(text) {
+    let value = text.trim();
+    if (value.startsWith('"')) value = value.slice(1);
+    if (value.endsWith('"')) value = value.slice(0, -1);
+    return value.trim();
+  }
+  emitCall(node, source) {
+    const callee = node.childForFieldName("callee") ?? node.childForFieldName("function");
+    const target = callee ? this.lastIdentifier(callee) : this.firstIdentifier(node);
+    if (!target || this.fold(target.text) === "new") return;
+    const receiver = callee?.childForFieldName("receiver");
+    const withReceiver = this.withReceiverFor(node);
+    this.emit(RelationshipType.Calls, source?.name ?? "root", target.text, target, this.confidence(target.text), {
+      qualified: callee?.text,
+      ...receiver ? { receiver: receiver.text } : {},
+      ...callee?.type === "implicit_member_expression" ? { implicitMember: true } : {},
+      ...withReceiver ? { withReceiver: withReceiver.text } : {}
+    });
+  }
+  emitWithReceiver(node, source) {
+    const receiver = node.childForFieldName("value");
+    if (!receiver) return;
+    this.emit(RelationshipType.Uses, source?.name ?? "root", receiver.text, receiver, this.confidence(receiver.text), {
+      construct: "with_receiver"
+    });
+  }
+  emitControlFlowRead(node, source, construct) {
+    if (!node) return;
+    const target = node.type === "identifier" ? node : this.firstIdentifier(node);
+    if (!target) return;
+    this.emit(RelationshipType.Uses, source?.name ?? "root", target.text, target, this.confidence(target.text), { construct });
+  }
+  emitLoopFields(node, source) {
+    const variable = node.childForFieldName("variable");
+    const collection = node.childForFieldName("collection");
+    const start = node.childForFieldName("start");
+    const end = node.childForFieldName("end");
+    if (variable) this.emitControlFlowRead(variable, source, node.type === "for_each_statement" ? "foreach_binder" : "for_binder");
+    if (collection) this.emitControlFlowRead(collection, source, "foreach_collection");
+    if (start) this.emitControlFlowRead(start, source, "for_start");
+    if (end) this.emitControlFlowRead(end, source, "for_end");
+  }
+  emitMemberReceiver(node, source) {
+    if (!source || this.hasCallAncestor(node)) return;
+    const receiver = node.childForFieldName("receiver");
+    if (!receiver || receiver.type !== "identifier") return;
+    this.emit(RelationshipType.Uses, source.name, receiver.text, receiver, this.confidence(receiver.text), {
+      construct: "member_receiver",
+      member: node.childForFieldName("member")?.text
+    });
+  }
+  withReceiverFor(node) {
+    let parent = node.parent;
+    while (parent) {
+      if (parent.type === "with_statement") {
+        return parent.childForFieldName("value");
+      }
+      if (BODY_NODES.has(parent.type)) return null;
+      parent = parent.parent;
+    }
+    return null;
+  }
+  emitInstantiation(node, source) {
+    const target = node.childForFieldName("type") ?? this.firstIdentifier(node);
+    if (!target) return;
+    this.emit(RelationshipType.Instantiates, source?.name ?? "root", target.text, target, this.confidence(target.text));
+  }
+  emitEventRaise(node, source) {
+    const event = node.childForFieldName("event") ?? this.firstIdentifier(node);
+    if (!event) return;
+    this.emit(RelationshipType.Calls, source?.name ?? "root", event.text, event, this.confidence(event.text), {
+      eventRaise: true
+    });
+  }
+  emitReads(node, source) {
+    if (!node) return;
+    for (const child of this.children(node)) {
+      if (child.type === "qualified_member_expression") {
+        this.emitMemberReceiver(child, source);
+        this.emitReads(child, source);
+      } else if (child.type === "identifier") {
+        this.emit(RelationshipType.Uses, source?.name ?? "root", child.text, child, this.confidence(child.text));
+      } else {
+        this.emitReads(child, source);
+      }
+    }
+  }
+  emitIdentifierRead(node, source) {
+    const parent = node.parent;
+    if (!parent || !source) return;
+    if (parent.childForFieldName("name")?.id === node.id) return;
+    if (parent.type === "type_expression" || parent.type === "as_type_clause") return;
+    if (this.hasCallAncestor(node)) return;
+    if (parent.type === "new_expression") return;
+    if (parent.type === "variable_declarator" || parent.type === "const_declarator") return;
+    if (parent.type === "parameter") return;
+    const left = parent.childForFieldName("left");
+    if (left?.id === node.id) return;
+    if (parent.type === "qualified_member_expression" && parent.childForFieldName("member")?.id !== node.id) return;
+    this.emit(RelationshipType.Uses, source.name, node.text, node, this.confidence(node.text));
+  }
+  emitNamed(type, source, target, confidence) {
+    if (target) this.emit(type, source?.name ?? "root", target.text, target, confidence);
+  }
+  emit(type, source, target, node, confidence, metadata = {}) {
+    const key = `${source}\0${type}\0${target}\0${node.startPosition.row + 1}`;
+    if (this.emitted.has(key)) return;
+    this.emitted.add(key);
+    this.relationships.push({
+      source,
+      target,
+      type,
+      confidence,
+      line_number: node.startPosition.row + 1,
+      metadata
+    });
+  }
+  confidence(target) {
+    return this.declarations.has(this.fold(target)) ? 1 : 0.6;
+  }
+  symbolForNode(node) {
+    return this.nodeSymbols.get(node.startIndex);
+  }
+  hasCallAncestor(node) {
+    let parent = node.parent;
+    while (parent) {
+      if (parent.type === "call_statement" || parent.type === "call_expression") {
+        const callee = parent.childForFieldName("callee") ?? parent.childForFieldName("function");
+        return !!callee && callee.startIndex <= node.startIndex && callee.endIndex >= node.endIndex;
+      }
+      if (parent.type === "block" || BODY_NODES.has(parent.type)) return false;
+      parent = parent.parent;
+    }
+    return false;
+  }
+  firstIdentifier(node) {
+    for (const child of this.children(node)) {
+      if (child.type === "identifier") return child;
+      const nested = this.firstIdentifier(child);
+      if (nested) return nested;
+    }
+    return null;
+  }
+  lastIdentifier(node) {
+    if (node.type === "identifier") return node;
+    const children = this.children(node);
+    for (let i = children.length - 1; i >= 0; i--) {
+      const child = children[i];
+      if (child.type === "identifier") return child;
+      const nested = this.lastIdentifier(child);
+      if (nested) return nested;
+    }
+    return null;
+  }
+  typeName(node) {
+    const type = node.childForFieldName("type");
+    return this.typeText(type);
+  }
+  typeText(node) {
+    if (!node) return void 0;
+    if (node.type === "as_type_clause") {
+      return this.typeText(node.childForFieldName("type"));
+    }
+    const text = node.text.trim();
+    return text.length > 0 ? text : void 0;
+  }
+  parameters(node) {
+    const list = node.childForFieldName("parameters");
+    if (!list) return void 0;
+    return this.children(list).filter((p) => p.type === "parameter").map((p) => ({
+      name: (p.childForFieldName("name") ?? this.firstIdentifier(p))?.text ?? "",
+      type: this.typeText(p.childForFieldName("type")),
+      isOptional: this.children(p).some((c) => c.type === "optional_modifier"),
+      passingMode: this.children(p).find((c) => c.type === "byref_modifier" || c.type === "byval_modifier")?.type.replace("_modifier", ""),
+      isParamArray: this.children(p).some((c) => c.type === "paramarray_modifier"),
+      defaultValue: p.childForFieldName("default_value")?.childForFieldName("value")?.text
+    })).filter((p) => p.name.length > 0);
+  }
+  visibility(node) {
+    const value = node.childForFieldName("visibility")?.text.toLowerCase();
+    return value === "public" || value === "private" || value === "friend" ? value : "private";
+  }
+  hasText(node, text) {
+    return this.children(node).some((child) => child.text.toLowerCase() === text);
+  }
+  hasNodeType(node, type) {
+    if (node.type === type) return true;
+    return this.children(node).some((child) => this.hasNodeType(child, type));
+  }
+  fold(value) {
+    return value.toLowerCase();
+  }
+  lineCount(value) {
+    let lines = 1;
+    for (let index = 0; index < value.length; index += 1) {
+      if (value[index] === "\n") lines += 1;
+    }
+    return lines;
+  }
+  children(node) {
+    return node.namedChildren.filter((child) => child !== null);
+  }
+  range(node) {
+    return {
+      startLine: node.startPosition.row + 1,
+      startColumn: node.startPosition.column,
+      endLine: node.endPosition.row + 1,
+      endColumn: node.endPosition.column,
+      startIndex: node.startIndex,
+      endIndex: node.endIndex
+    };
+  }
+  dedupe() {
+    const seen = /* @__PURE__ */ new Set();
+    this.relationships = this.relationships.filter((relationship) => {
+      const key = `${relationship.source}\0${relationship.type}\0${relationship.target}\0${relationship.line_number}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+  stampEvidence() {
+    for (const relationship of this.relationships) {
+      const confidence = relationship.confidence ?? 1;
+      relationship.metadata = {
+        evidenceClass: confidence < 0.7 ? "inferred" : relationship.type === RelationshipType.Imports ? "import_based" : relationship.type === RelationshipType.References || relationship.type === RelationshipType.Uses ? "usage_contextual" : "structural",
+        ...relationship.metadata
+      };
+    }
+  }
+};
+export {
+  RealVbaAnalyzer
+};