@suss/adapter-ruby 0.3.2-0 → 0.4.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/ast.ts
+import { IdMap, IdSet } from "@suss/extractor";
 function rangeOf(node) {
   return {
     start: node.startPosition.row + 1,
@@ -83,6 +84,8 @@ function readCallArgs(argumentList) {
   }
   return { positional, keyword };
 }
+var NodeMap = class extends IdMap {
+};
 
 // src/constantPath.ts
 import fs from "fs";
@@ -367,6 +370,351 @@ function inheritedStatements(ancestry) {
 import { dispatchByType, graphqlResolverBinding } from "@suss/behavioral-ir";
 import { unreadableReading } from "@suss/extractor";
 
+// src/paths/effects.ts
+import { enumerateOrDegrade, sharedGatingConditions } from "@suss/extractor";
+
+// src/paths/lowering.ts
+var RAISE_NAMES = /* @__PURE__ */ new Set(["raise", "fail"]);
+var CAPTURES_RETURN = /* @__PURE__ */ new Set([
+  "method",
+  "singleton_method",
+  "lambda",
+  "class",
+  "module",
+  "singleton_class"
+]);
+var KEYWORD_EXITS = {
+  return: "return",
+  break: "break",
+  next: "continue",
+  redo: "continue"
+};
+function isRaise(node) {
+  if (node.type !== "call") {
+    return false;
+  }
+  const receiver = field(node, "receiver");
+  const method = field(node, "method") ?? node.namedChildren[0] ?? null;
+  return receiver === null && method !== null && RAISE_NAMES.has(method.text);
+}
+function exitOf(node) {
+  if (isRaise(node)) {
+    return "throw";
+  }
+  return KEYWORD_EXITS[node.type] ?? null;
+}
+function exitKindOf(node) {
+  let sawReturn = false;
+  const raises = (current) => {
+    for (const child of current.namedChildren) {
+      if (child === null || CAPTURES_RETURN.has(child.type)) {
+        continue;
+      }
+      if (isRaise(child)) {
+        return true;
+      }
+      if (child.type === "return") {
+        sawReturn = true;
+      }
+      if (raises(child)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  if (isRaise(node) || raises(node)) {
+    return "throw";
+  }
+  return node.type === "return" || sawReturn ? "return" : null;
+}
+function handleOf(node) {
+  return node === null ? { sourceText: "", expression: null } : { sourceText: node.text, expression: node };
+}
+function blockStatements(block) {
+  if (block === null) {
+    return [];
+  }
+  return block.namedChildren.filter((child) => child !== null);
+}
+var Lowerer = class {
+  constructor(terminals) {
+    this.terminals = terminals;
+  }
+  terminals;
+  terminalsByStmt = /* @__PURE__ */ new Map();
+  terminalHome = new NodeMap();
+  attach(statement, candidates) {
+    const found = candidates.flatMap((node) => {
+      const match = node === null ? void 0 : this.terminals.get(node.id);
+      return match === void 0 ? [] : [match];
+    });
+    if (found.length > 0) {
+      this.terminalsByStmt.set(statement, found);
+      for (const node of found) {
+        this.terminalHome.set(node, statement);
+      }
+    }
+    return statement;
+  }
+  lowerBlock(block) {
+    return blockStatements(block).map((statement) => this.lower(statement));
+  }
+  /** An elsif chain reads as an if nested in the previous else arm. */
+  lowerAlternative(node) {
+    if (node === null) {
+      return null;
+    }
+    if (node.type !== "elsif") {
+      return this.lowerBlock(node);
+    }
+    const nested = {
+      kind: "if",
+      condition: handleOf(field(node, "condition")),
+      thenBody: this.lowerBlock(field(node, "consequence")),
+      elseBody: this.lowerAlternative(field(node, "alternative")),
+      exitKind: exitKindOf(node)
+    };
+    this.attach(nested, [field(node, "condition")]);
+    return [nested];
+  }
+  lowerIf(node) {
+    return {
+      kind: "if",
+      condition: handleOf(field(node, "condition")),
+      thenBody: this.lowerBlock(field(node, "consequence")),
+      elseBody: this.lowerAlternative(field(node, "alternative")),
+      exitKind: exitKindOf(node)
+    };
+  }
+  lowerBegin(node) {
+    const rescues = node.namedChildren.filter(
+      (child) => child !== null && child.type === "rescue"
+    );
+    const ensureClause = node.namedChildren.find(
+      (child) => child !== null && child.type === "ensure"
+    ) ?? null;
+    const tryBody = node.namedChildren.filter(
+      (child) => child !== null && child.type !== "rescue" && child.type !== "ensure" && child.type !== "else"
+    );
+    return {
+      kind: "try",
+      tryBody: tryBody.map((statement) => this.lower(statement)),
+      catchBody: rescues.length > 0 ? rescues.flatMap((clause) => this.lowerBlock(field(clause, "body"))) : null,
+      finallyBody: ensureClause === null ? null : this.lowerBlock(ensureClause),
+      exitKind: exitKindOf(node)
+    };
+  }
+  lowerCase(node) {
+    const groups = [];
+    for (const child of node.namedChildren) {
+      if (child === null) {
+        continue;
+      }
+      if (child.type === "when") {
+        groups.push({
+          condition: handleOf(field(child, "pattern")),
+          hasTrailingBreak: false,
+          body: this.lowerBlock(field(child, "body"))
+        });
+      }
+      if (child.type === "else") {
+        groups.push({
+          condition: null,
+          hasTrailingBreak: false,
+          body: this.lowerBlock(child)
+        });
+      }
+    }
+    return { kind: "switch", groups, exitKind: exitKindOf(node) };
+  }
+  lower(node) {
+    const exit = exitOf(node);
+    if (exit !== null) {
+      return this.attach({ kind: "exit", exit, exitKind: exitKindOf(node) }, [
+        node
+      ]);
+    }
+    if (node.type === "if" || node.type === "unless") {
+      return this.attach(this.lowerIf(node), [field(node, "condition")]);
+    }
+    if (node.type === "while" || node.type === "until" || node.type === "for") {
+      const header = field(node, "condition") ?? field(node, "value");
+      return this.attach(
+        {
+          kind: "loop",
+          condition: handleOf(header),
+          body: this.lowerBlock(field(node, "body")),
+          exitKind: exitKindOf(node)
+        },
+        [header]
+      );
+    }
+    const attachedBlock = node.namedChildren.find(
+      (child) => child !== null && (child.type === "do_block" || child.type === "block")
+    );
+    if (node.type === "call" && attachedBlock !== void 0) {
+      return this.attach(
+        {
+          kind: "loop",
+          condition: handleOf(node),
+          body: this.lowerBlock(field(attachedBlock, "body") ?? attachedBlock),
+          exitKind: exitKindOf(node)
+        },
+        [node]
+      );
+    }
+    if (node.type === "begin" || node.type === "rescue_modifier") {
+      return this.attach(this.lowerBegin(node), []);
+    }
+    if (node.type === "case" || node.type === "case_match") {
+      return this.attach(this.lowerCase(node), [field(node, "value")]);
+    }
+    return this.attach({ kind: "opaque", exitKind: exitKindOf(node) }, [node]);
+  }
+};
+function lowerRubyBody(body, terminals) {
+  const lowerer = new Lowerer(
+    new Map(terminals.map((terminal) => [terminal.id, terminal]))
+  );
+  return {
+    statements: lowerer.lowerBlock(body),
+    terminalsByStmt: lowerer.terminalsByStmt,
+    terminalHome: lowerer.terminalHome
+  };
+}
+
+// src/paths/effects.ts
+var DECLARATION_TYPES = /* @__PURE__ */ new Set([
+  "method",
+  "singleton_method",
+  "lambda",
+  "class",
+  "module",
+  "singleton_class"
+]);
+var RAISE_NAMES2 = /* @__PURE__ */ new Set(["raise", "fail"]);
+var BLOCK_TYPES = /* @__PURE__ */ new Set([
+  "body_statement",
+  "then",
+  "else",
+  "do_block",
+  "block"
+]);
+var LITERAL_ARGS = {
+  string: (node) => ({
+    kind: "string",
+    value: node.text.replace(/^["']|["']$/g, "")
+  }),
+  integer: (node) => {
+    const value = Number.parseInt(node.text, 10);
+    return Number.isNaN(value) ? null : { kind: "number", value };
+  },
+  float: (node) => {
+    const value = Number.parseFloat(node.text);
+    return Number.isNaN(value) ? null : { kind: "number", value };
+  },
+  true: () => ({ kind: "boolean", value: true }),
+  false: () => ({ kind: "boolean", value: false }),
+  simple_symbol: (node) => ({ kind: "string", value: node.text.slice(1) })
+};
+function children(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function isPropertyRead(node) {
+  return field(node, "receiver") !== null && field(node, "arguments") === null;
+}
+function isRaise2(node) {
+  const method = field(node, "method") ?? children(node)[0] ?? null;
+  return field(node, "receiver") === null && method !== null && RAISE_NAMES2.has(method.text);
+}
+function bodyCalls(node, found = []) {
+  for (const child of children(node)) {
+    if (DECLARATION_TYPES.has(child.type)) {
+      continue;
+    }
+    if (child.type === "call" && !isPropertyRead(child) && !isRaise2(child)) {
+      found.push(child);
+    }
+    bodyCalls(child, found);
+  }
+  return found;
+}
+function calleeText(call) {
+  const receiver = field(call, "receiver");
+  const method = field(call, "method") ?? children(call)[0];
+  if (method === void 0) {
+    return call.text;
+  }
+  return receiver === null ? method.text : `${receiver.text}.${method.text}`;
+}
+function argOf(node) {
+  const literal = LITERAL_ARGS[node.type]?.(node);
+  if (literal !== null && literal !== void 0) {
+    return literal;
+  }
+  if (node.type === "call" && !isPropertyRead(node)) {
+    return { kind: "call", callee: calleeText(node), args: argsOf(node) };
+  }
+  return { kind: "identifier", name: node.text };
+}
+function argsOf(call) {
+  const args = field(call, "arguments");
+  if (args === null) {
+    return [];
+  }
+  return children(args).map(
+    (child) => child.type === "pair" ? argOf(field(child, "value") ?? child) : argOf(child)
+  );
+}
+function enclosingStatement(call, body) {
+  let current = call;
+  while (current.parent !== null) {
+    if (BLOCK_TYPES.has(current.parent.type) || current.parent.id === body.id) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return current;
+}
+function invocationEffects(definitionNode) {
+  const body = field(definitionNode, "body");
+  if (body === null) {
+    return [];
+  }
+  const calls = bodyCalls(body);
+  if (calls.length === 0) {
+    return [];
+  }
+  const statementOf = /* @__PURE__ */ new Map();
+  const statements = [];
+  for (const call of calls) {
+    const statement = enclosingStatement(call, body);
+    statementOf.set(call.id, statement);
+    statements.push(statement);
+  }
+  const lowered = lowerRubyBody(body, statements);
+  const enumerated = enumerateOrDegrade(
+    {
+      statements: lowered.statements,
+      terminalsByStmt: lowered.terminalsByStmt
+    },
+    statements
+  );
+  return calls.map((call) => {
+    const statement = statementOf.get(call.id);
+    const conditions = sharedGatingConditions(
+      statement === void 0 ? void 0 : enumerated.byTerminal.get(statement)
+    );
+    return {
+      type: "invocation",
+      callee: calleeText(call),
+      args: argsOf(call),
+      async: false,
+      ...conditions.length > 0 ? { preconditions: conditions } : {}
+    };
+  });
+}
+
 // src/typeShape.ts
 function scalarLookupName(qualifiedName, prefixes) {
   for (const prefix of prefixes) {
@@ -500,10 +848,37 @@ async function graphqlObjectFieldUnits(pattern, pack, info, ownBlocks, options)
     (decl) => buildFieldUnit(pack, typeName, decl, options.filePath)
   );
 }
+function branchesFor(body, range) {
+  if (body.effects === void 0) {
+    return [];
+  }
+  return [
+    {
+      conditions: [],
+      terminal: {
+        kind: "void",
+        statusCode: null,
+        body: null,
+        exceptionType: null,
+        message: null,
+        component: null,
+        renderTree: null,
+        delegateTarget: null,
+        emitEvent: null,
+        location: range
+      },
+      effects: body.effects,
+      location: range,
+      isDefault: true
+    }
+  ];
+}
 function bodyOfMethod(method) {
+  const effects = invocationEffects(method);
   return {
     bodyContent: methodHasStatements(method) ? "statements" : "empty",
-    readings: []
+    readings: [],
+    ...effects.length > 0 ? { effects } : {}
   };
 }
 var NO_METHOD_BEHIND_IT = {
@@ -740,7 +1115,7 @@ function buildFieldUnit(pack, typeName, decl, filePath) {
       fieldName: decl.fieldName
     }),
     parameters,
-    branches: [],
+    branches: branchesFor(decl.body, rangeOf(decl.node)),
     ...decl.body.bodyContent !== void 0 ? { bodyContent: decl.body.bodyContent } : {},
     dependencyCalls: [],
     declaredContract: null,
@@ -801,9 +1176,444 @@ import fs3 from "fs";
 import path3 from "path";
 import { Database } from "@suss/datalog";
 import { assembleSummary } from "@suss/extractor";
+
+// src/facts/values.ts
+function nodeId(filePath, node) {
+  return `${filePath}:${node.startIndex}-${node.endIndex}`;
+}
+function nameId(filePath, name) {
+  return `${filePath}#${name}`;
+}
+var DECLARATION_TYPES2 = /* @__PURE__ */ new Set([
+  "method",
+  "singleton_method",
+  "lambda",
+  "class",
+  "module",
+  "singleton_class"
+]);
+var WRITTEN_VALUE_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "integer",
+  "float",
+  "true",
+  "false",
+  "nil",
+  "simple_symbol",
+  "hash_key_symbol"
+]);
+function children2(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function add(emitter, relation, ...tuple) {
+  emitter.db.add(relation, tuple);
+}
+function valueKey(emitter, value) {
+  if (value.type !== "identifier" && value.type !== "constant") {
+    return nodeId(emitter.filePath, value);
+  }
+  const enclosing = emitter.enclosing;
+  if (enclosing !== null && enclosing.params.has(value.text)) {
+    return `${enclosing.funcKey}#${value.text}`;
+  }
+  return nameId(emitter.filePath, value.text);
+}
+function pairKeyText(key) {
+  if (key.type === "hash_key_symbol") {
+    return key.text;
+  }
+  if (key.type === "simple_symbol") {
+    return key.text.slice(1);
+  }
+  if (key.type === "string") {
+    return key.text.slice(1, -1);
+  }
+  return null;
+}
+function isPropertyRead2(node) {
+  return node.type === "call" && field(node, "receiver") !== null && field(node, "arguments") === null && children2(node).every(
+    (child) => child.type !== "do_block" && child.type !== "block"
+  );
+}
+function emitPropertyRead(emitter, node) {
+  const receiver = field(node, "receiver");
+  const method = field(node, "method");
+  if (receiver === null || method === null) {
+    return;
+  }
+  add(
+    emitter,
+    "readsProperty",
+    nodeId(emitter.filePath, node),
+    valueKey(emitter, receiver),
+    method.text
+  );
+}
+function emitCall(emitter, call) {
+  add(emitter, "writtenValue", nodeId(emitter.filePath, call));
+  const method = field(call, "method");
+  if (method === null) {
+    return;
+  }
+  const receiver = field(call, "receiver");
+  const callKey = nodeId(emitter.filePath, call);
+  const calleeKey = receiver === null ? valueKey(emitter, method) : nodeId(emitter.filePath, method);
+  add(emitter, "call", callKey, calleeKey);
+  if (receiver !== null) {
+    add(
+      emitter,
+      "readsProperty",
+      calleeKey,
+      valueKey(emitter, receiver),
+      method.text
+    );
+  }
+  const args = field(call, "arguments");
+  let position = 0;
+  for (const argument of args === null ? [] : children2(args)) {
+    if (argument.type === "pair") {
+      const key = field(argument, "key");
+      const value = field(argument, "value");
+      const keyText = key === null ? null : pairKeyText(key);
+      if (keyText !== null && value !== null) {
+        add(
+          emitter,
+          "callKeywordArg",
+          callKey,
+          keyText,
+          valueKey(emitter, value)
+        );
+      }
+      continue;
+    }
+    add(
+      emitter,
+      "callArg",
+      callKey,
+      String(position),
+      valueKey(emitter, argument)
+    );
+    position += 1;
+  }
+}
+function emitArray(emitter, array) {
+  const objectKey = nodeId(emitter.filePath, array);
+  add(emitter, "objectValue", objectKey);
+  let position = 0;
+  for (const element of children2(array)) {
+    add(
+      emitter,
+      "holdsProperty",
+      objectKey,
+      String(position),
+      valueKey(emitter, element)
+    );
+    position += 1;
+  }
+}
+function emitHash(emitter, hash) {
+  const objectKey = nodeId(emitter.filePath, hash);
+  add(emitter, "objectValue", objectKey);
+  for (const pair of children2(hash)) {
+    if (pair.type !== "pair") {
+      continue;
+    }
+    const key = field(pair, "key");
+    const value = field(pair, "value");
+    const keyText = key === null ? null : pairKeyText(key);
+    if (keyText === null || value === null) {
+      continue;
+    }
+    add(emitter, "holdsProperty", objectKey, keyText, valueKey(emitter, value));
+  }
+}
+function walkExpressions(node, visit) {
+  for (const child of children2(node)) {
+    if (DECLARATION_TYPES2.has(child.type)) {
+      continue;
+    }
+    visit(child);
+    walkExpressions(child, visit);
+  }
+}
+function emitExpressionFacts(emitter, node) {
+  walkExpressions(node, (child) => {
+    if (isPropertyRead2(child)) {
+      emitPropertyRead(emitter, child);
+    } else if (child.type === "call") {
+      emitCall(emitter, child);
+    }
+    if (child.type === "array") {
+      emitArray(emitter, child);
+    }
+    if (child.type === "hash") {
+      emitHash(emitter, child);
+    }
+    if (WRITTEN_VALUE_TYPES.has(child.type)) {
+      add(emitter, "writtenValue", nodeId(emitter.filePath, child));
+    }
+  });
+}
+function implicitReturn(body) {
+  const statements = children2(body).filter(
+    (child) => child.type !== "rescue" && child.type !== "ensure"
+  );
+  const last = statements[statements.length - 1];
+  return last === void 0 || last.type === "return" ? null : last;
+}
+function emitMethodFacts(emitter, method) {
+  const funcKey = nodeId(emitter.filePath, method);
+  add(emitter, "func", funcKey);
+  const params = field(method, "parameters");
+  const declared = /* @__PURE__ */ new Set();
+  let position = 0;
+  for (const param of params === null ? [] : children2(params)) {
+    const paramName = param.type === "identifier" ? param : field(param, "name") ?? null;
+    if (paramName !== null) {
+      declared.add(paramName.text);
+      const paramKey = `${funcKey}#${paramName.text}`;
+      add(emitter, "paramOf", funcKey, String(position), paramKey);
+      add(emitter, "paramNamed", funcKey, paramName.text, paramKey);
+    }
+    position += 1;
+  }
+  const inside = {
+    ...emitter,
+    enclosing: { funcKey, params: declared }
+  };
+  const body = field(method, "body");
+  if (body === null) {
+    return funcKey;
+  }
+  const recordNested = (node) => {
+    for (const child of children2(node)) {
+      if (DECLARATION_TYPES2.has(child.type)) {
+        add(emitter, "containsFn", funcKey, nodeId(emitter.filePath, child));
+        continue;
+      }
+      recordNested(child);
+    }
+  };
+  recordNested(body);
+  walkExpressions(body, (child) => {
+    if (child.type === "return") {
+      const first = children2(child)[0];
+      const returned = first?.type === "argument_list" ? children2(first)[0] : first;
+      if (returned !== void 0) {
+        add(inside, "returnsValue", funcKey, valueKey(inside, returned));
+      }
+    }
+    if (child.type === "call") {
+      add(inside, "bodyCalls", funcKey, nodeId(inside.filePath, child));
+    }
+  });
+  const implicit = implicitReturn(body);
+  if (implicit !== null) {
+    add(inside, "returnsValue", funcKey, valueKey(inside, implicit));
+  }
+  emitExpressionFacts(inside, body);
+  return funcKey;
+}
+function emitAssignment(emitter, assignment) {
+  const left = field(assignment, "left");
+  const right = field(assignment, "right");
+  if (right === null) {
+    return;
+  }
+  if (left?.type !== "identifier" && left?.type !== "constant") {
+    return;
+  }
+  add(
+    emitter,
+    "binds",
+    nameId(emitter.filePath, left.text),
+    valueKey(emitter, right)
+  );
+  add(
+    emitter,
+    "exportsAs",
+    emitter.filePath,
+    left.text,
+    valueKey(emitter, right)
+  );
+}
+var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
+function emitClassFacts(emitter, cls) {
+  const classKey = nodeId(emitter.filePath, cls);
+  add(emitter, "objectValue", classKey);
+  const body = field(cls, "body");
+  for (const statement of body === null ? [] : children2(body)) {
+    if (statement.type === "assignment") {
+      const left = field(statement, "left");
+      const right = field(statement, "right");
+      if (left !== null && right !== null && left.type === "constant") {
+        add(
+          emitter,
+          "holdsProperty",
+          classKey,
+          left.text,
+          valueKey(emitter, right)
+        );
+      }
+      continue;
+    }
+    if (!METHOD_TYPES.has(statement.type)) {
+      continue;
+    }
+    const funcKey = emitMethodFacts(emitter, statement);
+    const name = field(statement, "name");
+    if (name !== null) {
+      add(emitter, "holdsProperty", classKey, name.text, funcKey);
+    }
+  }
+  return classKey;
+}
+function emitValueFacts(db, filePath, root) {
+  const emitter = { db, filePath, enclosing: null };
+  const declaresName = (child, key) => {
+    const name = field(child, "name");
+    if (name === null) {
+      return;
+    }
+    add(emitter, "binds", nameId(filePath, name.text), key);
+    add(emitter, "exportsAs", filePath, name.text, key);
+  };
+  const walk = (node) => {
+    for (const child of children2(node)) {
+      if (child.type === "class") {
+        declaresName(child, emitClassFacts(emitter, child));
+        continue;
+      }
+      if (METHOD_TYPES.has(child.type)) {
+        declaresName(child, emitMethodFacts(emitter, child));
+      }
+      if (child.type === "assignment") {
+        emitAssignment(emitter, child);
+      }
+      walk(child);
+    }
+  };
+  walk(root);
+  emitExpressionFacts(emitter, root);
+}
+
+// src/facts/constants.ts
+var NESTING_TYPES = /* @__PURE__ */ new Set(["class", "module"]);
+function children3(node) {
+  return node.namedChildren.filter((child) => child !== null);
+}
+function writtenName(node) {
+  if (node.type === "constant") {
+    return node.text;
+  }
+  if (node.type !== "scope_resolution") {
+    return null;
+  }
+  const scope = field(node, "scope");
+  const name = field(node, "name");
+  if (name === null) {
+    return null;
+  }
+  const prefix = scope === null ? "" : writtenName(scope);
+  return prefix === null ? null : `${prefix}::${name.text}`;
+}
+function qualify(nesting, name) {
+  return [...nesting, name].join("::");
+}
+function isDeclaration(node, parent) {
+  if (parent === null) {
+    return false;
+  }
+  if (NESTING_TYPES.has(parent.type)) {
+    return field(parent, "name") === node;
+  }
+  if (parent.type === "assignment") {
+    return field(parent, "left") === node;
+  }
+  return parent.type === "scope_resolution";
+}
+function collectFileConstants(filePath, root) {
+  const definitions = [];
+  const references = [];
+  const walk = (node, parent, nesting) => {
+    if (NESTING_TYPES.has(node.type)) {
+      const name = field(node, "name");
+      const written = name === null ? null : writtenName(name);
+      if (written !== null) {
+        definitions.push({
+          qualifiedName: qualify(nesting, written),
+          key: nodeId(filePath, node)
+        });
+        const inside = [...nesting, ...written.split("::")];
+        for (const child of children3(node)) {
+          walk(child, node, inside);
+        }
+        return;
+      }
+    }
+    if (node.type === "assignment") {
+      const left = field(node, "left");
+      const right = field(node, "right");
+      if (left !== null && left.type === "constant" && right !== null) {
+        definitions.push({
+          qualifiedName: qualify(nesting, left.text),
+          key: nodeId(filePath, right)
+        });
+      }
+    }
+    if ((node.type === "constant" || node.type === "scope_resolution") && !isDeclaration(node, parent)) {
+      const written = writtenName(node);
+      if (written !== null) {
+        references.push({
+          key: node.type === "constant" ? `${filePath}#${node.text}` : nodeId(filePath, node),
+          written,
+          nesting
+        });
+      }
+    }
+    for (const child of children3(node)) {
+      walk(child, node, nesting);
+    }
+  };
+  walk(root, null, []);
+  return { definitions, references };
+}
+function emitConstantBindings(db, perFile) {
+  const byName = /* @__PURE__ */ new Map();
+  const files = [...perFile];
+  for (const file of files) {
+    for (const definition of file.definitions) {
+      const found = byName.get(definition.qualifiedName) ?? [];
+      found.push(definition.key);
+      byName.set(definition.qualifiedName, found);
+    }
+  }
+  const settles = (candidate) => {
+    const found = byName.get(candidate);
+    return found !== void 0 && found.length === 1 ? found[0] ?? null : null;
+  };
+  for (const file of files) {
+    for (const reference of file.references) {
+      for (let depth = reference.nesting.length; depth >= 0; depth--) {
+        const candidate = qualify(
+          reference.nesting.slice(0, depth),
+          reference.written
+        );
+        const key = settles(candidate);
+        if (key !== null) {
+          db.add("binds", [reference.key, key]);
+          break;
+        }
+      }
+    }
+  }
+}
+
+// src/project.ts
 async function extractRubyProject(options) {
   const db = new Database();
   const summaries = [];
+  const constants = [];
   const cache = createFileCache(
     (source) => parseRuby(source).then((tree) => tree.rootNode),
     (absPath) => fs3.existsSync(absPath) ? fs3.readFileSync(absPath, "utf8") : null
@@ -825,7 +1635,10 @@ async function extractRubyProject(options) {
       summaries.push(summary);
       emitEntryFact(db, file, raw.identity.range, raw.identity.name);
     }
+    emitValueFacts(db, file, root);
+    constants.push(collectFileConstants(file, root));
   }
+  emitConstantBindings(db, constants);
   return { summaries, facts: db };
 }
 var SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set(["vendor", "node_modules", "tmp", ".git"]);