Revert to create a temporary file

Author: n4o847

src/index.ts

@@ -1,64 +1,6 @@
-import * as ts from 'typescript';
-import * as tmp from 'tmp-promise';
-import * as path from 'path';
+import { run } from './temporary';
 
-interface RunOptions {
-  input: Buffer;
-}
-
-interface RunResult {
-  output: Buffer;
-}
-
-export async function run(fileName: string, { input = Buffer.of() }: Partial<RunOptions> = {}): Promise<RunResult> {
-  const callerFileName = await tmp.tmpName({ prefix: `compile-time-typescript`, postfix: `caller.ts` });
-  const callerSourceFile = ts.createSourceFile(callerFileName, `
-    import Main from ${JSON.stringify(path.resolve(fileName).replace(/\.ts$/, ''))};
-    type Input = ${JSON.stringify(input.toString('binary'))};
-    type Output = Main<Input>;
-  `, ts.ScriptTarget.Latest);
-
-  const defaultCompilerHost = ts.createCompilerHost({});
-  const customCompilerHost: ts.CompilerHost = {
-    ...defaultCompilerHost,
-    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void), shouldCreateNewSourceFile?: boolean): ts.SourceFile | undefined {
-      if (fileName === callerFileName) {
-        return callerSourceFile;
-      } else {
-        return defaultCompilerHost.getSourceFile.call(this, fileName, languageVersion, onError, shouldCreateNewSourceFile);
-      }
-    },
-  };
-
-  const program = ts.createProgram({
-    rootNames: [callerFileName],
-    options: {
-      strict: true,
-    },
-    host: customCompilerHost,
-  });
-  const checker = program.getTypeChecker();
-  const outputList: Buffer[] = [];
-
-  function visit(node: ts.Node) {
-    const symbol = checker.getSymbolAtLocation(node);
-    if (symbol && symbol.getName() === `Output`) {
-      const type = checker.getDeclaredTypeOfSymbol(symbol);
-      if (type.isStringLiteral()) {
-        outputList.push(Buffer.from(type.value));
-      } else {
-        throw new Error(`type error: ${checker.typeToString(type)}`);
-      }
-    }
-    node.forEachChild(visit);
-  }
-
-  callerSourceFile.forEachChild(visit);
-
-  return {
-    output: Buffer.concat(outputList),
-  };
-}
+export { run } from './temporary';
 
 export async function main(...args: string[]) {
   if (!(args.length === 1 && typeof args[0] === 'string')) {

src/temporary.ts

@@ -0,0 +1,58 @@
+import * as ts from 'typescript';
+import { promises as fs } from 'fs';
+import * as tmp from 'tmp-promise';
+import * as path from 'path';
+
+interface RunOptions {
+  input: Buffer;
+}
+
+interface RunResult {
+  output: Buffer;
+}
+
+export async function run(fileName: string, { input = Buffer.of() }: Partial<RunOptions> = {}): Promise<RunResult> {
+  const { path: tmpDirPath } = await tmp.dir({ prefix: `compile-time-typescript` });
+  const calleeFileName = `callee.ts`;
+  const callerFileName = `caller.ts`;
+  await Promise.all([
+    fs.copyFile(fileName, path.join(tmpDirPath, calleeFileName)),
+    fs.writeFile(path.join(tmpDirPath, callerFileName), `
+      import Main from './${path.basename(calleeFileName, path.extname(calleeFileName))}';
+      type Input = ${JSON.stringify(input.toString('binary'))};
+      type Output = Main<Input>;
+    `),
+  ]);
+  const program = ts.createProgram({
+    rootNames: [path.join(tmpDirPath, callerFileName)],
+    options: {
+      strict: true,
+    },
+  });
+  const source = program.getSourceFile(path.join(tmpDirPath, callerFileName))!;
+  const checker = program.getTypeChecker();
+  const outputList: Buffer[] = [];
+
+  function visit(node: ts.Node) {
+    const symbol = checker.getSymbolAtLocation(node);
+    if (symbol && symbol.getName() === `Output`) {
+      const type = checker.getDeclaredTypeOfSymbol(symbol);
+      if (type.isStringLiteral()) {
+        outputList.push(Buffer.from(type.value));
+      } else {
+        throw new Error(`type error: ${checker.typeToString(type)}`);
+      }
+    }
+    node.forEachChild(visit);
+  }
+
+  source.forEachChild(visit);
+  await Promise.all([
+    fs.unlink(path.join(tmpDirPath, calleeFileName)),
+    fs.unlink(path.join(tmpDirPath, callerFileName)),
+  ]);
+  await fs.rmdir(tmpDirPath);
+  return {
+    output: Buffer.concat(outputList),
+  };
+}

src/virtual.ts

@@ -0,0 +1,61 @@
+import * as ts from 'typescript';
+import * as tmp from 'tmp-promise';
+import * as path from 'path';
+
+interface RunOptions {
+  input: Buffer;
+}
+
+interface RunResult {
+  output: Buffer;
+}
+
+export async function run(fileName: string, { input = Buffer.of() }: Partial<RunOptions> = {}): Promise<RunResult> {
+  const callerFileName = await tmp.tmpName({ prefix: `compile-time-typescript`, postfix: `caller.ts` });
+  const callerSourceFile = ts.createSourceFile(callerFileName, `
+    import Main from ${JSON.stringify(path.resolve(fileName).replace(/\.ts$/, ''))};
+    type Input = ${JSON.stringify(input.toString('binary'))};
+    type Output = Main<Input>;
+  `, ts.ScriptTarget.Latest);
+
+  const defaultCompilerHost = ts.createCompilerHost({});
+  const customCompilerHost: ts.CompilerHost = {
+    ...defaultCompilerHost,
+    getSourceFile(fileName: string, languageVersion: ts.ScriptTarget, onError?: ((message: string) => void), shouldCreateNewSourceFile?: boolean): ts.SourceFile | undefined {
+      if (fileName === callerFileName) {
+        return callerSourceFile;
+      } else {
+        return defaultCompilerHost.getSourceFile.call(this, fileName, languageVersion, onError, shouldCreateNewSourceFile);
+      }
+    },
+  };
+
+  const program = ts.createProgram({
+    rootNames: [callerFileName],
+    options: {
+      strict: true,
+    },
+    host: customCompilerHost,
+  });
+  const checker = program.getTypeChecker();
+  const outputList: Buffer[] = [];
+
+  function visit(node: ts.Node) {
+    const symbol = checker.getSymbolAtLocation(node);
+    if (symbol && symbol.getName() === `Output`) {
+      const type = checker.getDeclaredTypeOfSymbol(symbol);
+      if (type.isStringLiteral()) {
+        outputList.push(Buffer.from(type.value));
+      } else {
+        throw new Error(`type error: ${checker.typeToString(type)}`);
+      }
+    }
+    node.forEachChild(visit);
+  }
+
+  callerSourceFile.forEachChild(visit);
+
+  return {
+    output: Buffer.concat(outputList),
+  };
+}