TypeScriptToLua · Perryvw · Jul 11, 2021 · Jul 10, 2021 · Jul 10, 2021 · Jul 10, 2021
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -64,7 +64,7 @@
         "jest-circus": "^25.1.0",
         "lua-types": "^2.8.0",
         "lua-wasm-bindings": "^0.2.2",
-        "prettier": "^2.0.5",
+        "prettier": "^2.3.2",
         "ts-jest": "^26.3.0",
         "ts-node": "^8.6.2"
     }

diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts
@@ -1,13 +1,9 @@
 import * as ts from "typescript";
 import * as diagnosticFactories from "./transpilation/diagnostics";
 
-type KnownKeys<T> = { [K in keyof T]: string extends K ? never : number extends K ? never : K } extends {
-    [K in keyof T]: infer U;
-}
-    ? U
-    : never;
-
-type OmitIndexSignature<T extends Record<any, any>> = Pick<T, KnownKeys<T>>;
+type OmitIndexSignature<T> = {
+    [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K];
+};
 
 export interface TransformerImport {
     transform: string;
@@ -35,6 +31,7 @@ export type CompilerOptions = OmitIndexSignature<ts.CompilerOptions> & {
     sourceMapTraceback?: boolean;
     luaPlugins?: LuaPluginImport[];
     plugins?: Array<ts.PluginImport | TransformerImport>;
+    tstlVerbose?: boolean;
     [option: string]: any;
 };
 
@@ -73,5 +70,9 @@ export function validateOptions(options: CompilerOptions): ts.Diagnostic[] {
         diagnostics.push(diagnosticFactories.usingLuaBundleWithInlineMightGenerateDuplicateCode());
     }
 
+    if (options.luaBundle && options.buildMode === BuildMode.Library) {
+        diagnostics.push(diagnosticFactories.cannotBundleLibrary());
+    }
+
     return diagnostics;
 }
diff --git a/src/cli/parse.ts b/src/cli/parse.ts
@@ -73,6 +73,11 @@ export const optionDeclarations: CommandLineOption[] = [
         description: "List of TypeScriptToLua plugins.",
         type: "object",
     },
+    {
+        name: "tstlVerbose",
+        description: "Provide verbose output useful for diagnosing problems.",
-        description: "Provide verbose output useful for diagnosing problems.",
+        description: "Provide verbose output, useful for diagnosing problems.",
-        description: "Provide verbose output useful for diagnosing problems.",
+        description: "Provide verbose output, useful for diagnosing problems.",
+        type: "boolean",
+    },
 ];
 
 export function updateParsedConfigFile(parsedConfigFile: ts.ParsedCommandLine): ParsedCommandLine {

diff --git a/src/transformation/context/context.ts b/src/transformation/context/context.ts
@@ -27,8 +27,7 @@ export interface DiagnosticsProducingTypeChecker extends ts.TypeChecker {
 
 export class TransformationContext {
     public readonly diagnostics: ts.Diagnostic[] = [];
-    public readonly checker: DiagnosticsProducingTypeChecker = (this
-        .program as any).getDiagnosticsProducingTypeChecker();
+    public readonly checker: DiagnosticsProducingTypeChecker = this.program.getDiagnosticsProducingTypeChecker();
     public readonly resolver: EmitResolver;
 
     public readonly options: CompilerOptions = this.program.getCompilerOptions();

diff --git a/src/transpilation/diagnostics.ts b/src/transpilation/diagnostics.ts
@@ -48,3 +48,8 @@ export const usingLuaBundleWithInlineMightGenerateDuplicateCode = createSerialDi
         "Using 'luaBundle' with 'luaLibImport: \"inline\"' might generate duplicate code. " +
         "It is recommended to use 'luaLibImport: \"require\"'.",
 }));
+
+export const cannotBundleLibrary = createDiagnosticFactory(
+    () =>
+        'Cannot bundle probjects with"buildmode": "library". Projects including the library can still bundle (which will include external library files).'
+);
diff --git a/src/transpilation/resolve.ts b/src/transpilation/resolve.ts
@@ -5,9 +5,9 @@ import * as fs from "fs";
 import { EmitHost, ProcessedFile } from "./utils";
 import { SourceNode } from "source-map";
 import { getEmitPathRelativeToOutDir, getProjectRoot, getSourceDir } from "./transpiler";
