@suss/adapter-ruby 0.26.0 → 0.28.0

package/dist/index.js

@@ -15,6 +15,45 @@ function field(node, name) {
 function bodyStatements(body) {
   return body.namedChildren.filter((child) => child !== null);
 }
+var BRANCH_FIELDS = {
+  if: ["consequence", "alternative"],
+  unless: ["consequence", "alternative"],
+  elsif: ["consequence", "alternative"],
+  if_modifier: ["body"],
+  unless_modifier: ["body"],
+  while: ["body"],
+  until: ["body"],
+  while_modifier: ["body"],
+  until_modifier: ["body"],
+  when: ["body"],
+  rescue: ["body"]
+};
+var STATEMENT_LISTS = /* @__PURE__ */ new Set(["then", "else", "do", "ensure", "begin"]);
+var CLAUSE_TYPES = /* @__PURE__ */ new Set(["elsif", "else", "when", "rescue", "ensure"]);
+function nestedStatements(stmt) {
+  const branchFields = BRANCH_FIELDS[stmt.type];
+  if (branchFields !== void 0) {
+    return branchFields.flatMap((name) => {
+      const branch = field(stmt, name);
+      return branch === null ? [] : statementsRunBy(branch);
+    });
+  }
+  if (STATEMENT_LISTS.has(stmt.type)) {
+    return bodyStatements(stmt).flatMap(
+      (child) => CLAUSE_TYPES.has(child.type) ? nestedStatements(child) : [child]
+    );
+  }
+  if (stmt.type === "case") {
+    return bodyStatements(stmt).filter((child) => CLAUSE_TYPES.has(child.type)).flatMap(nestedStatements);
+  }
+  return [];
+}
+function statementsRunBy(branch) {
+  if (STATEMENT_LISTS.has(branch.type) || CLAUSE_TYPES.has(branch.type)) {
+    return nestedStatements(branch);
+  }
+  return [branch];
+}
 var OWN_BODY_TYPES = /* @__PURE__ */ new Set([
   "method",
   "singleton_method",
@@ -78,8 +117,8 @@ var VISIBILITY_KEYWORDS = /* @__PURE__ */ new Set([
   "protected",
   "public"
 ]);
-function visibilityKeyword(text) {
-  return VISIBILITY_KEYWORDS.has(text) ? text : null;
+function visibilityKeyword(text2) {
+  return VISIBILITY_KEYWORDS.has(text2) ? text2 : null;
 }
 function setVisibility(visibility, name, keyword) {
   if (keyword === "public") {
@@ -202,14 +241,31 @@ var NodeMap = class extends IdMap {
 // src/constantPath.ts
 import fs from "fs";
 import path from "path";
-function underscoreConstantPath(qualifiedName) {
-  return qualifiedName.replaceAll("::", "/").replace(/([A-Z\d]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+function underscoreConstantPath(qualifiedName, acronyms = []) {
+  return lowerAcronyms(qualifiedName.replaceAll("::", "/"), acronyms).replace(/([A-Z\d]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase();
+}
+function lowerAcronyms(word, acronyms) {
+  if (acronyms.length === 0) {
+    return word;
+  }
+  const alternatives = acronyms.map(escapeRegExp).join("|");
+  const acronymRegex = new RegExp(
+    `(?:(?<=([A-Za-z\\d]))|\\b)(${alternatives})(?=\\b|[^a-z])`,
+    "g"
+  );
+  return word.replace(
+    acronymRegex,
+    (_match, before, acronym) => `${before === void 0 ? "" : "_"}${acronym.toLowerCase()}`
+  );
+}
+function escapeRegExp(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var PATH_CONVENTIONS = {
   railsUnderscore: underscoreConstantPath
 };
-function resolveConstantFile(root, qualifiedName, convention) {
-  const relative = `${PATH_CONVENTIONS[convention](qualifiedName)}.rb`;
+function resolveConstantFile(root, qualifiedName, convention, acronyms = []) {
+  const relative = `${PATH_CONVENTIONS[convention](qualifiedName, acronyms)}.rb`;
   for (const candidate of [root, ...autoloadDirectories(root)]) {
     const file = path.join(candidate, relative);
     if (fs.existsSync(file)) {
@@ -283,12 +339,19 @@ function walkBody(statements, nesting, visit) {
   }
 }
 function ownIdentity(nameNode, outerNesting) {
-  const qualifiedName = qualifyConstantRef(nameNode, outerNesting);
+  const qualifiedName = definedName(nameNode, outerNesting);
   if (qualifiedName === null) {
     return null;
   }
   return { qualifiedName, bodyNesting: [qualifiedName, ...outerNesting] };
 }
+function definedName(nameNode, outerNesting) {
+  const innermost = outerNesting[0] ?? null;
+  if (nameNode.type === "scope_resolution" && innermost !== null && !nameNode.text.startsWith("::")) {
+    return `${innermost}::${nameNode.text}`;
+  }
+  return qualifyConstantRef(nameNode, outerNesting);
+}
 function visitClass(node, nesting, visit) {
   const nameNode = field(node, "name");
   const identity = nameNode !== null ? ownIdentity(nameNode, nesting) : null;
@@ -352,7 +415,8 @@ async function reachDefinition(qualifiedName, lookup) {
   const filePath = resolveConstantFile(
     lookup.root,
     qualifiedName,
-    lookup.pathConvention
+    lookup.pathConvention,
+    lookup.acronyms
   );
   if (filePath === null) {
     return null;
@@ -394,7 +458,10 @@ async function chainOf(self, lookup, active) {
 async function superclassChain(self, lookup, active) {
   const candidates = superclassCandidatesOf(self.blocks);
   for (const candidate of candidates) {
-    if (lookup.ancestryRootClassNames.includes(candidate) || active.has(candidate)) {
+    if (lookup.ancestryRootClassNames.includes(candidate)) {
+      return [{ type: "root", name: candidate }];
+    }
+    if (active.has(candidate)) {
       return [];
     }
     const blocks = await definitionOf(candidate, lookup);
@@ -472,6 +539,9 @@ function superclassCandidatesOf(blocks) {
 }
 function methodInAncestry(ancestry, name) {
   for (const entry of ancestry) {
+    if (entry.type === "root") {
+      return { type: "none" };
+    }
     if (entry.type === "unfollowed") {
       return {
         type: "unsettled",
@@ -1207,21 +1277,13 @@ function calledMethod(node) {
 
 // src/values/evaluator.ts
 import { nodeOfKey } from "@suss/resolution";
-import { Evaluator, force, literalOf as literalOf2 } from "@suss/values";
+import { Evaluator, force, literalOf as literalOf2, text } from "@suss/values";
 
 // src/facts/resolve.ts
+import { constant, lit, rule, variable as v } from "@suss/datalog";
 import {
-  constant,
-  deriveOnDemand,
-  evaluate,
-  lit,
-  rule,
-  variable as v
-} from "@suss/datalog";
-import {
-  ANSWER_RELATIONS,
-  RESOLUTION_QUESTIONS,
-  RESOLUTION_RULES,
+  askResolution,
+  resolutionProgram,
   writtenValueOf as sharedWrittenValueOf,
   VALUE_STEP
 } from "@suss/resolution";
@@ -1239,18 +1301,9 @@ var RUBY_RULES = [
     ]
   )
 ];
-var RESOLUTION_PROGRAM = deriveOnDemand(
-  [...RESOLUTION_RULES, ...RUBY_RULES, ...RESOLUTION_QUESTIONS],
-  ANSWER_RELATIONS
-);
+var RUBY_PROGRAM = resolutionProgram(RUBY_RULES);
 function resolveValues(db, keys) {
-  if (keys.length === 0) {
-    return;
-  }
-  for (const key of keys) {
-    db.add("wanted", [key]);
-  }
-  evaluate(db, RESOLUTION_PROGRAM.rules);
+  askResolution(db, keys, "wanted", RUBY_PROGRAM);
 }
 function resolvedFunctions(db, key) {
   return db.facts("wantedResolves").filter((row) => String(row[0]) === key).map((row) => String(row[1]));
@@ -1261,27 +1314,262 @@ function writtenValueOf(db, key) {
 }
 
 // src/facts/values.ts
-function nodeId(filePath, node) {
-  return `${filePath}:${node.startIndex}-${node.endIndex}`;
-}
-function nameId(filePath, name) {
-  return `${filePath}#${name}`;
-}
+import { startsAtName, valueLeftByWrites } from "@suss/resolution";
+
+// src/facts/locals.ts
+import { writesRunInOrder } from "@suss/resolution";
+var BLOCK_TYPES2 = /* @__PURE__ */ new Set(["block", "do_block"]);
+var LATER_BODY_TYPES = /* @__PURE__ */ new Set([...OWN_BODY_TYPES, ...BLOCK_TYPES2]);
+var RUBY_NAME_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "instance_variable"
+]);
+var TARGET_LIST_TYPES = /* @__PURE__ */ new Set([
+  "left_assignment_list",
+  "destructured_left_assignment",
+  "rest_assignment"
+]);
+var WHOLE_VALUE_OPERATORS = /* @__PURE__ */ new Set([
+  "||=",
+  "&&="
+]);
 function paramNameOf(param) {
   return param.type === "identifier" ? param : field(param, "name") ?? null;
 }
-function declaredParamNames(method) {
-  const params = field(method, "parameters");
-  const declared = /* @__PURE__ */ new Set();
-  for (const param of params === null ? [] : children2(params)) {
+function parametersOf(owner) {
+  const params = field(owner, "parameters");
+  return params === null ? [] : bodyStatements(params);
+}
+function parameterNames2(owner) {
+  const names = /* @__PURE__ */ new Set();
+  for (const param of parametersOf(owner)) {
     const name = paramNameOf(param);
     if (name !== null) {
-      declared.add(name.text);
+      names.add(name.text);
     }
   }
-  return declared;
+  return names;
+}
+function targetsOf(left) {
+  if (left.type === "identifier" || left.type === "constant") {
+    return [left];
+  }
+  if (TARGET_LIST_TYPES.has(left.type)) {
+    return bodyStatements(left).flatMap(targetsOf);
+  }
+  return [];
+}
+function writeOf(target, value, at, fromParameter) {
+  return { name: target.text, target, value, at, fromParameter };
+}
+function readAssignment(node) {
+  const left = field(node, "left");
+  const right = field(node, "right");
+  if (left === null || right === null) {
+    return [];
+  }
+  const value = left.type === "left_assignment_list" ? null : right;
+  return targetsOf(left).map((target) => writeOf(target, value, node, false));
+}
+function readOperatorAssignment(node) {
+  const left = field(node, "left");
+  const right = field(node, "right");
+  const operator = field(node, "operator");
+  if (left === null || right === null || left.type !== "identifier") {
+    return [];
+  }
+  const whole = operator !== null && WHOLE_VALUE_OPERATORS.has(operator.text);
+  return [writeOf(left, whole ? right : null, node, false)];
+}
+function readForVariable(node) {
+  const pattern = field(node, "pattern");
+  if (pattern === null) {
+    return [];
+  }
+  return targetsOf(pattern).map((target) => writeOf(target, null, node, false));
+}
+function readBlockParameters(node) {
+  const found = [];
+  for (const param of parametersOf(node)) {
+    const name = paramNameOf(param);
+    if (name !== null) {
+      found.push(writeOf(name, null, param, true));
+    }
+  }
+  return found;
+}
+var WRITE_READERS = {
+  assignment: readAssignment,
+  operator_assignment: readOperatorAssignment,
+  for: readForVariable,
+  block: readBlockParameters,
+  do_block: readBlockParameters
+};
+function writesUnder(body) {
+  const found = [];
+  const visit = (node) => {
+    for (const child of bodyStatements(node)) {
+      if (OWN_BODY_TYPES.has(child.type)) {
+        continue;
+      }
+      found.push(...WRITE_READERS[child.type]?.(child) ?? []);
+      visit(child);
+    }
+  };
+  visit(body);
+  return found;
+}
+var namesByTree = /* @__PURE__ */ new WeakMap();
+function cacheFor(tree) {
+  const known = namesByTree.get(tree);
+  if (known !== void 0) {
+    return known;
+  }
+  const fresh = { file: null, byMethod: new NodeMap() };
+  namesByTree.set(tree, fresh);
+  return fresh;
+}
+function scopeNames(parameters, body) {
+  const locals = new Set(parameters);
+  const blockParams = /* @__PURE__ */ new Set();
+  for (const write of body === null ? [] : writesUnder(body)) {
+    if (write.fromParameter) {
+      blockParams.add(write.name);
+      continue;
+    }
+    locals.add(write.name);
+  }
+  return { locals, blockParams };
+}
+function namesOfMethod(method) {
+  const cache = cacheFor(method.tree);
+  const remembered = cache.byMethod.get(method);
+  if (remembered !== void 0) {
+    return remembered;
+  }
+  const names = scopeNames(parameterNames2(method), field(method, "body"));
+  cache.byMethod.set(method, names);
+  return names;
+}
+function namesOfFile(tree) {
+  const cache = cacheFor(tree);
+  cache.file ??= scopeNames(/* @__PURE__ */ new Set(), tree.rootNode);
+  return cache.file;
 }
-function readKey(filePath, node, enclosing) {
+function ownerOfName(node, name, enclosing) {
+  if (node.type === "constant") {
+    return null;
+  }
+  const names = enclosing === null ? namesOfFile(node.tree) : namesOfMethod(enclosing);
+  if (names.blockParams.has(name)) {
+    const block = blockDeclaring(node, name);
+    if (block !== null) {
+      return block;
+    }
+  }
+  return enclosing !== null && names.locals.has(name) ? enclosing : null;
+}
+function blockDeclaring(node, name) {
+  let current = node.parent;
+  while (current !== null) {
+    if (BLOCK_TYPES2.has(current.type) && parameterNames2(current).has(name)) {
+      return current;
+    }
+    if (OWN_BODY_TYPES.has(current.type)) {
+      return null;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function parameterWrites(method) {
+  const found = [];
+  for (const param of method === null ? [] : parametersOf(method)) {
+    const name = paramNameOf(param);
+    if (name !== null) {
+      found.push(writeOf(name, name, param, true));
+    }
+  }
+  return found;
+}
+function collectWrites(method, body) {
+  const writes = [...parameterWrites(method), ...writesUnder(body)].sort(
+    (left, right) => left.target.startIndex - right.target.startIndex
+  );
+  const targetIds = new Set(writes.map((write) => write.target.id));
+  const groups = /* @__PURE__ */ new Map();
+  for (const write of writes) {
+    const owner = ownerOfName(write.target, write.name, method);
+    const key = `${owner === null ? "" : owner.id} ${write.name}`;
+    const group = groups.get(key);
+    if (group === void 0) {
+      groups.set(key, {
+        owner,
+        name: write.name,
+        writes: [write],
+        ordered: false
+      });
+      continue;
+    }
+    group.writes.push(write);
+  }
+  const rules = nameReads(targetIds);
+  for (const group of groups.values()) {
+    const scope = group.owner === null ? body : field(group.owner, "body");
+    if (scope === null) {
+      continue;
+    }
+    group.ordered = writesRunInOrder(
+      scope,
+      group.name,
+      group.writes.map((write) => orderedWrite(write, scope)),
+      rules
+    );
+  }
+  return [...groups.values()];
+}
+function orderedWrite(write, scope) {
+  return {
+    at: write.at,
+    direct: !write.fromParameter && write.at.parent?.id === scope.id
+  };
+}
+function nameReads(targetIds) {
+  return {
+    nameTypes: RUBY_NAME_TYPES,
+    laterBodies: LATER_BODY_TYPES,
+    childrenOf: bodyStatements,
+    isRead: (node) => isNameRead(node, targetIds)
+  };
+}
+function isNameRead(node, targetIds) {
+  if (targetIds.has(node.id)) {
+    return false;
+  }
+  const parent = node.parent;
+  return !(parent !== null && parent.type === "call" && field(parent, "method")?.id === node.id && field(parent, "receiver") !== null);
+}
+
+// src/facts/values.ts
+function nodeId(filePath, node) {
+  return `${filePath}:${node.startIndex}-${node.endIndex}`;
+}
+function nameId(filePath, name) {
+  return `${filePath}#${name}`;
+}
+function readThrough(node) {
+  if (node.type !== "parenthesized_statements") {
+    return node;
+  }
+  const inner = node.namedChildren.filter((child) => child !== null);
+  return inner.length === 1 ? readThrough(inner[0]) : node;
+}
+function nameKey(filePath, node, enclosing) {
+  const owner = ownerOfName(node, node.text, enclosing);
+  return owner === null ? nameId(filePath, node.text) : `${nodeId(filePath, owner)}#${node.text}`;
+}
+function readKey(filePath, written, enclosing) {
+  const node = readThrough(written);
   if (node.type !== "identifier" && node.type !== "constant") {
     return nodeId(filePath, node);
   }
@@ -1289,10 +1577,7 @@ function readKey(filePath, node, enclosing) {
   if (parent !== null && parent.type === "call" && field(parent, "method")?.id === node.id && field(parent, "receiver") !== null) {
     return isPropertyRead2(parent) ? nodeId(filePath, parent) : nodeId(filePath, node);
   }
-  if (enclosing !== null && declaredParamNames(enclosing).has(node.text)) {
-    return `${nodeId(filePath, enclosing)}#${node.text}`;
-  }
-  return nameId(filePath, node.text);
+  return nameKey(filePath, node, enclosing);
 }
 var WRITTEN_VALUE_TYPES = /* @__PURE__ */ new Set([
   "string",
@@ -1321,15 +1606,12 @@ function children2(node) {
 function add(emitter, relation, ...tuple) {
   emitter.db.add(relation, tuple);
 }
-function valueKey(emitter, value) {
+function valueKey(emitter, written) {
+  const value = readThrough(written);
   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);
+  return nameKey(emitter.filePath, value, emitter.enclosing);
 }
 function pairKeyText(key) {
   if (key.type === "hash_key_symbol") {
@@ -1468,8 +1750,72 @@ function emitExpressionFacts(emitter, node) {
     if (child.type === "nil") {
       add(emitter, "placeholderValue", nodeId(emitter.filePath, child));
     }
+    if (child.type === "self" && emitter.selfKey !== null) {
+      add(emitter, "binds", nodeId(emitter.filePath, child), emitter.selfKey);
+    }
+    if (child.type === "instance_variable") {
+      emitInstanceRead(emitter, child);
+    }
+    if (ASSIGNMENT_TYPES.has(child.type)) {
+      collectInstanceWrite(emitter, child);
+    }
   });
 }
+var ASSIGNMENT_TYPES = /* @__PURE__ */ new Set(["assignment", "operator_assignment"]);
+function isWriteTarget(node) {
+  const parent = node.parent;
+  return parent !== null && ASSIGNMENT_TYPES.has(parent.type) && field(parent, "left")?.id === node.id;
+}
+function emitInstanceRead(emitter, node) {
+  if (emitter.selfKey === null || isWriteTarget(node)) {
+    return;
+  }
+  add(
+    emitter,
+    "readsProperty",
+    nodeId(emitter.filePath, node),
+    emitter.selfKey,
+    node.text
+  );
+}
+function collectInstanceWrite(emitter, node) {
+  const left = field(node, "left");
+  const right = field(node, "right");
+  const collector = emitter.instanceWrites;
+  if (left === null || right === null || collector === null) {
+    return;
+  }
+  if (left.type !== "instance_variable") {
+    return;
+  }
+  const operator = field(node, "operator")?.text;
+  const value = node.type === "assignment" || WHOLE_VALUE_OPERATORS.has(operator ?? "") ? right : null;
+  const written = collector.get(left.text) ?? [];
+  written.push(
+    describeWrite(emitter, {
+      name: left.text,
+      target: left,
+      value,
+      at: node,
+      fromParameter: false
+    })
+  );
+  collector.set(left.text, written);
+}
+function emitInstanceWrites(emitter, classKey, collected) {
+  for (const [name, writes] of collected) {
+    const settled = valueLeftByWrites(writes, false);
+    if (settled !== null) {
+      add(emitter, "holdsProperty", classKey, name, settled);
+      continue;
+    }
+    for (const write of writes) {
+      if (write.value !== null && !write.narrowsName) {
+        add(emitter, "holdsProperty", classKey, name, write.value);
+      }
+    }
+  }
+}
 function implicitReturn(body) {
   const statements = children2(body).filter(
     (child) => child.type !== "rescue" && child.type !== "ensure"
@@ -1480,23 +1826,17 @@ function implicitReturn(body) {
 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)) {
+  for (const param of parametersOf(method)) {
     const paramName = paramNameOf(param);
     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 inside = { ...emitter, enclosing: method };
   const body = field(method, "body");
   if (body === null) {
     return funcKey;
@@ -1528,31 +1868,78 @@ function emitMethodFacts(emitter, method) {
     add(inside, "returnsValue", funcKey, valueKey(inside, implicit));
   }
   emitExpressionFacts(inside, body);
+  emitScopeWrites(inside, method, body);
   return funcKey;
 }
-function emitAssignment(emitter, assignment2) {
-  const left = field(assignment2, "left");
-  const right = field(assignment2, "right");
-  if (right === null) {
-    return;
+function isConstruction(value) {
+  return value.type === "call" || ARRAY_TYPES.has(value.type) || value.type === "hash";
+}
+function sourceOf(node) {
+  return node.text.replace(/\s+/g, " ").trim();
+}
+function readFirst(node) {
+  const inner = readThrough(node);
+  if (inner !== node) {
+    return inner;
   }
-  if (left?.type !== "identifier" && left?.type !== "constant") {
-    return;
+  return node.type === "call" ? field(node, "receiver") : null;
+}
+var CHAIN_READS = {
+  nameTypes: RUBY_NAME_TYPES,
+  readFirst
+};
+function describeWrite(emitter, write) {
+  const value = write.value === null ? null : readThrough(write.value);
+  return {
+    value: value === null ? null : valueKey(emitter, value),
+    placeholder: value?.type === "nil",
+    construction: value !== null && isConstruction(value) ? sourceOf(value) : null,
+    narrowsName: value !== null && value.type === "call" && startsAtName(value, write.name, CHAIN_READS)
+  };
+}
+function settledValue(emitter, group) {
+  const only = group.writes.length === 1 ? group.writes[0] : void 0;
+  if (only !== void 0) {
+    return only.fromParameter || only.value === null ? null : valueKey(emitter, only.value);
   }
-  add(
-    emitter,
-    "binds",
-    nameId(emitter.filePath, left.text),
-    valueKey(emitter, right)
-  );
-  add(
-    emitter,
-    "exportsAs",
-    emitter.filePath,
-    left.text,
-    valueKey(emitter, right)
+  return valueLeftByWrites(
+    group.writes.map((write) => describeWrite(emitter, write)),
+    group.ordered
   );
 }
+function emitScopeWrites(emitter, method, body) {
+  for (const group of collectWrites(method, body)) {
+    const settled = settledValue(emitter, group);
+    const key = group.owner === null ? nameId(emitter.filePath, group.name) : `${nodeId(emitter.filePath, group.owner)}#${group.name}`;
+    if (settled === null) {
+      emitCandidates(emitter, key, group);
+      continue;
+    }
+    add(
+      emitter,
+      group.writes.length === 1 ? "binds" : "endsHolding",
+      key,
+      settled
+    );
+    if (group.owner === null) {
+      add(emitter, "exportsAs", emitter.filePath, group.name, settled);
+    }
+  }
+}
+function emitCandidates(emitter, key, group) {
+  for (const write of group.writes) {
+    if (write.value === null) {
+      add(emitter, "writesUnstated", key);
+      continue;
+    }
+    if (write.fromParameter) {
+      continue;
+    }
+    if (!describeWrite(emitter, write).narrowsName) {
+      add(emitter, "mayHold", key, valueKey(emitter, write.value));
+    }
+  }
+}
 var METHOD_TYPES = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 function emitClassFacts(emitter, cls) {
   const classKey = nodeId(emitter.filePath, cls);
@@ -1564,6 +1951,12 @@ function emitClassFacts(emitter, cls) {
     add(emitter, "extendsNamed", classKey, base.text);
   }
   const body = field(cls, "body");
+  const collected = /* @__PURE__ */ new Map();
+  const within = {
+    ...emitter,
+    selfKey: classKey,
+    instanceWrites: collected
+  };
   for (const statement of body === null ? [] : children2(body)) {
     if (statement.type === "assignment") {
       const left = field(statement, "left");
@@ -1587,16 +1980,23 @@ function emitClassFacts(emitter, cls) {
     if (!METHOD_TYPES.has(statement.type)) {
       continue;
     }
-    const funcKey = emitMethodFacts(emitter, statement);
+    const funcKey = emitMethodFacts(within, statement);
     const name = field(statement, "name");
     if (name !== null) {
       add(emitter, "holdsProperty", classKey, name.text, funcKey);
     }
   }
+  emitInstanceWrites(within, classKey, collected);
   return classKey;
 }
 function emitValueFacts(db, filePath, root) {
-  const emitter = { db, filePath, enclosing: null };
+  const emitter = {
+    db,
+    filePath,
+    enclosing: null,
+    selfKey: null,
+    instanceWrites: null
+  };
   const declaresName = (child, key) => {
     const name = field(child, "name");
     if (name === null) {
@@ -1614,14 +2014,12 @@ function emitValueFacts(db, filePath, root) {
       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);
+  emitScopeWrites(emitter, null, root);
 }
 
 // src/values/lowering.ts
@@ -1637,7 +2035,7 @@ var OWN_ROOT_TYPES = /* @__PURE__ */ new Set([
   "module",
   "singleton_class"
 ]);
-var BLOCK_TYPES2 = /* @__PURE__ */ new Set(["block", "do_block"]);
+var BLOCK_TYPES3 = /* @__PURE__ */ new Set(["block", "do_block"]);
 var METHOD_TYPES2 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 var NAME_TYPES = /* @__PURE__ */ new Set([
   "identifier",
@@ -2143,7 +2541,7 @@ function isTailExpression(node) {
   if (owner.type === "block" && owner.parent?.type === "lambda") {
     return true;
   }
-  if (METHOD_TYPES2.has(owner.type) || BLOCK_TYPES2.has(owner.type)) {
+  if (METHOD_TYPES2.has(owner.type) || BLOCK_TYPES3.has(owner.type)) {
     return true;
   }
   if (owner.type === "when") {
@@ -2162,7 +2560,7 @@ function isRoot(node) {
   if (OWN_ROOT_TYPES.has(node.type)) {
     return true;
   }
-  return BLOCK_TYPES2.has(node.type) && node.parent?.type === "call";
+  return BLOCK_TYPES3.has(node.type) && node.parent?.type === "call";
 }
 function isPathStatement(node, parent) {
   if (node.type === "elsif") {
@@ -2190,7 +2588,7 @@ function siteOf(node) {
     current = parent;
   }
 }
-function parametersOf(parameters) {
+function parametersOf2(parameters) {
   if (parameters === null) {
     return [];
   }
@@ -2212,19 +2610,19 @@ function functionOf(node) {
       return null;
     }
     return {
-      parameters: parametersOf(field(node, "parameters")),
+      parameters: parametersOf2(field(node, "parameters")),
       body: bodyOf(block)
     };
   }
-  if (BLOCK_TYPES2.has(node.type)) {
+  if (BLOCK_TYPES3.has(node.type)) {
     return {
-      parameters: parametersOf(field(node, "parameters")),
+      parameters: parametersOf2(field(node, "parameters")),
       body: bodyOf(node)
     };
   }
   if (METHOD_TYPES2.has(node.type)) {
     const body = field(node, "body");
-    const parameters = parametersOf(field(node, "parameters"));
+    const parameters = parametersOf2(field(node, "parameters"));
     if (body === null) {
       return { parameters, body: [] };
     }
@@ -2585,11 +2983,18 @@ function bindEvaluator(db, nodes) {
     )
   );
 }
-function evaluatedValue(node, db) {
-  return force(evaluatorFor(node, db).evaluate(node));
+function evaluatedValue(node, db, bindings) {
+  const evaluator = evaluatorFor(node, db);
+  if (bindings === void 0) {
+    return force(evaluator.evaluate(node));
+  }
+  const supplied = new Map(
+    [...bindings].map(([name, value]) => [name, text(value)])
+  );
+  return force(evaluator.evaluate(node, { bindings: supplied }));
 }
-function stringValueOf(node, db) {
-  return literalOf2(evaluatedValue(node, db));
+function stringValueOf(node, db, bindings) {
+  return literalOf2(evaluatedValue(node, db, bindings));
 }
 function methodDefinitionsIn(file, root) {
   const found = /* @__PURE__ */ new Map();
@@ -3250,8 +3655,7 @@ function controllerFilters(pattern, ancestry) {
       skipNames.set(form.skippedBy, form.name);
     }
   }
-  const declared = [];
-  const skips = [];
+  let declared = [];
   for (const { statement } of inheritedStatements(ancestry)) {
     const called = calledName(statement);
     if (called === null) {
@@ -3259,16 +3663,21 @@ function controllerFilters(pattern, ancestry) {
     }
     const form = byName.get(called);
     if (form !== void 0) {
-      declared.push(...declarationsOf(statement, form));
+      for (const declaration of declarationsOf(statement, form)) {
+        declared = [
+          ...declared.filter((earlier) => !sameFilter(earlier, declaration)),
+          declaration
+        ];
+      }
       continue;
     }
     const skipped = skipNames.get(called);
     if (skipped !== void 0) {
-      skips.push(...skipsOf(statement, skipped));
+      declared = applySkips(declared, skipsOf(statement, skipped));
     }
   }
   const resolved = [];
-  for (const declaration of applySkips(declared, skips)) {
+  for (const declaration of declared) {
     const found = methodInAncestry(ancestry, declaration.methodName);
     if (found.type !== "found") {
       continue;
@@ -3381,6 +3790,9 @@ function skipsOf(statement, filterName) {
   const actions = namesUnder(args.keyword.only);
   return args.positional.map((arg) => symbolValue(arg)).filter((name) => name !== null).map((methodName) => ({ filterName, methodName, actions }));
 }
+function sameFilter(one, other) {
+  return one.filter.name === other.filter.name && one.methodName === other.methodName;
+}
 function applySkips(declared, skips) {
   const left = [];
   for (const declaration of declared) {
@@ -3423,13 +3835,8 @@ function namesUnder(node) {
 }
 
 // src/storage.ts
-import { deriveOnDemand as deriveOnDemand2, evaluate as evaluate2 } from "@suss/datalog";
 import { storageBinding } from "@suss/ir-core";
-import {
-  ANSWER_RELATIONS as ANSWER_RELATIONS2,
-  RESOLUTION_QUESTIONS as RESOLUTION_QUESTIONS2,
-  RESOLUTION_RULES as RESOLUTION_RULES2
-} from "@suss/resolution";
+import { askResolution as askResolution2 } from "@suss/resolution";
 function children3(node) {
   return node.namedChildren.filter((child) => child !== null);
 }
@@ -3455,13 +3862,8 @@ function isConstant(node) {
 function constantName(constant2) {
   return constant2.type === "constant" ? constant2.text : compoundName(constant2);
 }
-var ANCESTRY_PROGRAM = deriveOnDemand2(
-  [...RESOLUTION_RULES2, ...RESOLUTION_QUESTIONS2],
-  ANSWER_RELATIONS2
-);
 function reachesBase(facts, classKey, bases) {
-  facts.add("wantedAncestry", [classKey]);
-  evaluate2(facts, ANCESTRY_PROGRAM.rules);
+  askResolution2(facts, [classKey], "wantedAncestry", RUBY_PROGRAM);
   return facts.lookup("wantedBaseName", 0, classKey).some((row) => bases.includes(String(row[1])));
 }
 function classBehind(facts, file, constant2) {
@@ -3508,7 +3910,7 @@ function storageEffect(call, model, pattern, kind, selector) {
     binding: storageBinding({
       recognition: "ruby-storage",
       storageSystem: pattern.storageSystem,
-      scope: pattern.baseClasses[0] ?? "",
+      scope: "default",
       container: constantName(model)
     }),
     callee: call.text,
@@ -3676,6 +4078,7 @@ function fieldReadContext(pattern, cache, fileBlocks, bodyRead) {
     lookup: {
       root: pattern.root,
       pathConvention: pattern.pathConvention,
+      acronyms: pattern.acronyms ?? [],
       ancestryRootClassNames: pattern.ancestryRootClassNames,
       parsedFile: (absPath) => cache.get(absPath),
       localDefinition: (name) => sameFileBlocks(name, fileBlocks)
@@ -3790,12 +4193,16 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
   const lookup = {
     root: pattern.root,
     pathConvention: pattern.pathConvention,
+    acronyms: pattern.acronyms ?? [],
     ancestryRootClassNames: pattern.ancestryRootClassNames,
     parsedFile: (absPath) => options.cache.get(absPath),
     localDefinition: (name) => sameFileBlocks(name, fileBlocks)
   };
   const ancestry = await ancestryOf(info.qualifiedName, ownBlocks, lookup);
-  if (!reachesConfiguredBase(ancestry, info.qualifiedName, pattern.baseClassNames)) {
+  if (!reachesConfiguredBase(ancestry, info.qualifiedName, [
+    ...pattern.baseClassNames,
+    ...pattern.ancestryRootClassNames
+  ])) {
     return [];
   }
   const filters = controllerFilters(pattern, ancestry);
@@ -3815,43 +4222,73 @@ async function controllerActionUnits(pattern, pack, info, ownBlocks, fileBlocks,
       enclosingQualifiedName: filter.enclosingQualifiedName
     });
   }
-  for (const block of ownBlocks) {
-    if (block.info.bodyNode === null) {
+  const emitAction = (actionName, method, block) => {
+    const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
+      (filter) => filterReference(
+        filter,
+        options.displayPathOf?.(filter.file) ?? filter.file
+      )
+    );
+    const raw = buildControllerActionUnit(
+      pack,
+      pattern,
+      info.qualifiedName,
+      actionName,
+      method,
+      {
+        display: block.file === (options.absoluteFile ?? options.filePath) ? options.filePath : options.displayPathOf?.(block.file) ?? block.file,
+        absolute: block.file
+      },
+      options,
+      around
+    );
+    units.push(raw);
+    options.onReachSeed?.(raw, {
+      file: block.file,
+      node: method,
+      enclosingQualifiedName: block.info.qualifiedName
+    });
+  };
+  const own = /* @__PURE__ */ new Set();
+  for (const [actionName, method, block] of publicInstanceMethods(ownBlocks)) {
+    own.add(actionName);
+    emitAction(actionName, method, block);
+  }
+  const seen = new Set(own);
+  for (const entry of ancestry) {
+    if (entry.type !== "bodies" || entry.name === info.qualifiedName) {
       continue;
     }
-    const visibility = instanceMethodVisibility(block.info.bodyNode);
-    for (const [actionName, method] of instanceMethodsByName(
-      block.info.bodyNode
+    for (const [actionName, method, block] of publicInstanceMethods(
+      entry.blocks
     )) {
-      if ((visibility.get(actionName) ?? "public") !== "public") {
+      if (seen.has(actionName)) {
         continue;
       }
-      const around = filters.filter((filter) => filterCoversAction(filter, actionName)).map(
-        (filter) => filterReference(
-          filter,
-          options.displayPathOf?.(filter.file) ?? filter.file
-        )
-      );
-      const raw = buildControllerActionUnit(
-        pack,
-        pattern,
-        info.qualifiedName,
-        actionName,
-        method,
-        { display: options.filePath, absolute: block.file },
-        options,
-        around
-      );
-      units.push(raw);
-      options.onReachSeed?.(raw, {
-        file: block.file,
-        node: method,
-        enclosingQualifiedName: info.qualifiedName
-      });
+      seen.add(actionName);
+      if (pattern.routeFor(info.qualifiedName, actionName) === null) {
+        continue;
+      }
+      emitAction(actionName, method, block);
     }
   }
   return units;
 }
+function publicInstanceMethods(blocks) {
+  const found = [];
+  for (const block of blocks) {
+    if (block.info.bodyNode === null) {
+      continue;
+    }
+    const visibility = instanceMethodVisibility(block.info.bodyNode);
+    for (const [name, method] of instanceMethodsByName(block.info.bodyNode)) {
+      if ((visibility.get(name) ?? "public") === "public") {
+        found.push([name, method, block]);
+      }
+    }
+  }
+  return found;
+}
 function buildControllerActionUnit(pack, pattern, controllerQualifiedName, actionName, method, file, bodyRead, wrappers = []) {
   const range = rangeOf(method);
   const route = pattern.routeFor(controllerQualifiedName, actionName);
@@ -4364,7 +4801,8 @@ function collectFileConstants(filePath, root) {
       if (written !== null) {
         definitions.push({
           qualifiedName: qualify(nesting, written),
-          key: nodeId(filePath, node)
+          key: nodeId(filePath, node),
+          kind: "declaration"
         });
         const inside = [...nesting, ...written.split("::")];
         for (const child of children4(node)) {
@@ -4379,7 +4817,8 @@ function collectFileConstants(filePath, root) {
       if (left !== null && left.type === "constant" && right !== null) {
         definitions.push({
           qualifiedName: qualify(nesting, left.text),
-          key: nodeId(filePath, right)
+          key: nodeId(filePath, right),
+          kind: "assignment"
         });
       }
     }
@@ -4406,14 +4845,18 @@ function emitConstantBindings(db, perFile) {
   for (const file of files) {
     for (const definition of file.definitions) {
       const found = byName.get(definition.qualifiedName) ?? [];
-      found.push(definition.key);
+      found.push(definition);
       byName.set(definition.qualifiedName, found);
       fileOfDefinition.set(definition.key, file.filePath);
     }
   }
   const settles = (candidate) => {
-    const found = byName.get(candidate);
-    return found !== void 0 && found.length === 1 ? found[0] ?? null : null;
+    const found = byName.get(candidate) ?? [];
+    const declared = found.filter((one) => one.kind === "declaration");
+    if (declared.length > 0) {
+      return declared[0].key;
+    }
+    return found.length === 1 ? found[0].key : null;
   };
   for (const file of files) {
     for (const reference of file.references) {
@@ -4440,7 +4883,7 @@ function emitConstantBindings(db, perFile) {
 import fs4 from "fs";
 import path5 from "path";
 import { Database as Database3 } from "@suss/datalog";
-import { explainResolvedKey, RESOLUTION_RULES as RESOLUTION_RULES3 } from "@suss/resolution";
+import { explainResolvedKey, RESOLUTION_RULES } from "@suss/resolution";
 
 // src/parser.ts
 import fs2 from "fs";
@@ -4588,34 +5031,118 @@ import {
   unfollowedCallGap,
   worthRecording
 } from "@suss/behavioral-ir";
-import { Database, evaluate as evaluate3, lit as lit2, rule as rule2, variable as v2 } from "@suss/datalog";
+import { Database, evaluate, lit as lit2, rule as rule2, variable as v2 } from "@suss/datalog";
 import { assembleSummary } from "@suss/extractor";
 
 // src/reach/resolveCallee.ts
+import { calleeOutcomeOf, calleeOutcomes } from "@suss/resolution";
 var DYNAMIC_SEND_NAMES = /* @__PURE__ */ new Set(["send", "public_send", "__send__"]);
+var INVOKES_RECEIVER = "call";
+var STOP_FOR = {
+  severalSources: "multipleSources",
+  outsideRun: "outsideRun",
+  unsettled: "unsettledValue",
+  undeclared: "noDeclaration"
+};
 var stop = (reason) => ({
   kind: "stopped",
   reason
 });
+var NO_DECLARATION = stop("noDeclaration");
 function followed(target) {
   return { kind: "followed", target };
 }
-async function resolveCallee(call, site, ctx) {
+function calleeSpellings(calls, ctx) {
+  const spellingOf = /* @__PURE__ */ new Map();
+  const keys = /* @__PURE__ */ new Set();
+  for (const { call, site } of calls) {
+    const spelling = spellingFor(call, site);
+    spellingOf.set(call.id, spelling);
+    if (spelling.kind === "receiver") {
+      keys.add(spelling.key);
+    }
+  }
+  return {
+    spellingOf,
+    outcomes: calleeOutcomes(ctx.facts, [...keys], RUBY_PROGRAM)
+  };
+}
+async function resolveCallee(call, site, ctx, read) {
+  const spelling = read?.spellingOf.get(call.id) ?? spellingFor(call, site);
+  if (spelling.kind === "stopped") {
+    return spelling;
+  }
+  if (spelling.kind === "implicitSelf") {
+    return resolveImplicitSelf(spelling.name, site, ctx);
+  }
+  const outcome = read?.outcomes.get(spelling.key) ?? calleeOutcomeOf(ctx.facts, spelling.key, RUBY_PROGRAM);
+  return asCallee(spelling, outcome, site, ctx);
+}
+function spellingFor(call, site) {
   const methodName = calleeMethodName(call);
   if (methodName === void 0) {
-    return stop("noDeclaration");
+    return { kind: "stopped", reason: "noDeclaration" };
   }
   if (DYNAMIC_SEND_NAMES.has(methodName)) {
-    return stop("unsettledValue");
+    return { kind: "stopped", reason: "unsettledValue" };
   }
   const receiver = field(call, "receiver");
   if (receiver === null || receiver.type === "self") {
-    return resolveImplicitSelf(methodName, site, ctx);
+    return { kind: "implicitSelf", name: methodName };
+  }
+  return {
+    kind: "receiver",
+    key: readKey(site.file, receiver, site.method),
+    method: methodName,
+    onClassItself: receiver.type === "constant" || receiver.type === "scope_resolution"
+  };
+}
+async function asCallee(spelling, outcome, site, ctx) {
+  if (outcome.kind === "severalSources") {
+    return stop("multipleSources");
+  }
+  if (outcome.kind === "callerSupplied") {
+    return fromCaller(spelling, outcome.key, site);
+  }
+  const objects = objectsBehind(ctx.facts, spelling.key);
+  if (objects.length > 1) {
+    return stop("multipleSources");
+  }
+  const objectKey = objects[0] ?? (outcome.kind === "object" ? outcome.key : void 0);
+  if (objectKey !== void 0) {
+    return methodOnObject(spelling, objectKey, ctx);
+  }
+  if (outcome.kind === "function") {
+    return spelling.method === INVOKES_RECEIVER ? functionCallee(outcome.key, ctx) : NO_DECLARATION;
+  }
+  return stop(STOP_FOR[outcome.kind] ?? "noDeclaration");
+}
+function objectsBehind(facts, key) {
+  return [
+    ...new Set(
+      facts.lookup("wantedObjectOf", 0, key).map((row) => String(row[1]))
+    )
+  ];
+}
+async function methodOnObject(spelling, objectKey, ctx) {
+  const qualifiedName = ctx.classNames.get(objectKey);
+  if (qualifiedName === void 0) {
+    return NO_DECLARATION;
   }
-  if (receiver.type === "identifier" && methodName === "call" && site.ownParameters.includes(receiver.text)) {
-    return stop("callerSupplied");
+  if (!spelling.onClassItself) {
+    return methodOnAncestryOf(qualifiedName, spelling.method, ctx);
   }
-  return resolveOnReceiver(receiver, methodName, site, ctx);
+  return spelling.method === "new" ? methodOnAncestryOf(qualifiedName, "initialize", ctx) : singletonMethodOn(qualifiedName, spelling.method, ctx);
+}
+function fromCaller(spelling, parameterKey, site) {
+  if (!parameterKey.startsWith(`${site.owner}#`) || spelling.method !== INVOKES_RECEIVER) {
+    return stop("unsettledValue");
+  }
+  return stop("callerSupplied");
+}
+function functionCallee(key, ctx) {
+  const target = ctx.definitions.get(key);
+  return target === void 0 ? NO_DECLARATION : followed(target);
 }
 async function resolveMethodReference(name, site, ctx) {
   const resolved = await resolveImplicitSelf(name, site, ctx);
@@ -4640,58 +5167,13 @@ async function resolveImplicitSelf(methodName, site, ctx) {
 function resolveTopLevelName(methodName, ctx) {
   const candidates = ctx.topLevelMethods.get(methodName);
   if (candidates === void 0 || candidates.length === 0) {
-    return stop("noDeclaration");
+    return NO_DECLARATION;
   }
   if (candidates.length > 1) {
     return stop("multipleSources");
   }
   return followed(candidates[0]);
 }
-async function resolveOnReceiver(receiver, methodName, site, ctx) {
-  if (receiver.type === "call") {
-    const innerName = calleeMethodName(receiver);
-    const innerReceiver = field(receiver, "receiver");
-    if (innerName === "new" && innerReceiver !== null) {
-      const classRef = classRefOf(innerReceiver, site, ctx);
-      return classRef === null ? stop("unsettledValue") : methodOnAncestryOf(classRef, methodName, ctx);
-    }
-    const root = rootConstantOf(receiver);
-    if (root === null) {
-      return stop("unsettledValue");
-    }
-    return classRefOf(root, site, ctx) === null ? stop("outsideRun") : stop("unsettledValue");
-  }
-  if (receiver.type === "constant" || receiver.type === "scope_resolution") {
-    const classRef = classRefOf(receiver, site, ctx);
-    return classRef === null ? stop("outsideRun") : singletonMethodOn(classRef, methodName, ctx);
-  }
-  return stop("unsettledValue");
-}
-function rootConstantOf(node) {
-  if (node.type === "constant" || node.type === "scope_resolution") {
-    return node;
-  }
-  if (node.type !== "call") {
-    return null;
-  }
-  const receiver = field(node, "receiver");
-  return receiver === null ? null : rootConstantOf(receiver);
-}
-function classRefOf(node, site, ctx) {
-  if (node.type === "constant") {
-    const shadow = shadowingClassFor(node, site.nesting, ctx.knownClasses);
-    if (shadow !== null) {
-      return shadow;
-    }
-    const qualified = qualifyConstantRef(node, site.nesting);
-    return qualified !== null && ctx.knownClasses.has(qualified) ? qualified : null;
-  }
-  if (node.type === "scope_resolution") {
-    const qualified = qualifyConstantRef(node, site.nesting);
-    return qualified !== null && ctx.knownClasses.has(qualified) ? qualified : null;
-  }
-  return null;
-}
 async function methodOnAncestryOf(qualifiedName, methodName, ctx) {
   const ownBlocks = ctx.lookup.localDefinition?.(qualifiedName) ?? null;
   if (ownBlocks === null) {
@@ -4707,7 +5189,7 @@ async function methodOnAncestryOf(qualifiedName, methodName, ctx) {
       found.cause === "dynamicDefine" ? "unsettledValue" : "outsideRun"
     );
   }
-  return stop("noDeclaration");
+  return NO_DECLARATION;
 }
 function reachedMethod(node, block, name) {
   return {
@@ -4732,7 +5214,7 @@ function singletonMethodOn(qualifiedName, methodName, ctx) {
       return followed(reachedMethod(found, block, methodName));
     }
   }
-  return stop("noDeclaration");
+  return NO_DECLARATION;
 }
 
 // src/reach/closure.ts
@@ -4745,7 +5227,7 @@ var REACHABLE_RULES = [
   )
 ];
 async function reachedFunctions(seeds, options) {
-  const ctx = buildReachContext(options.files);
+  const ctx = buildReachContext(options.files, options.facts);
   const db = new Database();
   const functionByKey = /* @__PURE__ */ new Map();
   const seedKeys = /* @__PURE__ */ new Set();
@@ -4767,18 +5249,26 @@ async function reachedFunctions(seeds, options) {
     db.add("entry", [seed.key]);
   }
   for (; ; ) {
-    evaluate3(db, REACHABLE_RULES);
+    evaluate(db, REACHABLE_RULES);
     const frontier = db.facts("reachable").map(([key]) => String(key)).filter((key) => !scanned.has(key));
     if (frontier.length === 0) {
       break;
     }
-    for (const key of frontier) {
+    const bodies = frontier.flatMap((key) => {
       scanned.add(key);
       const source = functionByKey.get(key);
-      if (source === void 0) {
-        continue;
-      }
-      const scan = await scanBody(source, ctx, options);
+      return source === void 0 ? [] : [{ key, source, ...bodyOf2(source, options) }];
+    });
+    const spellings = calleeSpellings(
+      bodies.flatMap((body) => body.written),
+      ctx
+    );
+    for (const { key, source, calls, site } of bodies) {
+      const scan = await scanBody(source, ctx, options, {
+        calls,
+        site,
+        spellings
+      });
       if (scan.stops.length > 0) {
         stopsByKey.set(key, scan.stops);
       }
@@ -4831,11 +5321,22 @@ async function reachedFunctions(seeds, options) {
 function keyOf(target) {
   return nodeId(target.file, target.node);
 }
-function buildReachContext(files) {
+var METHOD_TYPES4 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
+function buildReachContext(files, facts) {
   const blocksByQualifiedName = /* @__PURE__ */ new Map();
   const classes = [];
+  const classNames = /* @__PURE__ */ new Map();
+  const classOfMethod = /* @__PURE__ */ new Map();
   for (const { file, root } of files) {
-    walkDefinitions(root, (info) => classes.push({ file, info }));
+    walkDefinitions(root, (info) => {
+      classes.push({ file, info });
+      classNames.set(nodeId(file, info.node), info.qualifiedName);
+      for (const statement of namedChildren(info.bodyNode)) {
+        if (METHOD_TYPES4.has(statement.type)) {
+          classOfMethod.set(nodeId(file, statement), info.qualifiedName);
+        }
+      }
+    });
   }
   const knownClasses = new Set(classes.map(({ info }) => info.qualifiedName));
   for (const { file, info } of classes) {
@@ -4843,22 +5344,33 @@ function buildReachContext(files) {
     list.push({ info, knownClasses, file });
     blocksByQualifiedName.set(info.qualifiedName, list);
   }
-  const topLevelMethods = /* @__PURE__ */ new Map();
+  const definitions = /* @__PURE__ */ new Map();
   for (const { file, root } of files) {
-    for (const method of topLevelMethodNodes(root)) {
+    for (const [key, method] of methodDefinitionsIn(file, root)) {
       const name = field(method, "name")?.text;
       if (name === void 0) {
         continue;
       }
-      const list = topLevelMethods.get(name) ?? [];
-      list.push({
+      const owner = classOfMethod.get(key) ?? null;
+      definitions.set(key, {
         file,
         node: method,
         name,
-        exportPath: [name],
-        enclosingQualifiedName: null
+        exportPath: owner === null ? [name] : [owner, name],
+        enclosingQualifiedName: owner
       });
-      topLevelMethods.set(name, list);
+    }
+  }
+  const topLevelMethods = /* @__PURE__ */ new Map();
+  for (const { file, root } of files) {
+    for (const method of topLevelMethodNodes(root)) {
+      const found = definitions.get(nodeId(file, method));
+      if (found === void 0) {
+        continue;
+      }
+      const list = topLevelMethods.get(found.name) ?? [];
+      list.push(found);
+      topLevelMethods.set(found.name, list);
     }
   }
   const lookup = {
@@ -4871,7 +5383,13 @@ function buildReachContext(files) {
     parsedFile: async () => null,
     localDefinition: (name) => blocksByQualifiedName.get(name) ?? null
   };
-  return { lookup, knownClasses, topLevelMethods };
+  return { lookup, topLevelMethods, facts, classNames, definitions };
+}
+function namedChildren(node) {
+  if (node === null) {
+    return [];
+  }
+  return node.namedChildren.filter((child) => child !== null);
 }
 function topLevelMethodNodes(root, found = []) {
   for (const child of bodyStatements(root)) {
@@ -4886,14 +5404,6 @@ function topLevelMethodNodes(root, found = []) {
   }
   return found;
 }
-function nestingOf(qualifiedName) {
-  const parts = qualifiedName.split("::");
-  const out = [];
-  for (let depth = parts.length; depth >= 1; depth--) {
-    out.push(parts.slice(0, depth).join("::"));
-  }
-  return out;
-}
 var EMPTY_SCAN = {
   followed: [],
   stops: [],
@@ -4911,21 +5421,23 @@ function methodReferenceSymbol(node) {
   const argChildren = args === null ? [] : bodyStatements(args);
   return argChildren.length === 1 && argChildren[0]?.type === "simple_symbol" ? argChildren[0] : null;
 }
-async function scanBody(source, ctx, options) {
+function bodyOf2(source, options) {
+  const site = {
+    file: source.file,
+    method: source.node,
+    owner: keyOf(source),
+    enclosingQualifiedName: source.enclosingQualifiedName
+  };
+  const calls = field(source.node, "body") === null ? [] : withoutChainLinks(bodyCalls(source.node, options.inheritedMethods));
+  return { calls, site, written: calls.map((call) => ({ call, site })) };
+}
+async function scanBody(source, ctx, options, read) {
   const displayPathOf = options.displayPathOf;
-  const body = field(source.node, "body");
-  if (body === null) {
+  if (field(source.node, "body") === null) {
     return EMPTY_SCAN;
   }
-  const calls = withoutChainLinks(
-    bodyCalls(source.node, options.inheritedMethods)
-  );
+  const { calls, site } = read;
   const ownParameters = positionalParameters(source.node).map((p) => p.name);
-  const site = {
-    enclosingQualifiedName: source.enclosingQualifiedName,
-    nesting: source.enclosingQualifiedName === null ? [] : nestingOf(source.enclosingQualifiedName),
-    ownParameters
-  };
   const followed2 = [];
   const stops = [];
   const placements = new TargetPlacements();
@@ -4968,7 +5480,7 @@ async function scanBody(source, ctx, options) {
   };
   for (const call of calls) {
     const callee = calleeText(call);
-    const outcome = await resolveCallee(call, site, ctx);
+    const outcome = await resolveCallee(call, site, ctx, read.spellings);
     const placed = outcome.kind === "followed" ? {
       file: displayPathOf(outcome.target.file),
       span: spanOf(outcome.target.node)
@@ -5106,7 +5618,8 @@ function inheritedMethodsIn(packs) {
   return found;
 }
 function alreadyDiscovered(seen, raw) {
-  const key = `${raw.identity.file}::${raw.identity.name}::${raw.identity.range.start}`;
+  const reported = raw.identity.exportPath?.join(".") ?? raw.identity.name;
+  const key = `${raw.identity.file}::${reported}::${raw.identity.range.start}`;
   if (seen.has(key)) {
     return true;
   }
@@ -5266,6 +5779,7 @@ async function extractRubyProject(options) {
     () => reachedFunctions(seeds, {
       files: parsed,
       displayPathOf,
+      facts: db,
       ...storage === void 0 ? {} : { storage },
       inheritedMethods
     })
@@ -5362,15 +5876,15 @@ function findRubyFiles(root) {
 }
 
 // src/facts/why.ts
-var WITNESS_RULES = [...RESOLUTION_RULES3, ...RUBY_RULES];
-var METHOD_TYPES4 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
+var WITNESS_RULES = [...RESOLUTION_RULES, ...RUBY_RULES];
+var METHOD_TYPES5 = /* @__PURE__ */ new Set(["method", "singleton_method"]);
 function namedChildrenOf(node) {
   return node.namedChildren.filter((child) => child !== null);
 }
 function enclosingMethod2(node) {
   let current = node.parent;
   while (current !== null) {
-    if (METHOD_TYPES4.has(current.type)) {
+    if (METHOD_TYPES5.has(current.type)) {
       return current;
     }
     current = current.parent;
@@ -5405,8 +5919,8 @@ function displayNameOf(node) {
   if (node.type === "class" || node.type === "module") {
     return field(node, "name")?.text ?? node.text;
   }
-  const text = node.text.split("\n")[0].trim();
-  return text.length > 40 ? `${text.slice(0, 40)}...` : text;
+  const text2 = node.text.split("\n")[0].trim();
+  return text2.length > 40 ? `${text2.slice(0, 40)}...` : text2;
 }
 function width(node) {
   return node.endIndex - node.startIndex;
@@ -5433,14 +5947,14 @@ var RubyWhySession = class {
    * The smallest expression on `line` of `file` whose text is exactly
    * `text`, or null.
    */
-  findExpression(file, line, text) {
+  findExpression(file, line, text2) {
     const root = this.rootOf(file);
     if (root === null) {
       return null;
     }
     let found = null;
     const visit = (node) => {
-      if (node.startPosition.row + 1 === line && node.text === text) {
+      if (node.startPosition.row + 1 === line && node.text === text2) {
         if (found === null || width(node) <= width(found)) {
           found = node;
         }
@@ -5610,6 +6124,7 @@ export {
   inheritedStatements,
   methodDefinitionsIn,
   methodInAncestry,
+  nestedStatements,
   nodeId,
   parseRuby,
   parseRubySync,