TypeScriptToLua · Perryvw · Dec 15, 2018 · Oct 25, 2018 · Oct 25, 2018 · Oct 25, 2018
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -117,9 +117,9 @@ export class TSHelper {
     }
 
     public static getContainingFunctionReturnType(node: ts.Node, checker: ts.TypeChecker): ts.Type {
-        const declaration = this.findFirstNodeAbove(node, (n): n is ts.Node => ts.isFunctionLike(n));
+        const declaration = this.findFirstNodeAbove(node, ts.isFunctionLike);
         if (declaration) {
-            const signature = checker.getSignatureFromDeclaration(declaration as ts.SignatureDeclaration);
+            const signature = checker.getSignatureFromDeclaration(declaration);
             return checker.getReturnTypeOfSignature(signature);
         }
         return null;
@@ -320,7 +320,8 @@ export class TSHelper {
             return ContextType.NonVoid;
         }
         if ((ts.isPropertySignature(signatureDeclaration.parent)
-             || ts.isPropertyDeclaration(signatureDeclaration.parent))
+             || ts.isPropertyDeclaration(signatureDeclaration.parent)
+             || ts.isPropertyAssignment(signatureDeclaration.parent))
             && !(ts.getCombinedModifierFlags(signatureDeclaration.parent) & ts.ModifierFlags.Static)) {
             // Non-static lambda property
             return ContextType.NonVoid;
@@ -332,18 +333,35 @@ export class TSHelper {
         return ContextType.Void;
     }
 
+    public static reduceContextTypes(contexts: ContextType[]): ContextType {
+        const reducer = (a: ContextType, b: ContextType) => {
+            if (a === ContextType.None) {
+                return b;
+            } else if (b === ContextType.None) {
+                return a;
+            } else if (a !== b) {
+                return ContextType.Mixed;
+            } else {
+                return a;
+            }
+        };
+        return contexts.reduce(reducer, ContextType.None);
+    }
+
     public static getFunctionContextType(type: ts.Type, checker: ts.TypeChecker): ContextType {
+        if (type.isTypeParameter()) {
+            type = type.getConstraint() || type;
+        }
+
+        if (type.isUnion()) {
+            return this.reduceContextTypes(type.types.map(t => this.getFunctionContextType(t, checker)));
+        }
+
         const signatures = checker.getSignaturesOfType(type, ts.SignatureKind.Call);
         if (signatures.length === 0) {
             return ContextType.None;
         }
         const signatureDeclarations = this.getSignatureDeclarations(signatures, checker);
-        const context = this.getDeclarationContextType(signatureDeclarations[0], checker);
-        for (let i = 1; i < signatureDeclarations.length; ++i) {
-            if (this.getDeclarationContextType(signatureDeclarations[i], checker) !== context) {
-                return ContextType.Mixed;
-            }
-        }
-        return context;
+        return this.reduceContextTypes(signatureDeclarations.map(s => this.getDeclarationContextType(s, checker)));
     }
 }
diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -800,7 +800,7 @@ export abstract class LuaTranspiler {
             case ts.SyntaxKind.FunctionExpression:
                 return this.transpileFunctionExpression(node as ts.ArrowFunction, "self");
             case ts.SyntaxKind.ArrowFunction:
-                return this.transpileFunctionExpression(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:
@@ -1447,7 +1447,7 @@ export abstract class LuaTranspiler {
         const toContext = tsHelper.getFunctionContextType(toType, this.checker);
         if (fromContext === ContextType.Mixed || toContext === ContextType.Mixed) {
             throw TSTLErrors.UnsupportedOverloadAssignment(node, toName);
-        } else if (fromContext !== toContext) {
+        } else if (fromContext !== toContext && fromContext !== ContextType.None && toContext !== ContextType.None) {
             if (toContext === ContextType.Void) {
                 throw TSTLErrors.UnsupportedFunctionConversion(node, toName);
             } else {
@@ -1469,10 +1469,12 @@ export abstract class LuaTranspiler {
             toType.symbol.members.forEach(
                 (toMember, memberName) => {
                     const fromMember = fromType.symbol.members.get(memberName);
-                    const toMemberType = this.checker.getTypeOfSymbolAtLocation(toMember, node);
-                    const fromMemberType = this.checker.getTypeOfSymbolAtLocation(fromMember, node);
-                    this.validateAssignment(node, fromMemberType, toMemberType,
-                                            toName ? `${toName}.${memberName}` : memberName.toString());
+                    if (fromMember) {
+                        const toMemberType = this.checker.getTypeOfSymbolAtLocation(toMember, node);
+                        const fromMemberType = this.checker.getTypeOfSymbolAtLocation(fromMember, node);
+                        this.validateAssignment(node, fromMemberType, toMemberType,
+                                                toName ? `${toName}.${memberName}` : memberName.toString());
+                    }
                 }
             );
         }

diff --git a/test/translation/lua/namespaceMerge.lua b/test/translation/lua/namespaceMerge.lua
@@ -2,7 +2,7 @@ MergedClass = MergedClass or {}
 MergedClass.__index = MergedClass
 function MergedClass.new(construct, ...)
     local self = setmetatable({}, MergedClass)
-    self.propertyFunc = function(_)
+    self.propertyFunc = function(____)
 end
     if construct and MergedClass.constructor then MergedClass.constructor(self, ...) end
     return self

diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -263,6 +263,7 @@ export class AssignmentTests {
     @TestCase("foo.voidLambdaProp", "Foo.staticMethod", "foo+staticMethod")
     @TestCase("foo.voidLambdaProp", "Foo.staticLambdaProp", "foo+staticLambdaProp")
     @TestCase("foo.voidLambdaProp", "foo.voidMethod", "foo+voidMethod")
+    @TestCase("func", "(func as (string | ((s: string) => string)))", "foo+func")
     @Test("Valid function assignment")
     public validFunctionAssignment(func: string, assignTo: string, expectResult: string): void {
         const code = `${AssignmentTests.funcAssignTestCode} ${func} = ${assignTo}; return ${func}("foo");`;
@@ -279,10 +280,17 @@ export class AssignmentTests {
     @TestCase("s => s", "foo")
     @TestCase("function(s) { return s; }", "foo")
     @TestCase("function(this: void, s: string) { return s; }", "foo")
+    @TestCase("func", "foo+func", "string | ((s: string) => string)")
+    @TestCase("func", "foo+func", "T")
     @Test("Valid function argument")
-    public validFunctionArgument(func: string, expectResult: string): void {
+    public validFunctionArgument(func: string, expectResult: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(s: string) => s";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      function takesFunc(fn: (s: string) => s) { return fn("foo"); }
+                      function takesFunc<T extends ((s: string) => string)>(fn: ${funcType}) {
+                          return (fn as any)("foo");
+                      }
                       return takesFunc(${func});`;
         const result = util.transpileAndExecute(code);
         Expect(result).toBe(expectResult);
@@ -297,10 +305,17 @@ export class AssignmentTests {
     @TestCase("s => s", "foo")
     @TestCase("function(s) { return s; }", "foo")
     @TestCase("function(this: void, s: string) { return s; }", "foo")
+    @TestCase("func", "foo+func", "string | ((s: string) => string)")
+    @TestCase("func", "foo+func", "T")
     @Test("Valid function return")
-    public validFunctionReturn(func: string, expectResult: string): void {
+    public validFunctionReturn(func: string, expectResult: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(s: string) => s";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      function returnsFunc(): (s: string) => string { return ${func}; }
+                      function returnsFunc<T extends ((s: string) => string)>(): ${funcType} {
+                          return ${func};
+                      }
                       const fn = returnsFunc();
                       return fn("foo");`;
         const result = util.transpileAndExecute(code);
@@ -367,6 +382,7 @@ export class AssignmentTests {
     @TestCase("thisLambda", "Foo.thisStaticMethod", "foo+thisStaticMethod")
     @TestCase("thisLambda", "Foo.thisStaticLambdaProp", "foo+thisStaticLambdaProp")
     @TestCase("thisLambda", "thisFunc", "foo+thisFunc")
+    @TestCase("foo.method", "(foo.method as (string | ((this: Foo, s: string) => string))", "foo+method")
     @Test("Valid method assignment")
     public validMethodAssignment(func: string, assignTo: string, expectResult: string): void {
         const code = `${AssignmentTests.funcAssignTestCode} ${func} = ${assignTo}; return ${func}("foo");`;
@@ -383,10 +399,17 @@ export class AssignmentTests {
     @TestCase("s => s", "foo")
     @TestCase("function(s) { return s; }", "foo")
     @TestCase("function(this: Foo, s: string) { return s; }", "foo")
+    @TestCase("foo.method", "foo+method", "string | ((this: Foo, s: string) => string)")
+    @TestCase("foo.method", "foo+method", "T")
     @Test("Valid method argument")
-    public validMethodArgument(func: string, expectResult: string): void {
+    public validMethodArgument(func: string, expectResult: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(this: Foo, s: string) => string";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      function takesMethod(meth: (this: Foo, s: string) => string) { foo.method = meth; }
+                      function takesMethod<T extends ((this: Foo, s: string) => string)>(meth: ${funcType}) {
+                          foo.method = meth as any;
+                      }
                       takesMethod(${func});
                       return foo.method("foo");`;
         const result = util.transpileAndExecute(code);
@@ -402,10 +425,17 @@ export class AssignmentTests {
     @TestCase("s => s", "foo")
     @TestCase("function(s) { return s; }", "foo")
     @TestCase("function(this: Foo, s: string) { return s; }", "foo")
+    @TestCase("foo.method", "foo+method", "string | ((this: Foo, s: string) => string)")
+    @TestCase("foo.method", "foo+method", "T")
     @Test("Valid method return")
-    public validMethodReturn(func: string, expectResult: string): void {
+    public validMethodReturn(func: string, expectResult: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(this: Foo, s: string) => string";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      function returnMethod(): (this: Foo, s: string) => string { return ${func}; }
+                      function returnMethod<T extends ((this: Foo, s: string) => string)>(): ${funcType} {
+                          return ${func};
+                      }
                       foo.method = returnMethod();
                       return foo.method("foo");`;
         const result = util.transpileAndExecute(code);
@@ -442,6 +472,7 @@ export class AssignmentTests {
     @TestCase("Foo.staticLambdaProp", "Foo.thisStaticMethod")
     @TestCase("Foo.staticLambdaProp", "Foo.thisStaticLambdaProp")
     @TestCase("Foo.staticLambdaProp", "function(this: Foo, s: string) { return s; }")
+    @TestCase("func", "(foo.method as (string | ((this: Foo, s: string) => string)))")
     @Test("Invalid function assignment")
     public invalidFunctionAssignment(func: string, assignTo: string): void {
         const code = `${AssignmentTests.funcAssignTestCode} ${func} = ${assignTo};`;
@@ -457,10 +488,15 @@ export class AssignmentTests {
     @TestCase("thisFunc")
     @TestCase("thisLambda")
     @TestCase("function(this: Foo, s: string) { return s; }")
+    @TestCase("foo.method", "string | ((s: string) => string)")
+    @TestCase("foo.method", "T")
     @Test("Invalid function argument")
-    public invalidFunctionArgument(func: string): void {
+    public invalidFunctionArgument(func: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(s: string) => s";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      declare function takesFunc(fn: (s: string) => s);
+                      declare function takesFunc<T extends ((s: string) => string)>(fn: ${funcType});
                       takesFunc(${func});`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
@@ -474,10 +510,17 @@ export class AssignmentTests {
     @TestCase("thisFunc")
     @TestCase("thisLambda")
     @TestCase("function(this: Foo, s: string) { return s; }")
+    @TestCase("foo.method", "string | ((s: string) => string)")
+    @TestCase("foo.method", "T")
     @Test("Invalid function return")
-    public invalidFunctionReturn(func: string): void {
+    public invalidFunctionReturn(func: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(s: string) => s";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      function returnsFunc(): (s: string) => string { return ${func}; }`;
+                      function returnsFunc<T extends ((s: string) => string)>(): ${funcType} {
+                          return ${func};
+                      }`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
             "Unsupported conversion from method to function. To fix, wrap the method in an arrow function.");
@@ -525,6 +568,7 @@ export class AssignmentTests {
     @TestCase("thisLambda", "foo.voidMethod")
     @TestCase("thisLambda", "foo.voidLambdaProp")
     @TestCase("thisLambda", "function(this: void, s: string) { return s; }")
+    @TestCase("foo.method", "(func as string | ((s: string) => string))")
     @Test("Invalid method assignment")
     public invalidMethodAssignment(func: string, assignTo: string): void {
         const code = `${AssignmentTests.funcAssignTestCode} ${func} = ${assignTo};`;
@@ -541,10 +585,15 @@ export class AssignmentTests {
     @TestCase("foo.voidMethod")
     @TestCase("foo.voidLambdaProp")
     @TestCase("function(this: void, s: string) { return s; }")
+    @TestCase("func", "string | ((this: Foo, s: string) => string)")
+    @TestCase("func", "T")
     @Test("Invalid method argument")
-    public invalidMethodArgument(func: string): void {
+    public invalidMethodArgument(func: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(this: Foo, s: string) => string";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      declare function takesMethod(meth: (this: Foo, s: string) => s);
+                      declare function takesMethod<T extends ((this: Foo, s: string) => string)>(meth: ${funcType});
                       takesMethod(${func});`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
@@ -559,10 +608,17 @@ export class AssignmentTests {
     @TestCase("foo.voidMethod")
     @TestCase("foo.voidLambdaProp")
     @TestCase("function(this: void, s: string) { return s; }")
+    @TestCase("func", "string | ((this: Foo, s: string) => string)")
+    @TestCase("func", "T")
     @Test("Invalid method return")
-    public invalidMethodReturn(func: string): void {
+    public invalidMethodReturn(func: string, funcType?: string): void {
+        if (!funcType) {
+            funcType = "(this: Foo, s: string) => string";
+        }
         const code = `${AssignmentTests.funcAssignTestCode}
-                      function returnsMethod(): (this: Foo, s: string) => s { return ${func}; }`;
+                      function returnsMethod<T extends ((this: Foo, s: string) => string)>(): ${funcType} {
+                          return ${func};
+                      }`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
             "Unsupported conversion from function to method. To fix, wrap the function in an arrow function "
@@ -635,7 +691,7 @@ export class AssignmentTests {
     public validInterfaceMethodAssignment(): void {
         const code = `interface A { fn(this: void, s: string): string; }
                       interface B { fn(this: void, s: string): string; }
-                      const a: A = { fn: s => s };
+                      const a: A = { fn(this: void, s) { return s; } };
                       const b: B = a;
                       return b.fn("foo");`;
         const result = util.transpileAndExecute(code);

diff --git a/test/unit/functions.spec.ts b/test/unit/functions.spec.ts
@@ -340,4 +340,23 @@ export class FunctionTests {
         const result = util.transpileAndExecute(code);
         Expect(result).toBe(expectResult);
     }
+
+    @Test("Nested Function")
+    public nestedFunction(): void {
+        const code = `class C {
+                          private prop = "bar";
+                          public outer() {
+                              const o = {
+                                  prop: "foo",
+                                  innerFunc: function() { return this.prop; },
+                                  innerArrow: () => this.prop
+                              };
+                              return o.innerFunc() + o.innerArrow();
+                          }
+                      }
+                      let c = new C();
+                      return c.outer();`;
+        const result = util.transpileAndExecute(code);
+        Expect(result).toBe("foobar");
+    }
 }