-import { formatPathToLuaPath, trimExtension } from "../utils";
+import { formatPathToLuaPath, normalizeSlashes, trimExtension } from "../utils";
 import { couldNotReadDependency, couldNotResolveRequire } from "./diagnostics";
-import { BuildMode } from "../CompilerOptions";
+import { BuildMode, CompilerOptions } from "../CompilerOptions";
 
 const resolver = resolve.ResolverFactory.createResolver({
     extensions: [".lua"],
@@ -24,9 +24,14 @@ interface ResolutionResult {
 export function resolveDependencies(program: ts.Program, files: ProcessedFile[], emitHost: EmitHost): ResolutionResult {
     const outFiles: ProcessedFile[] = [...files];
     const diagnostics: ts.Diagnostic[] = [];
+    const options = program.getCompilerOptions() as CompilerOptions;
 
     // Resolve dependencies for all processed files
     for (const file of files) {
+        if (options.tstlVerbose) {
+            console.log(`Resolving dependencies for ${normalizeSlashes(file.fileName)}`);
+        }
+
         const resolutionResult = resolveFileDependencies(file, program, emitHost);
         outFiles.push(...resolutionResult.resolvedFiles);
         diagnostics.push(...resolutionResult.diagnostics);
@@ -38,6 +43,7 @@ export function resolveDependencies(program: ts.Program, files: ProcessedFile[],
 function resolveFileDependencies(file: ProcessedFile, program: ts.Program, emitHost: EmitHost): ResolutionResult {
     const dependencies: ProcessedFile[] = [];
     const diagnostics: ts.Diagnostic[] = [];
+    const options = program.getCompilerOptions() as CompilerOptions;
 
     for (const required of findRequiredPaths(file.code)) {
         // Do no resolve lualib
@@ -57,6 +63,10 @@ function resolveFileDependencies(file: ProcessedFile, program: ts.Program, emitH
         const fileDir = path.dirname(file.fileName);
         const resolvedDependency = resolveDependency(fileDir, required, program, emitHost);
         if (resolvedDependency) {
+            if (options.tstlVerbose) {
+                console.log(`Resolved ${required} to ${normalizeSlashes(resolvedDependency)}`);
+            }
+
             // Figure out resolved require path and dependency output path
             const resolvedRequire = getEmitPathRelativeToOutDir(resolvedDependency, program);
 
@@ -100,6 +110,11 @@ function resolveDependency(
     program: ts.Program,
     emitHost: EmitHost
 ): string | undefined {
+    const options = program.getCompilerOptions() as CompilerOptions;
+    if (options.tstlVerbose) {
+        console.log(`Resolving "${dependency}" from ${normalizeSlashes(fileDirectory)}`);
+    }
+
     // Check if file is a file in the project
     const resolvedPath = path.join(fileDirectory, dependency);
 

diff --git a/src/transpilation/transpile.ts b/src/transpilation/transpile.ts
@@ -27,6 +27,10 @@ export function getProgramTranspileResult(
 ): TranspileResult {
     const options = program.getCompilerOptions() as CompilerOptions;
 
+    if (options.tstlVerbose) {
+        console.log("Parsing project settings");
+    }
+
     const diagnostics = validateOptions(options);
     let transpiledFiles: ProcessedFile[] = [];
 
@@ -57,13 +61,26 @@ export function getProgramTranspileResult(
     }
 
     const plugins = getPlugins(program, diagnostics, customPlugins);
+
+    if (options.tstlVerbose) {
+        console.log(`Successfully loaded ${plugins.length} plugins`);
+    }
+
     const visitorMap = createVisitorMap(plugins.map(p => p.visitors).filter(isNonNull));
     const printer = createPrinter(plugins.map(p => p.printer).filter(isNonNull));
     const processSourceFile = (sourceFile: ts.SourceFile) => {
+        if (options.tstlVerbose) {
+            console.log(`Transforming ${sourceFile.fileName}`);
+        }
+
         const { file, diagnostics: transformDiagnostics } = transformSourceFile(program, sourceFile, visitorMap);
 
         diagnostics.push(...transformDiagnostics);
         if (!options.noEmit && !options.emitDeclarationOnly) {
+            if (options.tstlVerbose) {
+                console.log(`Printing ${sourceFile.fileName}`);
+            }
+
             const printResult = printer(program, emitHost, sourceFile.fileName, file);
             transpiledFiles.push({
                 sourceFiles: [sourceFile],

diff --git a/src/transpilation/transpiler.ts b/src/transpilation/transpiler.ts
@@ -1,6 +1,6 @@
 import * as path from "path";
 import * as ts from "typescript";
-import { isBundleEnabled } from "../CompilerOptions";
+import { CompilerOptions, isBundleEnabled } from "../CompilerOptions";
 import { getLuaLibBundle } from "../LuaLib";
 import { normalizeSlashes, trimExtension } from "../utils";
 import { getBundleResult } from "./bundle";
@@ -29,6 +29,7 @@ export class Transpiler {
 
     public emit(emitOptions: EmitOptions): EmitResult {
         const { program, writeFile = this.emitHost.writeFile } = emitOptions;
+        const verbose = (program.getCompilerOptions() as CompilerOptions).tstlVerbose;
         const { diagnostics, transpiledFiles: freshFiles } = getProgramTranspileResult(
             this.emitHost,
             writeFile,
@@ -37,15 +38,27 @@ export class Transpiler {
 
         const { emitPlan } = this.getEmitPlan(program, diagnostics, freshFiles);
 
+        if (verbose) {
+            console.log("Emitting output");
+        }
+
         const options = program.getCompilerOptions();
         const emitBOM = options.emitBOM ?? false;
         for (const { outputPath, code, sourceMap, sourceFiles } of emitPlan) {
+            if (verbose) {
+                console.log(`Emitting ${normalizeSlashes(outputPath)}`);
+            }
+
             writeFile(outputPath, code, emitBOM, undefined, sourceFiles);
             if (options.sourceMap && sourceMap !== undefined) {
                 writeFile(outputPath + ".map", sourceMap, emitBOM, undefined, sourceFiles);
             }
         }
 
+        if (verbose) {
+            console.log("Emit finished!");
+        }
+
         return { diagnostics, emitSkipped: emitPlan.length === 0 };
     }
 
@@ -54,10 +67,18 @@ export class Transpiler {
         diagnostics: ts.Diagnostic[],
         files: ProcessedFile[]
     ): { emitPlan: EmitFile[] } {
-        const options = program.getCompilerOptions();
+        const options = program.getCompilerOptions() as CompilerOptions;
+
+        if (options.tstlVerbose) {
+            console.log("Constructing emit plan");
+        }
 
         const lualibRequired = files.some(f => f.code.includes('require("lualib_bundle")'));
         if (lualibRequired) {
+            if (options.tstlVerbose) {
+                console.log("Including lualib bundle");
+            }
+
             // Add lualib bundle to source dir 'virtually', will be moved to correct output dir in emitPlan
             const fileName = normalizeSlashes(path.resolve(getSourceDir(program), "lualib_bundle.lua"));
             files.unshift({ fileName, code: getLuaLibBundle(this.emitHost) });

diff --git a/src/typescript-internal.d.ts b/src/typescript-internal.d.ts
@@ -1,3 +1,5 @@
+import { DiagnosticsProducingTypeChecker } from "./transformation/context";
+
 export {};
 
 declare module "typescript" {
@@ -14,6 +16,7 @@ declare module "typescript" {
 
     interface Program {
         getCommonSourceDirectory(): string;
+        getDiagnosticsProducingTypeChecker(): DiagnosticsProducingTypeChecker;
     }
 
     interface CompilerOptions {

diff --git a/test/cli/parse.spec.ts b/test/cli/parse.spec.ts
@@ -104,6 +104,8 @@ describe("command line", () => {
             ["noHeader", "true", { noHeader: true }],
             ["sourceMapTraceback", "false", { sourceMapTraceback: false }],
             ["sourceMapTraceback", "true", { sourceMapTraceback: true }],
+            ["tstlVerbose", "true", { tstlVerbose: true }],
+            ["tstlVerbose", "false", { tstlVerbose: false }],
 
             ["buildMode", "default", { buildMode: tstl.BuildMode.Default }],
             ["buildMode", "library", { buildMode: tstl.BuildMode.Library }],

diff --git a/test/transpile/__snapshots__/project.spec.ts.snap b/test/transpile/__snapshots__/project.spec.ts.snap
@@ -1,5 +1,25 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`should give verbose output 1`] = `
+Array [
+  "Parsing project settings",
+  "Successfully loaded 0 plugins",
+  "Transforming <cwd>/test/transpile/project/otherFile.ts",
+  "Printing <cwd>/test/transpile/project/otherFile.ts",
+  "Transforming <cwd>/test/transpile/project/index.ts",
+  "Printing <cwd>/test/transpile/project/index.ts",
+  "Constructing emit plan",
+  "Resolving dependencies for <cwd>/test/transpile/project/otherFile.ts",
+  "Resolving dependencies for <cwd>/test/transpile/project/index.ts",
+  "Resolving \\"./otherFile\\" from <cwd>/test/transpile/project",
+  "Resolved ./otherFile to <cwd>/test/transpile/project/otherFile.ts",
+  "Emitting output",
+  "Emitting <cwd>/test/transpile/project/otherFile.lua",
+  "Emitting <cwd>/test/transpile/project/index.lua",
+  "Emit finished!",
+]
+`;
+
 exports[`should transpile 1`] = `
 Array [
   Object {

diff --git a/test/transpile/module-resolution.spec.ts b/test/transpile/module-resolution.spec.ts
@@ -230,25 +230,6 @@ describe("module resolution in library mode", () => {
             expect(file.lua).not.toContain('require("lua_modules');
         }
     });
-
-    test("bundle works in library mode because no external dependencies", () => {
-        const projectPath = path.resolve(__dirname, "module-resolution", "project-with-lua-sources");
-        const mainFile = path.join(projectPath, "main.ts");
-
-        const { transpiledFiles } = util
-            .testProject(path.join(projectPath, "tsconfig.json"))
-            .setMainFileName(path.join(projectPath, "main.ts"))
-            .setOptions({ buildMode: tstl.BuildMode.Library, luaBundle: "bundle.lua", luaBundleEntry: mainFile })
-            .expectToEqual({
-                funcFromLuaFile: "lua file in subdir",
-                funcFromSubDirLuaFile: "lua file in subdir",
-            })
-            .getLuaResult();
-
-        for (const file of transpiledFiles) {
-            expect(file.lua).not.toContain('require("lua_modules');
-        }
-    });
 });
 
 describe("module resolution project with dependencies built by tstl library mode", () => {

diff --git a/test/transpile/project.spec.ts b/test/transpile/project.spec.ts
@@ -1,4 +1,5 @@
 import * as path from "path";
+import { normalizeSlashes } from "../../src/utils";
 import * as util from "../util";
 
 test("should transpile", () => {
@@ -13,3 +14,22 @@ test("should transpile", () => {
         transpiledFiles.map(f => ({ filePath: path.relative(projectDir, f.outPath), lua: f.lua }))
     ).toMatchSnapshot();
 });
+
+test("should give verbose output", () => {
+    // Capture console logs
+    const consoleLogs: string[] = [];
+    const originalLog = console.log;
+    console.log = (...args: any[]) => {
+        consoleLogs.push(args.map(a => a.toString().replace(normalizeSlashes(process.cwd()), "<cwd>")).join(","));
+    };
+
+    const projectDir = path.join(__dirname, "project");
+    util.testProject(path.join(projectDir, "tsconfig.json"))
+        .setMainFileName(path.join(projectDir, "index.ts"))
+        .setOptions({ tstlVerbose: true })
+        .expectToHaveNoDiagnostics();
+
+    console.log = originalLog;
+
+    expect(consoleLogs).toMatchSnapshot();
+});