TypeScriptToLua · lolleko · Mar 25, 2018 · Mar 25, 2018 · Mar 25, 2018
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -600,7 +600,7 @@ export class LuaTranspiler {
                 return this.transpileExpression((node as ts.DeleteExpression).expression) + "=nil";
             case ts.SyntaxKind.FunctionExpression:
             case ts.SyntaxKind.ArrowFunction:
-                return this.transpileArrowFunction(node as ts.ArrowFunction);
+                return this.transpileFunctionExpression(node as ts.ArrowFunction);
             case ts.SyntaxKind.NewExpression:
                 return this.transpileNewExpression(node as ts.NewExpression);
             case ts.SyntaxKind.ComputedPropertyName:
@@ -1363,21 +1363,7 @@ export class LuaTranspiler {
         return "{" + properties.join(",") + "}";
     }
 
-    public transpileFunctionExpression(node: ts.FunctionExpression): string {
-        // Build parameter string
-        const paramNames: string[] = [];
-        node.parameters.forEach((param) => {
-            paramNames.push((param.name as ts.Identifier).escapedText as string);
-        });
-
-        let result = `function(${paramNames.join(",")})\n`;
-        this.pushIndent();
-        result += this.transpileBlock(node.body);
-        this.popIndent();
-        return result + this.indent + "end\n";
-    }
-
-    public transpileArrowFunction(node: ts.ArrowFunction): string {
+    public transpileFunctionExpression(node: ts.ArrowFunction): string {
         // Build parameter string
         const paramNames: string[] = [];
         node.parameters.forEach((param) => {

diff --git a/test/unit/expressions.spec.ts b/test/unit/expressions.spec.ts
@@ -128,4 +128,28 @@ export class ExpressionTests {
     public conditional(input: string, lua: string) {
         Expect(util.transpileString(input)).toBe(lua);
     }
+
+    @Test("Arrow Function Expression")
+    public arrowFunctionExpression(input: string) {
+        // Transpile
+        const lua = util.transpileString(`let add = (a, b) => a+b; return add(1,2);`);
+
+        // Execute
+        const result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(3);
+    }
+
+    @Test("Function Expression")
+    public functionExpression(input: string) {
+        // Transpile
+        const lua = util.transpileString(`let add = function(a, b) {return a+b}; return add(1,2);`);
+
+        // Execute
+        const result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(3);
+    }
 }
diff --git a/test/unit/string.spec.ts b/test/unit/string.spec.ts
@@ -21,6 +21,28 @@ export class StringTests {
         Expect(result).toBe(String.fromCharCode(...inp));
     }
 
+    @TestCase(12, 23, 43)
+    @TestCase("test", "hello", "bye")
+    @TestCase("test", 42, "bye")
+    @TestCase("test", 42, 12)
+    @Test("Template Strings")
+    public templateStrings(a: any, b: any, c: any) {
+        // Transpile
+        const a1 = typeof(a) === "string" ? "'" + a + "'" : a;
+        const b1 = typeof(b) === "string" ? "'" + b + "'" : b;
+        const c1 = typeof(c) === "string" ? "'" + c + "'" : c;
+
+        let lua = util.transpileString(
+            "let a = " + a1 + "; let b = " + b1 + "; let c = " + c1 + "; return `${a} ${b} test ${c}`;"
+        );
+
+        // Execute
+        let result = util.executeLua(lua);
+
+        // Assert
+        Expect(result).toBe(`${a} ${b} test ${c}`);
+    }
+
     @TestCase("hello test", "", "")
     @TestCase("hello test", " ", "")
     @TestCase("hello test", "hello", "")