@jskit-ai/architecture-inspector 0.1.0 → 0.1.2

package/src/calls/resolve.js

@@ -0,0 +1,658 @@
+import { EventEmitter } from "node:events";
+import { Stats } from "node:fs";
+import { Duplex } from "node:stream";
+import ts from "typescript";
+import { isCalledInPlace, isFunctionLike, owningParameter, parameterNames, runsDuring, unwrapExpression } from "./functions.js";
+import { isClassLike } from "./symbols.js";
+import { isLiteralPattern } from "./evaluate.js";
+import { NODE_GLOBALS, createExternalValues, isComponentFile } from "./external.js";
+
+const MAX_TARGETS = 16;
+const MAX_TYPE_DEPTH = 6;
+// Vue's `<script setup>` compiler macros are globals of component scripts.
+const VUE_MACROS = new Set(["defineProps", "defineEmits", "defineExpose", "defineOptions", "defineSlots", "defineModel", "withDefaults"]);
+// Node objects untyped receivers most often hold; TypeScript's libraries do
+// not declare their members, so the names are read from Node itself.
+const NODE_MEMBER_SOURCES = Object.freeze([EventEmitter.prototype, Stats.prototype, Duplex.prototype]);
+const VIA_ORDER = Object.freeze(["checker", "self", "di-binding", "argument-flow"]);
+
+function weakerVia(left, right) {
+  return VIA_ORDER.indexOf(left) >= VIA_ORDER.indexOf(right) ? left : right;
+}
+
+function isAnyType(type) {
+  return Boolean(type.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown));
+}
+
+// JSKIT's package layout keeps client and server code apart, so a name never
+// matches a candidate on the other side.
+function codeSide(file) {
+  const parts = file.split("/");
+  if (parts.includes("server")) {
+    return "server";
+  }
+  if (parts.includes("client") || parts[0] === "src" || file.endsWith(".vue")) {
+    return "client";
+  }
+  return "shared";
+}
+
+function compatibleSides(left, right) {
+  return left === "shared" || right === "shared" || left === right;
+}
+
+// Member names of TypeScript's libraries and of common Node objects.
+function libraryMemberNames(program) {
+  const names = new Set();
+  for (const source of NODE_MEMBER_SOURCES) {
+    for (let prototype = source; prototype && prototype !== Object.prototype; prototype = Object.getPrototypeOf(prototype)) {
+      Object.getOwnPropertyNames(prototype).forEach((name) => names.add(name));
+    }
+  }
+  for (const sourceFile of program.getSourceFiles()) {
+    if (!program.isSourceFileDefaultLibrary(sourceFile)) {
+      continue;
+    }
+    const visit = (node) => {
+      if ((ts.isMethodSignature(node) || ts.isPropertySignature(node) || ts.isMethodDeclaration(node) ||
+        ts.isPropertyDeclaration(node) || ts.isGetAccessorDeclaration(node)) && node.name && ts.isIdentifier(node.name)) {
+        names.add(node.name.text);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+  }
+  return names;
+}
+
+function constructorOf(implementation) {
+  if (!isClassLike(implementation)) {
+    return implementation;
+  }
+  return implementation.members.find((member) => ts.isConstructorDeclaration(member) && member.body) || null;
+}
+
+/**
+ * Call resolution over one program: TypeScript checker targets, defineFeature
+ * injection, argument flow, literal-array unrolling and receiver names, each
+ * labelled with its certainty. Provably external calls are dropped.
+ * @param {object} dependencies
+ * @param {import("typescript").Program} dependencies.program
+ * @param {import("typescript").TypeChecker} dependencies.checker
+ * @param {import("./types.js").CallSymbols} dependencies.symbols
+ * @param {import("./types.js").CallEvaluator} dependencies.evaluator
+ * @param {import("./types.js").FeatureBindings["bindings"]} dependencies.bindings
+ * @param {Map<string, import("./types.js").FeatureBindings["actions"]>} dependencies.actionsById
+ * @param {import("./types.js").FileOf} dependencies.fileOf
+ * @param {Map<string, import("typescript").Node[]>} dependencies.functionNames
+ */
+function createResolver({ program, checker, symbols, evaluator, bindings, actionsById, fileOf, functionNames }) {
+  const builtinMembers = libraryMemberNames(program);
+  const { isExternalValue, isExternalDeclaration } = createExternalValues({ checker, symbols, fileOf });
+  /** @type {Map<import("typescript").Node, import("typescript").CallExpression[]>} */
+  const callSites = new Map();
+  const direct = new Map();
+  // The functions each indexed call reaches, and the calls whose index entry
+  // came from a guess (several values or an ambiguous injection).
+  /** @type {Map<import("typescript").CallExpression, import("typescript").Node[]>} */
+  const indexedTargets = new Map();
+  /** @type {Set<import("typescript").CallExpression>} */
+  const probableSites = new Set();
+
+  function implementationsFor(symbol) {
+    const found = symbols.symbolImplementations(symbol).map(constructorOf).filter(Boolean);
+    return found.length ? found : declaredMemberImplementations(symbol);
+  }
+
+  // A member a type declares without a value (`{ run: typeof run }` or
+  // `@property {typeof run} run`) holds the function or class its type names.
+  function declaredMemberImplementations(symbol) {
+    const declarations = symbol?.declarations || [];
+    if (!declarations.length || !declarations.every((declaration) => ts.isPropertySignature(declaration) || ts.isJSDocPropertyTag(declaration))) {
+      return [];
+    }
+    const type = checker.getTypeOfSymbol(symbol);
+    if (!type.getCallSignatures().length && !type.getConstructSignatures().length) {
+      return [];
+    }
+    return symbols.symbolImplementations(type.getSymbol()).map(constructorOf).filter(Boolean);
+  }
+
+  // Pass 1: what the checker resolves on its own, and the call-site index
+  // argument flow reads.
+  function directResolution(call) {
+    const callee = unwrapExpression(call.expression);
+    if (ts.isIdentifier(callee)) {
+      const symbol = symbols.symbolAt(callee);
+      if (!symbol) {
+        return { kind: "undeclared", name: callee.text };
+      }
+      if (symbols.isPackageImport(callee) || symbols.isLibrarySymbol(symbol)) {
+        return { kind: "external" };
+      }
+      const targets = implementationsFor(symbol);
+      return targets.length
+        ? { kind: "targets", targets, via: "checker" }
+        : { kind: "value", declaration: symbols.declarationOf(callee) };
+    }
+    if (ts.isPropertyAccessExpression(callee)) {
+      const symbol = checker.getSymbolAtLocation(callee.name);
+      if (symbol && symbols.isLibrarySymbol(symbol)) {
+        return { kind: "external" };
+      }
+      const targets = symbol ? implementationsFor(symbol) : [];
+      return targets.length ? { kind: "targets", targets, via: "checker" } : { kind: "member", callee };
+    }
+    if (ts.isElementAccessExpression(callee)) {
+      return { kind: "computed", callee };
+    }
+    if (callee.kind === ts.SyntaxKind.ImportKeyword) {
+      return { kind: "external" };
+    }
+    const declaration = checker.getResolvedSignature(call)?.declaration;
+    if (declaration && isFunctionLike(declaration) && fileOf(declaration)) {
+      return { kind: "targets", targets: [declaration], via: "checker" };
+    }
+    if (declaration && !fileOf(declaration)) {
+      return { kind: "external" };
+    }
+    return { kind: "other" };
+  }
+
+  // Records that a call reaches these functions, for argument flow. A
+  // probable site's values are never exact.
+  function indexSite(call, targets, probable = false) {
+    const known = indexedTargets.get(call) || [];
+    for (const target of targets) {
+      if (known.includes(target)) {
+        continue;
+      }
+      known.push(target);
+      if (!callSites.has(target)) {
+        callSites.set(target, []);
+      }
+      callSites.get(target).push(call);
+    }
+    if (known.length) {
+      indexedTargets.set(call, known);
+    }
+    if (probable) {
+      probableSites.add(call);
+    }
+  }
+
+  // The checker's own targets of each call; returns them per call.
+  function indexCalls(calls) {
+    return calls.map((call) => {
+      const resolution = directResolution(call);
+      direct.set(call, resolution);
+      indexSite(call, resolution.targets || []);
+      return resolution.targets || [];
+    });
+  }
+
+  // The value one call gives a parameter: the argument, or the property of an
+  // object literal argument a destructured parameter takes, with the rest of
+  // its property path.
+  function argumentValue(call, owner) {
+    let value = call.arguments?.[owner.index];
+    if (!value || ts.isSpreadElement(value)) {
+      return null;
+    }
+    const remaining = [...owner.path];
+    while (remaining.length && ts.isObjectLiteralExpression(unwrapExpression(value))) {
+      value = evaluator.propertyInitializer(unwrapExpression(value), remaining[0]);
+      remaining.shift();
+      if (!value) {
+        return null;
+      }
+    }
+    return { expression: value, path: remaining };
+  }
+
+  function argumentValues(declaration) {
+    const owner = owningParameter(declaration);
+    if (!owner) {
+      return [];
+    }
+    return (callSites.get(owner.fn) || []).map((call) => {
+      const value = argumentValue(call, owner);
+      return value && { ...value, probable: probableSites.has(call) };
+    }).filter(Boolean);
+  }
+
+  function propertyValueExpressions(property) {
+    const expressions = [];
+    for (const declaration of property.declarations || []) {
+      if ((ts.isPropertyAssignment(declaration) || ts.isPropertyDeclaration(declaration)) && declaration.initializer) {
+        expressions.push(declaration.initializer);
+      } else if (ts.isShorthandPropertyAssignment(declaration)) {
+        expressions.push(declaration.name);
+      } else if ((ts.isPropertyAccessExpression(declaration) || ts.isBinaryExpression(declaration.parent)) &&
+        ts.isBinaryExpression(declaration.parent) && declaration.parent.left === declaration) {
+        expressions.push(declaration.parent.right);
+      }
+    }
+    return expressions;
+  }
+
+  function propertyTypes(entries, name, location, depth, seen) {
+    const result = [];
+    for (const entry of entries) {
+      for (const part of entry.type.isUnion() ? entry.type.types : [entry.type]) {
+        const property = part.getProperty(name);
+        if (!property) {
+          continue;
+        }
+        const type = checker.getTypeOfSymbolAtLocation(property, location);
+        if (!isAnyType(type)) {
+          result.push({ ...entry, type });
+          continue;
+        }
+        for (const expression of propertyValueExpressions(property)) {
+          for (const found of typesOf(expression, depth + 1, seen)) {
+            result.push({ type: found.type, exact: entry.exact && found.exact, via: weakerVia(entry.via, found.via) });
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  function valueTypes(value, depth, seen) {
+    let entries = typesOf(value.expression, depth + 1, seen);
+    for (const name of value.path) {
+      entries = propertyTypes(entries, name, value.expression, depth, seen);
+    }
+    return entries;
+  }
+
+  // Types an untyped expression takes through injection and argument flow.
+  function typesOf(expression, depth = 0, seen = new Set()) {
+    const value = unwrapExpression(expression);
+    if (!value || depth > MAX_TYPE_DEPTH || seen.has(value)) {
+      return [];
+    }
+    seen.add(value);
+    const direct = checker.getTypeAtLocation(value);
+    if (!isAnyType(direct)) {
+      return [{ type: direct, exact: true, via: "checker" }];
+    }
+    if (ts.isIdentifier(value)) {
+      const declaration = symbols.declarationOf(value);
+      if (!declaration || !fileOf(declaration)) {
+        return [];
+      }
+      if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+        return typesOf(declaration.initializer, depth + 1, seen);
+      }
+      if (ts.isBindingElement(declaration) || ts.isParameter(declaration)) {
+        const binding = bindings.get(declaration);
+        if (binding) {
+          return binding.expressions.flatMap((bound) => typesOf(bound, depth + 1, seen).map((entry) => ({
+            type: entry.type,
+            exact: entry.exact && binding.exact,
+            via: weakerVia(entry.via, "di-binding")
+          })));
+        }
+        const values = argumentValues(declaration);
+        return values.flatMap((bound) => valueTypes(bound, depth, seen).map((entry) => ({
+          type: entry.type,
+          exact: entry.exact && values.length === 1,
+          via: "argument-flow"
+        })));
+      }
+      return [];
+    }
+    if (ts.isPropertyAccessExpression(value)) {
+      return propertyTypes(typesOf(value.expression, depth + 1, seen), value.name.text, value, depth, seen);
+    }
+    if (ts.isCallExpression(value)) {
+      const signatures = typesOf(value.expression, depth + 1, seen).flatMap((entry) =>
+        entry.type.getCallSignatures().map((signature) => ({ ...entry, type: signature.getReturnType() })));
+      return signatures.filter((entry) => !isAnyType(entry.type));
+    }
+    if (ts.isAwaitExpression(value)) {
+      return typesOf(value.expression, depth + 1, seen).map((entry) => ({ ...entry, type: checker.getAwaitedType(entry.type) || entry.type }));
+    }
+    return [];
+  }
+
+  function targetsFromTypes(entries, names) {
+    const targets = new Map();
+    let external = false;
+    for (const entry of entries) {
+      for (const part of entry.type.isUnion() ? entry.type.types : [entry.type]) {
+        for (const name of names) {
+          const property = part.getProperty(name);
+          if (!property) {
+            continue;
+          }
+          if (symbols.isLibrarySymbol(property)) {
+            external = true;
+            continue;
+          }
+          for (const target of implementationsFor(property)) {
+            const previous = targets.get(target);
+            targets.set(target, previous
+              ? { exact: previous.exact && entry.exact, via: weakerVia(previous.via, entry.via) }
+              : { exact: entry.exact, via: entry.via });
+          }
+        }
+      }
+    }
+    return { targets, external };
+  }
+
+  function fromTargets(targets, { exactAllowed = true, method }) {
+    const list = [...targets.keys()];
+    if (!list.length) {
+      return null;
+    }
+    if (list.length > MAX_TARGETS) {
+      return unresolved();
+    }
+    const facts = [...targets.values()];
+    const via = method || facts.map((entry) => entry.via).reduce(weakerVia);
+    if (list.length === 1) {
+      const exact = exactAllowed && facts[0].exact;
+      return { resolution: "resolved", certainty: exact ? "exact" : "probable", method: via, targets: list };
+    }
+    return { resolution: "ambiguous", certainty: "probable", method: via, targets: list };
+  }
+
+  function unresolved() {
+    return { resolution: "unresolved", certainty: "unresolved", method: "none", targets: [] };
+  }
+
+  // The functions a passed value can be, added to `targets`. With `passedOn`,
+  // the path of parameters followed so far, a parameter the value passes on
+  // holds what its own callers give it; a callback a helper runs (passedCall)
+  // is never followed to another caller's value.
+  function addValueTargets(value, targets, exact = false, passedOn = null) {
+    const found = value.path.length
+      ? [...targetsFromTypes(valueTypes({ expression: value.expression, path: value.path.slice(0, -1) }, 0, new Set()), [value.path.at(-1)]).targets.keys()]
+      : symbols.expressionImplementations(value.expression, 0).map(constructorOf).filter(Boolean);
+    const expression = unwrapExpression(value.expression);
+    const parameter = passedOn && !found.length && !value.path.length && ts.isIdentifier(expression) ? symbols.declarationOf(expression) : null;
+    if (parameter && (ts.isParameter(parameter) || ts.isBindingElement(parameter)) &&
+      !passedOn.includes(parameter) && passedOn.length < MAX_TYPE_DEPTH) {
+      const values = argumentValues(parameter);
+      for (const passed of values) {
+        addValueTargets(passed, targets, exact && values.length === 1 && !passed.probable, [...passedOn, parameter]);
+      }
+      return;
+    }
+    for (const target of found) {
+      targets.set(target, { exact: exact && found.length === 1 && !value.path.length, via: "argument-flow" });
+    }
+  }
+
+  // Values of an injected or passed-in function, called directly. A parameter
+  // called while its function runs is left to each caller (passedCall), so
+  // one caller's callback is never reached through another caller.
+  function boundFunctionTargets(declaration, call) {
+    const targets = new Map();
+    const binding = bindings.get(declaration);
+    if (binding) {
+      for (const expression of binding.expressions) {
+        for (const target of symbols.expressionImplementations(expression, 0).map(constructorOf).filter(Boolean)) {
+          targets.set(target, { exact: binding.exact, via: "di-binding" });
+        }
+      }
+      return targets;
+    }
+    const owner = owningParameter(declaration);
+    if (owner && ts.isCallExpression(call) && runsDuring(call, owner.fn)) {
+      return targets;
+    }
+    const values = argumentValues(declaration);
+    for (const value of values) {
+      addValueTargets(value, targets, values.length === 1 && !value.probable, []);
+    }
+    return targets;
+  }
+
+  function checkerTargets(call) {
+    if (!direct.has(call)) {
+      direct.set(call, directResolution(call));
+    }
+    return direct.get(call).targets || [];
+  }
+
+  // The functions a call reaches as the index knows them: the checker's, or
+  // those injection or argument flow resolved.
+  function siteTargets(call) {
+    return indexedTargets.get(call) || checkerTargets(call);
+  }
+
+  // The calls whose callee is a parameter or a destructured name: those
+  // injection or argument flow can resolve. What a call's callee is declared
+  // as depends only on its own file.
+  function boundCandidates(calls) {
+    return calls.filter((call) => {
+      checkerTargets(call);
+      const declaration = direct.get(call).declaration;
+      return declaration && (ts.isParameter(declaration) || ts.isBindingElement(declaration));
+    });
+  }
+
+  // Calls the checker cannot resolve but injection or argument flow can are
+  // call sites too, so argument flow and the callbacks a call passes reach
+  // through them. Each round can expose more; the targets and guesses only
+  // grow, so the rounds stop. Takes the candidates of every file, since one
+  // file's arguments decide another's targets, and returns each candidate's
+  // targets and whether they are a guess.
+  function indexBoundCalls(candidates) {
+    for (let changed = true; changed;) {
+      changed = false;
+      for (const call of candidates) {
+        const found = boundFunctionTargets(direct.get(call).declaration, call);
+        const targets = found.size > MAX_TARGETS ? [] : [...found.keys()];
+        const probable = targets.length !== 1 || !found.get(targets[0]).exact;
+        const known = indexedTargets.get(call) || [];
+        if (targets.some((target) => !known.includes(target)) || (probable && targets.length && !probableSites.has(call))) {
+          indexSite(call, targets, probable);
+          changed = true;
+        }
+      }
+    }
+    return candidates.map((call) => ({ targets: indexedTargets.get(call) || [], probable: probableSites.has(call) }));
+  }
+
+  // The parameters ({ index, path }) a function calls while it runs: in its
+  // own body, in callbacks it passes on, or by forwarding them to a function
+  // that does. A cycle adds nothing.
+  const invoked = new Map();
+  function invokedParameters(fn) {
+    if (invoked.has(fn)) {
+      return [...invoked.get(fn).values()];
+    }
+    const found = new Map();
+    invoked.set(fn, found);
+    const names = parameterNames(fn);
+    const own = (expression) => {
+      const value = unwrapExpression(expression);
+      if (!value || !ts.isIdentifier(value) || !names.has(value.text)) {
+        return null;
+      }
+      const owner = owningParameter(symbols.declarationOf(value));
+      return owner?.fn === fn ? owner : null;
+    };
+    const add = (index, path) => found.set(`${index}:${path.join(".")}`, { index, path });
+    const visit = (node) => {
+      if (isFunctionLike(node) && !isCalledInPlace(node)) {
+        return;
+      }
+      if (ts.isCallExpression(node)) {
+        const called = own(node.expression);
+        if (called) {
+          add(called.index, called.path);
+        }
+        node.arguments.forEach((argument, position) => {
+          const forwarded = own(argument);
+          for (const target of forwarded ? siteTargets(node) : []) {
+            for (const inner of invokedParameters(target)) {
+              if (inner.index === position) {
+                add(forwarded.index, [...forwarded.path, ...inner.path]);
+              }
+            }
+          }
+        });
+      }
+      ts.forEachChild(node, visit);
+    };
+    if (names.size) {
+      visit(fn.body);
+    }
+    return [...found.values()];
+  }
+
+  // What a call reaches through the functions it passes: each value it gives
+  // a parameter its callee calls while it runs. Null when there is none.
+  function passedCall(call) {
+    if (!call.arguments?.length) {
+      return null;
+    }
+    const targets = new Map();
+    for (const callee of siteTargets(call)) {
+      for (const parameter of invokedParameters(callee)) {
+        const value = argumentValue(call, parameter);
+        if (value) {
+          addValueTargets(value, targets, !probableSites.has(call));
+        }
+      }
+    }
+    const result = fromTargets(targets, {});
+    return result?.resolution === "unresolved" ? null : result;
+  }
+
+  function receiverHint(receiver, candidates) {
+    const text = receiver?.getText().split(".").pop()?.replace(/Service$/u, "").toLowerCase();
+    if (!text || !/^[a-z][\w]*$/u.test(text)) {
+      return [];
+    }
+    const singular = text.replace(/s$/u, "");
+    return candidates.filter((candidate) => fileOf(candidate).toLowerCase().split(/[/.-]/u)
+      .some((token) => token === text || token === singular));
+  }
+
+  // A member call on an untyped receiver reaches a project function only
+  // when the name is that function's alone: no builtin member has it, and
+  // exactly one function on this side declares it (or exactly one in a file
+  // the receiver names). A shared name is a guess, so it stays unresolved.
+  function byName(name, receiver, file) {
+    const side = codeSide(file);
+    const candidates = (functionNames.get(name) || []).filter((candidate) => compatibleSides(side, codeSide(fileOf(candidate))));
+    if (!candidates.length) {
+      return builtinMembers.has(name) ? null : unresolved();
+    }
+    const hinted = candidates.length > 1 ? receiverHint(receiver, candidates) : [];
+    const chosen = hinted.length === 1 ? hinted : candidates;
+    if (chosen.length !== 1 || builtinMembers.has(name)) {
+      return unresolved();
+    }
+    return { resolution: "resolved", certainty: "probable", method: "receiver-name", targets: chosen };
+  }
+
+  function enclosingClass(node) {
+    let current = node.parent;
+    while (current && !isClassLike(current)) {
+      current = current.parent;
+    }
+    return current;
+  }
+
+  function selfMethod(callee) {
+    if (callee.expression.kind !== ts.SyntaxKind.ThisKeyword) {
+      return null;
+    }
+    const owner = enclosingClass(callee);
+    const method = owner?.members.find((member) => ts.isMethodDeclaration(member) && member.body &&
+      member.name && ts.isIdentifier(member.name) && member.name.text === callee.name.text);
+    return method ? { resolution: "resolved", certainty: "exact", method: "self", targets: [method] } : null;
+  }
+
+  // `request.executeAction({ actionId: "literal" })` runs that action.
+  function actionCall(call, callee) {
+    if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "executeAction") {
+      return null;
+    }
+    const options = unwrapExpression(call.arguments[0]);
+    const idExpression = options && ts.isObjectLiteralExpression(options) ? evaluator.propertyInitializer(options, "actionId") : null;
+    const actionId = idExpression && evaluator.evaluateLiteral(idExpression);
+    const definitions = actionId ? actionsById.get(actionId) || [] : [];
+    const executes = definitions.flatMap((definition) => definition.execute);
+    if (definitions.length !== 1 || executes.length !== 1) {
+      return null;
+    }
+    return { resolution: "resolved", certainty: "exact", method: "route-action", targets: executes };
+  }
+
+  function memberResolution(call, callee, file) {
+    const action = actionCall(call, callee);
+    if (action) {
+      return action;
+    }
+    if (isExternalValue(callee.expression)) {
+      return null;
+    }
+    const found = targetsFromTypes(typesOf(callee.expression), [callee.name.text]);
+    if (found.targets.size) {
+      return fromTargets(found.targets, {});
+    }
+    if (found.external) {
+      return null;
+    }
+    return selfMethod(callee) || byName(callee.name.text, callee.expression, file);
+  }
+
+  function computedResolution(callee) {
+    if (isExternalValue(callee.expression)) {
+      return null;
+    }
+    const names = evaluator.evaluate(callee.argumentExpression);
+    if (!names.every(isLiteralPattern)) {
+      return unresolved();
+    }
+    const found = targetsFromTypes(typesOf(callee.expression), names);
+    if (found.targets.size) {
+      return fromTargets(found.targets, {});
+    }
+    return found.external ? null : unresolved();
+  }
+
+  // Pass 2: the final certainty of one call, or null when it is external.
+  function resolve(call, file) {
+    const resolution = direct.get(call) || directResolution(call);
+    const callee = unwrapExpression(call.expression);
+    switch (resolution.kind) {
+      case "targets":
+        return fromTargets(new Map(resolution.targets.map((target) => [target, { exact: true, via: "checker" }])), {});
+      case "external":
+        return null;
+      case "undeclared":
+        return NODE_GLOBALS.has(resolution.name) || (isComponentFile(file) && VUE_MACROS.has(resolution.name)) ? null : unresolved();
+      case "value": {
+        const declaration = resolution.declaration;
+        const bound = declaration && (ts.isParameter(declaration) || ts.isBindingElement(declaration))
+          ? fromTargets(boundFunctionTargets(declaration, call), {})
+          : null;
+        if (bound) {
+          return bound;
+        }
+        return declaration && isExternalDeclaration(declaration, 0) ? null : unresolved();
+      }
+      case "member":
+        return memberResolution(call, resolution.callee, file);
+      case "computed":
+        return computedResolution(callee);
+      default:
+        return unresolved();
+    }
+  }
+
+  return { indexCalls, indexSite, boundCandidates, indexBoundCalls, resolve, passedCall, builtinMembers };
+}
+
+export { codeSide, createResolver };