TypeScriptToLua · Perryvw · Mar 15, 2020 · Dec 9, 2019 · Dec 9, 2019 · Dec 9, 2019
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -52,6 +52,35 @@
 
   This change simplifies our codebase and opens a path to object accessors implementation
 
+- Errors reported during transpilation now are created as TypeScript diagnostics, instead of being thrown as JavaScript errors. This makes TypeScriptToLua always try to generate valid code (even in presence of errors) and allows multiple errors to be reported in a single file:
+
+  <!-- prettier-ignore -->
+  ```ts
+  for (var x in []) {}
+  ```
+
+  ```shell
+  # Before
+
+  $ tstl file.ts
+  file.ts:1:1 - error TSTL: Iterating over arrays with 'for ... in' is not allowed.
+
+  $ cat file.lua
+  error("Iterating over arrays with 'for ... in' is not allowed.")
+  ```
+
+  ```shell
+  # Now
+
+  $ tstl file.ts
+  file.ts:1:1 - error TSTL: Iterating over arrays with 'for ... in' is not allowed.
+  file.ts:1:6 - error TSTL: `var` declarations are not supported. Use `let` or `const` instead.
+
+  $ cat file.lua
+  for x in pairs({}) do
+  end
+  ```
+
 ## 0.31.0
 
 - **Breaking:** The old annotation syntax (`/* !varArg */`) **no longer works**, the only currently supported syntax is:

