New emit pipeline and API/CLI refactor

build_lualib.ts

@@ -1,31 +1,29 @@
 import * as fs from "fs";
 import * as glob from "glob";
-import { compile } from "./src/Compiler";
-import { LuaLib as luaLib, LuaLibFeature } from "./src/LuaLib";
+import * as path from "path";
+import * as tstl from "./src";
+import { LuaLib } from "./src/LuaLib";
 
-const bundlePath = "./dist/lualib/lualib_bundle.lua";
+const options: tstl.CompilerOptions = {
+    skipLibCheck: true,
+    types: [],
+    luaLibImport: tstl.LuaLibImportKind.None,
+    luaTarget: tstl.LuaTarget.Lua51,
+    noHeader: true,
+    outDir: path.join(__dirname, "./dist/lualib"),
+    rootDir: path.join(__dirname, "./src/lualib"),
+};
 
-compile([
-    "--skipLibCheck",
-    "--types",
-    "node",
-    "--luaLibImport",
-    "none",
-    "--luaTarget",
-    "5.1",
-    "--noHeader",
-    "--outDir",
-    "./dist/lualib",
-    "--rootDir",
-    "./src/lualib",
-    "--noHeader",
-    "true",
-    ...glob.sync("./src/lualib/**/*.ts"),
-]);
+// TODO: Check diagnostics
+const { transpiledFiles } = tstl.transpileFiles(glob.sync("./src/lualib/**/*.ts"), options);
+tstl.emitTranspiledFiles(options, transpiledFiles);
 
+const bundlePath = path.join(__dirname, "./dist/lualib/lualib_bundle.lua");
 if (fs.existsSync(bundlePath)) {
     fs.unlinkSync(bundlePath);
 }
 
-const bundle = luaLib.loadFeatures(Object.keys(LuaLibFeature).map(lib => LuaLibFeature[lib]));
-fs.writeFileSync(bundlePath, bundle);
+fs.writeFileSync(
+    bundlePath,
+    LuaLib.loadFeatures(Object.keys(tstl.LuaLibFeature).map(lib => tstl.LuaLibFeature[lib])),
+);

jest.config.js

@@ -3,7 +3,12 @@ const isCI = require("is-ci");
 /** @type {Partial<import("@jest/types").Config.DefaultOptions>} */
 module.exports = {
     testMatch: ["**/test/**/*.spec.ts"],
-    collectCoverageFrom: ["<rootDir>/src/**/*", "!<rootDir>/src/lualib/**/*"],
+    collectCoverageFrom: [
+        "<rootDir>/src/**/*",
+        "!<rootDir>/src/lualib/**/*",
+        // https://github.com/facebook/jest/issues/5274
+        "!<rootDir>/src/tstl.ts",
+    ],
     watchPathIgnorePatterns: ["/watch\\.ts$"],
 
     testEnvironment: "node",

package.json

@@ -45,7 +45,7 @@
     "devDependencies": {
         "@types/glob": "^5.0.35",
         "@types/jest": "^24.0.11",
-        "@types/node": "^9.6.23",
+        "@types/node": "^11.13.0",
         "fengari": "^0.1.2",
         "glob": "^7.1.2",
         "jest": "^24.5.0",

src/CommandLineParser.ts

@@ -13,7 +13,7 @@ type ArgumentParseResult<T> =
     { isValid: true; result: T; increment?: number }
     | { isValid: false, errorMessage: string };
 
-interface ParsedCommandLine extends ts.ParsedCommandLine {
+export interface ParsedCommandLine extends ts.ParsedCommandLine {
     options: CompilerOptions;
 }
 
@@ -161,19 +161,13 @@ function readTsConfig(parsedCommandLine: ts.ParsedCommandLine): CLIParseResult
         }
 
         const configPath = options.project;
-        const parsedJsonConfig = parseTsConfigFile(configPath, options);
-
-        return parsedJsonConfig;
+        const configContent = fs.readFileSync(configPath, "utf8");
+        return parseConfigFileContent(configContent, configPath, options);
     }
     return { isValid: true, result: parsedCommandLine };
 }
 
-export function parseTsConfigFile(filePath: string, existingOptions?: ts.CompilerOptions): CLIParseResult {
-    const configContents = fs.readFileSync(filePath).toString();
-    return parseTsConfigString(configContents, filePath, existingOptions);
-}
-
-export function parseTsConfigString(
+export function parseConfigFileContent(
     tsConfigString: string,
     configPath: string,
     existingOptions?: ts.CompilerOptions
@@ -183,7 +177,8 @@ export function parseTsConfigString(
         configJson.config,
         ts.sys,
         path.dirname(configPath),
-        existingOptions
+        existingOptions,
+        configPath
     );
 
     for (const key in parsedJsonConfig.raw) {

src/Emit.ts

@@ -0,0 +1,65 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as ts from "typescript";
+import { CompilerOptions, LuaLibImportKind } from "./CompilerOptions";
+import { TranspiledFile } from "./Transpile";
+
+const trimExt = (filePath: string) =>
+    path.join(path.dirname(filePath), path.basename(filePath, path.extname(filePath)));
+
+let lualibContent: string;
+export function emitTranspiledFiles(
+    options: CompilerOptions,
+    transpiledFiles: Map<string, TranspiledFile>,
+    writeFile = ts.sys.writeFile
+): void {
+    const { rootDir, outDir, outFile, luaLibImport } = options;
+
+    for (const [fileName, { lua, sourceMap, declaration, declarationMap }] of transpiledFiles) {
+        let outPath = fileName;
+        if (outDir !== rootDir) {
+            const relativeSourcePath = path.resolve(fileName).replace(path.resolve(rootDir), "");
+            outPath = path.join(outDir, relativeSourcePath);
+        }
+
+        // change extension or rename to outFile
+        if (outFile) {
+            if (path.isAbsolute(outFile)) {
+                outPath = outFile;
+            } else {
+                // append to workingDir or outDir
+                outPath = path.resolve(options.outDir, outFile);
+            }
+        } else {
+            outPath = trimExt(outPath) + ".lua";
+        }
+
+        if (lua !== undefined) {
+            writeFile(outPath, lua);
+        }
+
+        if (sourceMap !== undefined && options.sourceMap) {
+            writeFile(outPath + ".map", sourceMap);
+        }
+
+        if (declaration !== undefined) {
+            writeFile(trimExt(outPath) + ".d.ts", declaration);
+        }
+
+        if (declarationMap !== undefined) {
+            writeFile(trimExt(outPath) + ".d.ts.map", declarationMap);
+        }
+    }
+
+    if (luaLibImport === LuaLibImportKind.Require || luaLibImport === LuaLibImportKind.Always) {
+        if (lualibContent === undefined) {
+            lualibContent = fs.readFileSync(
+                path.resolve(__dirname, "../dist/lualib/lualib_bundle.lua"),
+                "utf8"
+            );
+        }
+
+        const outPath = path.join(outDir, "lualib_bundle.lua");
+        writeFile(outPath, lualibContent);
+    }
+}