Function templateFunctionStr

valdi/vscode_debugger/src/adapter/templates/index.ts:49–109

(
  stringified: string,
)

}

export function templateFunctionStr<Args extends string[]>(
  stringified: string,
): (...args: Args) => string {
  const sourceFile = ts.createSourceFile('test.js', stringified, ts.ScriptTarget.ESNext, true);

  // 1. Find the function.
  let decl: ts.FunctionLike | undefined;
  ts.forEachChild(sourceFile, function traverse(node) {
    if (ts.isFunctionLike(node)) {
      decl = node;
    } else {
      ts.forEachChild(node, traverse);
    }
  });

  if (!decl || !('body' in decl) || !decl.body) {
    throw new Error(`Could not find function declaration for:\n\n${stringified}`);
  }

  // 2. Get parameter names.
  const params = decl.parameters.map(p => {
    if (!ts.isIdentifier(p.name)) {
      throw new Error('Parameter must be identifier');
    }

    return p.name.text;
  });

  // 3. Gather usages of the parameter in the source.
  const replacements: { start: number; end: number; param: number }[] = [];
  ts.forEachChild(decl.body, function traverse(node) {
    if (ts.isIdentifier(node) && params.includes(node.text)) {
      replacements.push({
        start: node.getStart(),
        end: node.getEnd(),
        param: params.indexOf(node.text),
      });
    }

    ts.forEachChild(node, traverse);
  });

  replacements.sort((a, b) => b.end - a.end);

  // 4. Sort usages and slice up the function appropriately, wraping in an IIFE.
  const parts: string[] = [];
  let lastIndex = decl.body.getEnd() - 1;
  for (const replacement of replacements) {
    parts.push(stringified.slice(replacement.end, lastIndex));
    parts.push(`__args${replacement.param}`);
    lastIndex = replacement.start;
  }

  parts.push(stringified.slice(decl.body.getStart() + 1, lastIndex));
  const body = parts.reverse().join('');

  return (...args) => `(() => {
    ${args.map((a, i) => `let __args${i} = ${a}`).join('; ')};