TypeScriptToLua · Perryvw · May 10, 2018 · May 10, 2018 · May 10, 2018 · May 10, 2018
diff --git a/src/CommandLineParser.ts b/src/CommandLineParser.ts
@@ -136,7 +136,7 @@ function runDiagnostics(commandLine: ts.ParsedCommandLine) {
             }
         }
 
-        commandLine.errors.forEach((err) => {
+        commandLine.errors.forEach(err => {
             let ignore = false;
             // Ignore errors caused by tstl specific compiler options
             if (err.code === tsInvalidCompilerOptionErrorCode) {

diff --git a/src/Compiler.ts b/src/Compiler.ts
@@ -13,8 +13,8 @@ export function compile(fileNames: string[], options: CompilerOptions): void {
     const checker = program.getTypeChecker();
 
     // Get all diagnostics, ignore unsupported extension
-    const diagnostics = ts.getPreEmitDiagnostics(program).filter((diag) => diag.code !== 6054);
-    diagnostics.forEach((diagnostic) => {
+    const diagnostics = ts.getPreEmitDiagnostics(program).filter(diag => diag.code !== 6054);
+    diagnostics.forEach(diagnostic => {
         if (diagnostic.file) {
             const { line, character } =
                 diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start!);
@@ -30,12 +30,12 @@ export function compile(fileNames: string[], options: CompilerOptions): void {
     });
 
     // If there are errors dont emit
-    if (diagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error).length > 0) {
+    if (diagnostics.filter(diag => diag.category === ts.DiagnosticCategory.Error).length > 0) {
         console.log("Stopping compilation process because of errors.");
         process.exit(1);
     }
 
-    program.getSourceFiles().forEach((sourceFile) => {
+    program.getSourceFiles().forEach(sourceFile => {
         if (!sourceFile.isDeclarationFile) {
             try {
                 const rootDir = options.rootDir;

diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -24,14 +24,14 @@ export class TSHelper {
     }
 
     public static containsStatement(statements: ts.NodeArray<ts.Statement>, kind: ts.SyntaxKind): boolean {
-        return statements.some((statement) => statement.kind === kind);
+        return statements.some(statement => statement.kind === kind);
     }
 
     public static isFileModule(sourceFile: ts.SourceFile) {
         if (sourceFile) {
             // Vanilla ts flags files as external module if they have an import or
             // export statement, we only check for export statements
-            return sourceFile.statements.some((statement) =>
+            return sourceFile.statements.some(statement =>
                 (ts.getCombinedModifierFlags(statement) & ts.ModifierFlags.Export) !== 0
                 || statement.kind === ts.SyntaxKind.ExportAssignment
                 || statement.kind === ts.SyntaxKind.ExportDeclaration);
@@ -88,9 +88,11 @@ export class TSHelper {
 
     public static hasCustomDecorator(type: ts.Type, checker: ts.TypeChecker, decorator: string): boolean {
         if (type.symbol) {
-            const comment = type.symbol.getDocumentationComment(checker);
+            const comments = type.symbol.getDocumentationComment(checker);
             const decorators =
-                comment.filter((_) => _.kind === "text").map((_) => _.text.trim()).filter((_) => _[0] === "!");
+                comments.filter(comment => comment.kind === "text")
+                .map(comment => comment.text.trim())
+                .filter(comment => comment[0] === "!");
             return decorators.indexOf(decorator) > -1;
         }
         return false;

diff --git a/src/Transpiler.ts b/src/Transpiler.ts
diff --git a/test/translation/lua/classConstructorAssignment.lua b/test/translation/lua/classConstructorAssignment.lua
@@ -0,0 +1,10 @@
+Test = Test or {}
+Test.__index = Test
+function Test.new(construct, ...)
+    local instance = setmetatable({}, Test)
+    if construct and Test.constructor then Test.constructor(instance, ...) end
+    return instance
+end
+function Test.constructor(self,field)
+    self.field = field
+end
diff --git a/test/translation/lua/enumMembersOnly.lua b/test/translation/lua/enumMembersOnly.lua
@@ -1,3 +1,4 @@
 val1=0
 val2=2
-val3=3
+val3=3
+local a = val1
diff --git a/test/translation/lua/returnDefault.lua b/test/translation/lua/returnDefault.lua
@@ -0,0 +1,3 @@
+function myFunc()
+    return
+end
diff --git a/test/translation/ts/classConstructorAssignment.ts b/test/translation/ts/classConstructorAssignment.ts
@@ -0,0 +1,3 @@
+class Test {
+    constructor(private field: number) {}
+}
diff --git a/test/translation/ts/enumMembersOnly.ts b/test/translation/ts/enumMembersOnly.ts
@@ -3,4 +3,6 @@ enum TestEnum {
     val1 = 0,
     val2 = 2,
     val3
-}
+}
+
+const a = TestEnum.val1;
diff --git a/test/translation/ts/returnDefault.ts b/test/translation/ts/returnDefault.ts
@@ -0,0 +1,3 @@
+function myFunc() {
+    return;
+}
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -1,4 +1,5 @@
-import { Expect, Test, TestCase } from "alsatian";
+import { Expect, Test, TestCase, FocusTest } from "alsatian";
+import { TranspileError } from "../../src/Transpiler";
 
 import * as util from "../src/util";
 const fs = require("fs");
@@ -13,7 +14,7 @@ export class AssignmentTests {
     @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
     @Test("Const assignment")
     public constAssignment(inp: string, out: string) {
-        var lua = util.transpileString(`const myvar = ${inp};`)
+        const lua = util.transpileString(`const myvar = ${inp};`);
         Expect(lua).toBe(`local myvar = ${out}`);
     }
 
@@ -25,7 +26,7 @@ export class AssignmentTests {
     @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
     @Test("Const assignment")
     public letAssignment(inp: string, out: string) {
-        var lua = util.transpileString(`let myvar = ${inp};`)
+        const lua = util.transpileString(`let myvar = ${inp};`);
         Expect(lua).toBe(`local myvar = ${out}`);
     }
 
@@ -37,7 +38,39 @@ export class AssignmentTests {
     @TestCase(`{a:3,b:"4"}`, `{a = 3,b = "4"}`)
     @Test("Const assignment")
     public varAssignment(inp: string, out: string) {
-        var lua = util.transpileString(`var myvar = ${inp};`)
+        const lua = util.transpileString(`var myvar = ${inp};`);
         Expect(lua).toBe(`local myvar = ${out}`);
     }
+
+    @TestCase("var myvar;")
+    @TestCase("let myvar;")
+    @TestCase("const myvar;")
+    @TestCase("const myvar = null;")
+    @TestCase("const myvar = undefined;")
+    @Test("Null assignments")
+    public nullAssignment(declaration: string) {
+        const lua = util.transpileString(declaration + " return myvar;");
+        const result = util.executeLua(lua);
+        Expect(result).toBe(undefined);
+    }
+
+    @TestCase(["a", "b"], ["e", "f"])
+    @TestCase(["a", "b"], ["e", "f", "g"])
+    @TestCase(["a", "b", "c"], ["e", "f", "g"])
+    @Test("Binding pattern assignment")
+    public bindingPattern(input: string[], values: string[]) {
+        const pattern = input.join(",");
+        const initializer = values.map(v => `"${v}"`).join(",");
+
+        const lua = util.transpileString(`const [${pattern}] = [${initializer}]; return [${pattern}].join("-");`);
+        const result = util.executeLua(lua);
+
+        Expect(result).toBe(values.slice(0, input.length).join("-"));
+    }
+
+    @Test("Ellipsis binding pattern")
+    public ellipsisBindingPattern() {
+        Expect(() => util.transpileString("let [a,b,...c] = [1,2,3];"))
+            .toThrowError(Error, "Ellipsis destruction is not allowed.");
+    }
 }
diff --git a/test/unit/error.spec.ts b/test/unit/error.spec.ts
@@ -6,7 +6,7 @@ export class LuaErrorTests {
     @Test("throwString")
     public trowString() {
         // Transpile
-        let lua = util.transpileString(
+        const lua = util.transpileString(
             `throw "Some Error"`
         );
         // Assert
@@ -17,7 +17,7 @@ export class LuaErrorTests {
     public throwError() {
         // Transpile & Asser
         Expect(() => {
-            let lua = util.transpileString(
+            const lua = util.transpileString(
                 `throw Error("Some Error")`
             );
         }).toThrowError(Error, "Unsupported throw expression, only string literals are supported");

diff --git a/test/unit/expressions.spec.ts b/test/unit/expressions.spec.ts
@@ -1,4 +1,4 @@
-import { Expect, Test, TestCase, FocusTest } from "alsatian";
+import { Expect, Test, TestCase } from "alsatian";
 import { LuaTarget } from "../../src/Transpiler";
 
 import * as ts from "typescript";
@@ -175,6 +175,16 @@ export class ExpressionTests {
         Expect(result).toBe(3);
     }
 
+    @Test("Null Expression")
+    public nullExpression() {
+        Expect(util.transpileString("null")).toBe("nil");
+    }
+
+    @Test("Undefined Expression")
+    public undefinedExpression() {
+        Expect(util.transpileString("undefined")).toBe("nil");
+    }
+
     @TestCase([], 7)
     @TestCase([5], 9)
     @TestCase([1, 2], 3)
@@ -230,6 +240,7 @@ export class ExpressionTests {
     }
 
     @TestCase("= 4", 4 + 4)
+    @TestCase("-= 3", 4 - 3 + 4)
     @TestCase("+= 3", 4 + 3 + 4)
     @TestCase("*= 3", 4 * 3 + 4)
     @TestCase("/= 3", 4 / 3 + 4)