diff --git a/src/CompilerOptions.ts b/src/CompilerOptions.ts
@@ -1,4 +1,5 @@
 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 {
     [_ in keyof T]: infer U;
@@ -47,37 +48,12 @@ export function validateOptions(options: CompilerOptions): ts.Diagnostic[] {
     const diagnostics: ts.Diagnostic[] = [];
 
     if (options.luaBundle && !options.luaBundleEntry) {
-        diagnostics.push(configErrorDiagnostic(`'luaBundleEntry' is required when 'luaBundle' is enabled.`));
+        diagnostics.push(diagnosticFactories.luaBundleEntryIsRequired());
     }
 
     if (options.luaBundle && options.luaLibImport === LuaLibImportKind.Inline) {
-        diagnostics.push(
-            configWarningDiagnostic(
-                `Using 'luaBundle' with 'luaLibImport: "inline"' might generate duplicate code. ` +
-                    `It is recommended to use 'luaLibImport: "require"'`
-            )
-        );
+        diagnostics.push(diagnosticFactories.usingLuaBundleWithInlineMightGenerateDuplicateCode());
     }
 
     return diagnostics;
 }
-
-const configErrorDiagnostic = (message: string): ts.Diagnostic => ({
-    file: undefined,
-    start: undefined,
-    length: undefined,
-    category: ts.DiagnosticCategory.Error,
-    code: 0,
-    source: "typescript-to-lua",
-    messageText: message,
-});
-
-const configWarningDiagnostic = (message: string): ts.Diagnostic => ({
-    file: undefined,
-    start: undefined,
-    length: undefined,
-    category: ts.DiagnosticCategory.Warning,
-    code: 0,
-    source: "typescript-to-lua",
-    messageText: message,
-});
diff --git a/src/LuaPrinter.ts b/src/LuaPrinter.ts
@@ -4,7 +4,7 @@ import * as ts from "typescript";
 import { CompilerOptions, LuaLibImportKind } from "./CompilerOptions";
 import * as lua from "./LuaAST";
 import { loadLuaLibFeatures, LuaLibFeature } from "./LuaLib";
-import { isValidLuaIdentifier, luaKeywords } from "./transformation/utils/safe-names";
+import { isValidLuaIdentifier } from "./transformation/utils/safe-names";
 import { EmitHost } from "./transpilation";
 import { trimExtension } from "./utils";
 
@@ -660,11 +660,7 @@ export class LuaPrinter {
         const value = this.printExpression(expression.value);
 
         if (expression.key) {
-            if (
-                lua.isStringLiteral(expression.key) &&
-                isValidLuaIdentifier(expression.key.value) &&
-                !luaKeywords.has(expression.key.value)
-            ) {
+            if (lua.isStringLiteral(expression.key) && isValidLuaIdentifier(expression.key.value)) {
                 chunks.push(expression.key.value, " = ", value);
             } else {
                 chunks.push("[", this.printExpression(expression.key), "] = ", value);
@@ -761,11 +757,7 @@ export class LuaPrinter {
         const chunks: SourceChunk[] = [];
 
         chunks.push(this.printExpressionInParenthesesIfNeeded(expression.table));
-        if (
-            lua.isStringLiteral(expression.index) &&
-            isValidLuaIdentifier(expression.index.value) &&
-            !luaKeywords.has(expression.index.value)
-        ) {
+        if (lua.isStringLiteral(expression.index) && isValidLuaIdentifier(expression.index.value)) {
             chunks.push(".", this.createSourceNode(expression.index, expression.index.value));
         } else {
             chunks.push("[", this.printExpression(expression.index), "]");

diff --git a/src/cli/diagnostics.ts b/src/cli/diagnostics.ts
@@ -1,16 +1,12 @@
 import * as ts from "typescript";
+import { createSerialDiagnosticFactory, createDiagnosticFactoryWithCode } from "../utils";
 
-export const tstlOptionsAreMovingToTheTstlObject = (tstl: Record<string, any>): ts.Diagnostic => ({
-    file: undefined,
-    start: undefined,
-    length: undefined,
+export const tstlOptionsAreMovingToTheTstlObject = createSerialDiagnosticFactory((tstl: Record<string, any>) => ({
     category: ts.DiagnosticCategory.Warning,
-    code: 0,
-    source: "typescript-to-lua",
     messageText:
         'TSTL options are moving to the "tstl" object. Adjust your tsconfig to look like\n' +
         `"tstl": ${JSON.stringify(tstl, undefined, 4)}`,
-});
+}));
 
 export const watchErrorSummary = (errorCount: number): ts.Diagnostic => ({
     file: undefined,
@@ -24,16 +20,8 @@ export const watchErrorSummary = (errorCount: number): ts.Diagnostic => ({
             : `Found ${errorCount} errors. Watching for file changes.`,
 });
 
-const createCommandLineError = <Args extends any[]>(code: number, getMessage: (...args: Args) => string) => (
-    ...args: Args
-): ts.Diagnostic => ({
-    file: undefined,
-    start: undefined,
-    length: undefined,
-    category: ts.DiagnosticCategory.Error,
-    code,
-    messageText: getMessage(...args),
-});
+const createCommandLineError = <TArgs extends any[]>(code: number, getMessage: (...args: TArgs) => string) =>
+    createDiagnosticFactoryWithCode(code, (...args: TArgs) => ({ messageText: getMessage(...args) }));
 
 export const unknownCompilerOption = createCommandLineError(
     5023,

diff --git a/src/cli/report.ts b/src/cli/report.ts
@@ -1,12 +1,9 @@
 import * as ts from "typescript";
 
+export const prepareDiagnosticForFormatting = (diagnostic: ts.Diagnostic) =>
+    diagnostic.source === "typescript-to-lua" ? { ...diagnostic, code: "TL" as any } : diagnostic;
+
 export function createDiagnosticReporter(pretty: boolean, system = ts.sys): ts.DiagnosticReporter {
     const reporter = ts.createDiagnosticReporter(system, pretty);
-    return diagnostic => {
-        if (diagnostic.source === "typescript-to-lua") {
-            diagnostic = { ...diagnostic, code: ("TL" + diagnostic.code) as any };
-        }
-
-        reporter(diagnostic);
-    };
+    return diagnostic => reporter(prepareDiagnosticForFormatting(diagnostic));
 }
diff --git a/src/index.ts b/src/index.ts
@@ -6,5 +6,4 @@ export * from "./LuaAST";
 export { LuaLibFeature } from "./LuaLib";
 export * from "./LuaPrinter";
 export * from "./transformation/context";
-export { TranspileError } from "./transformation/utils/errors";
 export * from "./transpilation";
diff --git a/src/transformation/builtins/array.ts b/src/transformation/builtins/array.ts
@@ -1,14 +1,14 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { UnsupportedProperty } from "../utils/errors";
+import { unsupportedProperty } from "../utils/diagnostics";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { PropertyCallExpression, transformArguments } from "../visitors/call";
 
 export function transformArrayPrototypeCall(
     context: TransformationContext,
     node: PropertyCallExpression
-): lua.CallExpression {
+): lua.CallExpression | undefined {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
     const params = transformArguments(context, node.arguments, signature);
@@ -79,7 +79,7 @@ export function transformArrayPrototypeCall(
         case "flatMap":
             return transformLuaLibFunction(context, LuaLibFeature.ArrayFlatMap, node, caller, ...params);
         default:
-            throw UnsupportedProperty("array", expressionName, node);
+            context.diagnostics.push(unsupportedProperty(expression.name, "array", expressionName));
     }
 }
 

diff --git a/src/transformation/builtins/console.ts b/src/transformation/builtins/console.ts
@@ -1,15 +1,15 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { UnsupportedProperty } from "../utils/errors";
+import { unsupportedProperty } from "../utils/diagnostics";
 import { PropertyCallExpression, transformArguments } from "../visitors/call";
 
 const isStringFormatTemplate = (node: ts.Expression) => ts.isStringLiteral(node) && node.text.includes("%");
 
 export function transformConsoleCall(
     context: TransformationContext,
     expression: PropertyCallExpression
-): lua.Expression {
+): lua.Expression | undefined {
     const method = expression.expression;
     const methodName = method.name.text;
     const signature = context.checker.getResolvedSignature(expression);
@@ -61,6 +61,6 @@ export function transformConsoleCall(
             );
             return lua.createCallExpression(lua.createIdentifier("print"), [debugTracebackCall]);
         default:
-            throw UnsupportedProperty("console", methodName, expression);
+            context.diagnostics.push(unsupportedProperty(method.name, "console", methodName));
     }
 }
diff --git a/src/transformation/builtins/function.ts b/src/transformation/builtins/function.ts
@@ -1,18 +1,18 @@
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { UnsupportedProperty, UnsupportedSelfFunctionConversion } from "../utils/errors";
+import { unsupportedProperty, unsupportedSelfFunctionConversion } from "../utils/diagnostics";
 import { ContextType, getFunctionContextType } from "../utils/function-context";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { PropertyCallExpression, transformArguments } from "../visitors/call";
 
 export function transformFunctionPrototypeCall(
     context: TransformationContext,
     node: PropertyCallExpression
-): lua.CallExpression {
+): lua.CallExpression | undefined {
     const expression = node.expression;
     const callerType = context.checker.getTypeAtLocation(expression.expression);
     if (getFunctionContextType(context, callerType) === ContextType.Void) {
-        throw UnsupportedSelfFunctionConversion(node);
+        context.diagnostics.push(unsupportedSelfFunctionConversion(node));
     }
 
     const signature = context.checker.getResolvedSignature(node);
@@ -27,6 +27,6 @@ export function transformFunctionPrototypeCall(
         case "call":
             return transformLuaLibFunction(context, LuaLibFeature.FunctionCall, node, caller, ...params);
         default:
-            throw UnsupportedProperty("function", expressionName, node);
+            context.diagnostics.push(unsupportedProperty(expression.name, "function", expressionName));
     }
 }
diff --git a/src/transformation/builtins/index.ts b/src/transformation/builtins/index.ts
@@ -28,24 +28,22 @@ export function transformBuiltinPropertyAccessExpression(
     context: TransformationContext,
     node: ts.PropertyAccessExpression
 ): lua.Expression | undefined {
-    const type = context.checker.getTypeAtLocation(node.expression);
-    if (isStringType(context, type)) {
+    const ownerType = context.checker.getTypeAtLocation(node.expression);
+
+    if (isStringType(context, ownerType)) {
         return transformStringProperty(context, node);
-    } else if (isArrayType(context, type)) {
-        const arrayPropertyAccess = transformArrayProperty(context, node);
-        if (arrayPropertyAccess) {
-            return arrayPropertyAccess;
-        }
     }
 
-    if (ts.isIdentifier(node.expression)) {
-        const ownerType = context.checker.getTypeAtLocation(node.expression);
+    if (isArrayType(context, ownerType)) {
+        return transformArrayProperty(context, node);
+    }
 
-        if (isStandardLibraryType(context, ownerType, "Math")) {
-            return transformMathProperty(node);
-        } else if (isStandardLibraryType(context, ownerType, "Symbol")) {
-            // Pull in Symbol lib
-            importLuaLibFeature(context, LuaLibFeature.Symbol);
+    if (ts.isIdentifier(node.expression) && isStandardLibraryType(context, ownerType, undefined)) {
+        switch (node.expression.text) {
+            case "Math":
+                return transformMathProperty(context, node);
+            case "Symbol":
+                importLuaLibFeature(context, LuaLibFeature.Symbol);
         }
     }
 }

diff --git a/src/transformation/builtins/math.ts b/src/transformation/builtins/math.ts
@@ -2,10 +2,13 @@ import * as ts from "typescript";
 import * as lua from "../../LuaAST";
 import { LuaTarget } from "../../CompilerOptions";
 import { TransformationContext } from "../context";
-import { UnsupportedProperty } from "../utils/errors";
+import { unsupportedProperty } from "../utils/diagnostics";
 import { PropertyCallExpression, transformArguments } from "../visitors/call";
 
-export function transformMathProperty(node: ts.PropertyAccessExpression): lua.Expression {
+export function transformMathProperty(
+    context: TransformationContext,
+    node: ts.PropertyAccessExpression
+): lua.Expression | undefined {
     const name = node.name.text;
     switch (name) {
         case "PI":
@@ -23,11 +26,14 @@ export function transformMathProperty(node: ts.PropertyAccessExpression): lua.Ex
             return lua.createNumericLiteral(Math[name], node);
 
         default:
-            throw UnsupportedProperty("Math", name, node);
+            context.diagnostics.push(unsupportedProperty(node.name, "Math", name));
     }
 }
 
-export function transformMathCall(context: TransformationContext, node: PropertyCallExpression): lua.Expression {
+export function transformMathCall(
+    context: TransformationContext,
+    node: PropertyCallExpression
+): lua.Expression | undefined {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
     const params = transformArguments(context, node.arguments, signature);
@@ -93,6 +99,6 @@ export function transformMathCall(context: TransformationContext, node: Property
         }
 
         default:
-            throw UnsupportedProperty("Math", expressionName, expression);
+            context.diagnostics.push(unsupportedProperty(expression.name, "Math", expressionName));
     }
 }
diff --git a/src/transformation/builtins/number.ts b/src/transformation/builtins/number.ts
@@ -1,13 +1,13 @@
 import * as lua from "../../LuaAST";
 import { TransformationContext } from "../context";
-import { UnsupportedProperty } from "../utils/errors";
+import { unsupportedProperty } from "../utils/diagnostics";
 import { LuaLibFeature, transformLuaLibFunction } from "../utils/lualib";
 import { PropertyCallExpression, transformArguments } from "../visitors/call";
 
 export function transformNumberPrototypeCall(
     context: TransformationContext,
     node: PropertyCallExpression
-): lua.Expression {
+): lua.Expression | undefined {
     const expression = node.expression;
     const signature = context.checker.getResolvedSignature(node);
     const params = transformArguments(context, node.arguments, signature);
@@ -20,14 +20,14 @@ export function transformNumberPrototypeCall(
                 ? lua.createCallExpression(lua.createIdentifier("tostring"), [caller], node)
                 : transformLuaLibFunction(context, LuaLibFeature.NumberToString, node, caller, ...params);
         default:
-            throw UnsupportedProperty("number", expressionName, node);
+            context.diagnostics.push(unsupportedProperty(expression.name, "number", expressionName));
     }
 }
 
 export function transformNumberConstructorCall(
     context: TransformationContext,
     expression: PropertyCallExpression
-): lua.CallExpression {
+): lua.CallExpression | undefined {
     const method = expression.expression;
     const parameters = transformArguments(context, expression.arguments);
     const methodName = method.name.text;
@@ -37,6 +37,6 @@ export function transformNumberConstructorCall(
         case "isFinite":
             return transformLuaLibFunction(context, LuaLibFeature.NumberIsFinite, expression, ...parameters);
         default:
-            throw UnsupportedProperty("Number", methodName, expression);
+            context.diagnostics.push(unsupportedProperty(method.name, "Number", methodName));
     }
 }