TypeScriptToLua
diff --git a/‎src/Transpiler.ts‎
Lines changed: 6 additions & 0 deletions b/‎src/Transpiler.ts‎
Lines changed: 6 additions & 0 deletions
diff --git a/‎test/unit/expressions.spec.ts‎
Lines changed: 0 additions & 9 deletions b/‎test/unit/expressions.spec.ts‎
Lines changed: 0 additions & 9 deletions
diff --git a/‎test/unit/overloads.spec.ts‎
Lines changed: 46 additions & 5 deletions b/‎test/unit/overloads.spec.ts‎
Lines changed: 46 additions & 5 deletions
@@ -1185,6 +1185,9 @@ export abstract class LuaTranspiler {
     }
 
     public transpileFunctionDeclaration(node: ts.FunctionDeclaration): string {
+        // Don't transpile functions without body (overload declarations)
+        if (!node.body) { return ""; }
+
         let result = "";
         const identifier = node.name;
         const methodName = identifier.escapedText;
@@ -1232,6 +1235,9 @@ export abstract class LuaTranspiler {
     }
 
     public transpileMethodDeclaration(node: ts.MethodDeclaration, callPath: string): string {
+        // Don't transpile methods without body (overload declarations)
+        if (!node.body) { return ""; }
+
         let result = "";
         const identifier = node.name as ts.Identifier;
         const methodName = identifier.escapedText;
 
@@ -19,15 +19,6 @@ export class ExpressionTests {
         Expect(util.transpileString(input)).toBe(lua);
     }
 
-    @TestCase("obj instanceof someClass", "Unsupported binary operator kind: instanceof")
-    @TestCase("typeof obj", "Unsupported expression kind: TypeOfExpression")
-    @Test("Prohibted Expressions")
-    public prohibtedExpressions(input: string, expectedError: string) {
-        Expect(() => {
-            util.transpileString(input);
-        }).toThrowError(Error, expectedError);
-    }
-
     @TestCase("1+1", "1+1")
     @TestCase("1-1", "1-1")
     @TestCase("1*1", "1*1")
 
@@ -3,9 +3,8 @@ import { Expect, Test, TestCase } from "alsatian";
 import * as util from "../src/util";
 
 export class OverloadTests {
-
-    @Test("overload1")
-    public overload1() {
+    @Test("overload function1")
+    public overloadFunction1() {
         const lua = util.transpileString(
             `function abc(def: number): string;
             function abc(def: string): string;
@@ -23,8 +22,8 @@ export class OverloadTests {
         Expect(result).toBe("jkl9");
     }
 
-    @Test("overload2")
-    public overload2() {
+    @Test("overload function2")
+    public overloadFunction2() {
         const lua = util.transpileString(
             `function abc(def: number): string;
             function abc(def: string): string;
@@ -41,4 +40,46 @@ export class OverloadTests {
 
         Expect(result).toBe("ghj");
     }
+
+    @Test("overload method1")
+    public overloadMethod1() {
+        const lua = util.transpileString(
+            `class myclass {
+                static abc(def: number): string;
+                static abc(def: string): string;
+                static abc(def: number | string): string {
+                    if (typeof def == "number") {
+                        return "jkl" + (def * 3);
+                    } else {
+                        return def;
+                    }
+                }
+            }
+            return myclass.abc(3);`);
+
+        const result = util.executeLua(lua);
+
+        Expect(result).toBe("jkl9");
+    }
+
+    @Test("overload method2")
+    public overloadMethod2() {
+        const lua = util.transpileString(
+            `class myclass {
+                static abc(def: number): string;
+                static abc(def: string): string;
+                static abc(def: number | string): string {
+                    if (typeof def == "number") {
+                        return "jkl" + (def * 3);
+                    } else {
+                        return def;
+                    }
+                }
+            }
+            return myclass.abc("ghj");`);
+
+        const result = util.executeLua(lua);
+
+        Expect(result).toBe("ghj");
+    }
 }