TypeScriptToLua · Perryvw · Dec 14, 2018 · Oct 25, 2018 · Oct 25, 2018 · Oct 25, 2018
diff --git a/src/Errors.ts b/src/Errors.ts
@@ -84,11 +84,13 @@ export class TSTLErrors {
     public static UnsupportedMethodConversion = (node: ts.Node, name?: string) => {
         if (name) {
             return new TranspileError(`Unsupported conversion from function to method "${name}". `
-                                      + `To fix, wrap the function in an arrow function.`,
+                                      + `To fix, wrap the function in an arrow function or declare the function with`
+                                      + ` an explicit 'this' parameter.`,
                                       node);
         } else {
             return new TranspileError(`Unsupported conversion from function to method. `
-                                      + `To fix, wrap the function in an arrow function.`,
+                                      + `To fix, wrap the function in an arrow function or declare the function with`
+                                      + ` an explicit 'this' parameter.`,
                                       node);
         }
     }

diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -116,6 +116,15 @@ 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));
+        if (declaration) {
+            const signature = checker.getSignatureFromDeclaration(declaration as ts.SignatureDeclaration);
+            return checker.getReturnTypeOfSignature(signature);
+        }
+        return null;
+    }
+
     public static collectCustomDecorators(symbol: ts.Symbol, checker: ts.TypeChecker,
                                           decMap: Map<DecoratorKind, Decorator>): void {
         const comments = symbol.getDocumentationComment(checker);
@@ -269,11 +278,27 @@ export class TSHelper {
             if ((ts.isFunctionExpression(signatureDeclaration) || ts.isArrowFunction(signatureDeclaration))
                 && !this.getExplicitThisParameter(signatureDeclaration)) {
                 // Function expressions: get signatures of type being assigned to, unless 'this' was explicit
-                const declType = checker.getTypeAtLocation(signatureDeclaration.parent);
-                const declSignatures = declType.getCallSignatures();
-                if (declSignatures.length > 0) {
-                    declSignatures.map(s => s.getDeclaration()).forEach(decl => signatureDeclarations.push(decl));
-                    continue;
+                let declType: ts.Type;
+                if (ts.isCallExpression(signatureDeclaration.parent)) {
+                    // Function expression being passed as argument to another function
+                    const i = signatureDeclaration.parent.arguments.indexOf(signatureDeclaration);
+                    if (i >= 0) {
+                        const parentSignature = checker.getResolvedSignature(signatureDeclaration.parent);
+                        const parentSignatureDeclaration = parentSignature.getDeclaration();
+                        declType = checker.getTypeAtLocation(parentSignatureDeclaration.parameters[i]);
+                    }
+                } else if (ts.isReturnStatement(signatureDeclaration.parent)) {
+                    declType = this.getContainingFunctionReturnType(signatureDeclaration.parent, checker);
+                } else {
+                    // Function expression being assigned
+                    declType = checker.getTypeAtLocation(signatureDeclaration.parent);
+                }
+                if (declType) {
+                    const declSignatures = declType.getCallSignatures();
+                    if (declSignatures.length > 0) {
+                        declSignatures.map(s => s.getDeclaration()).forEach(decl => signatureDeclarations.push(decl));
+                        continue;
+                    }
                 }
             }
             signatureDeclarations.push(signatureDeclaration);

diff --git a/src/Transpiler.ts b/src/Transpiler.ts
@@ -702,6 +702,11 @@ export abstract class LuaTranspiler {
 
     public transpileReturn(node: ts.ReturnStatement): string {
         if (node.expression) {
+            const returnType = tsHelper.getContainingFunctionReturnType(node, this.checker);
+            if (returnType) {
+                const expressionType = this.checker.getTypeAtLocation(node.expression);
+                this.validateAssignment(node, expressionType, returnType);
+            }
             if (tsHelper.isInTupleReturnFunction(node, this.checker)) {
                 // Parent function is a TupleReturn function
                 if (ts.isArrayLiteralExpression(node.expression)) {

diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -276,6 +276,9 @@ export class AssignmentTests {
     @TestCase("Foo.staticLambdaProp", "foo+staticLambdaProp")
     @TestCase("foo.voidMethod", "foo+voidMethod")
     @TestCase("foo.voidLambdaProp", "foo+voidLambdaProp")
+    @TestCase("s => s", "foo")
+    @TestCase("function(s) { return s; }", "foo")
+    @TestCase("function(this: void, s: string) { return s; }", "foo")
     @Test("Valid function argument")
     public validFunctionArgument(func: string, expectResult: string): void {
         const code = `${AssignmentTests.funcAssignTestCode}
@@ -285,6 +288,25 @@ export class AssignmentTests {
         Expect(result).toBe(expectResult);
     }
 
+    @TestCase("func", "foo+func")
+    @TestCase("lambda", "foo+lambda")
+    @TestCase("Foo.staticMethod", "foo+staticMethod")
+    @TestCase("Foo.staticLambdaProp", "foo+staticLambdaProp")
+    @TestCase("foo.voidMethod", "foo+voidMethod")
+    @TestCase("foo.voidLambdaProp", "foo+voidLambdaProp")
+    @TestCase("s => s", "foo")
+    @TestCase("function(s) { return s; }", "foo")
+    @TestCase("function(this: void, s: string) { return s; }", "foo")
+    @Test("Valid function return")
+    public validFunctionReturn(func: string, expectResult: string): void {
+        const code = `${AssignmentTests.funcAssignTestCode}
+                      function returnsFunc(): (s: string) => string { return ${func}; }
+                      const fn = returnsFunc();
+                      return fn("foo");`;
+        const result = util.transpileAndExecute(code);
+        Expect(result).toBe(expectResult);
+    }
+
     @TestCase("foo.method", "foo.lambdaProp", "foo+lambdaProp")
     @TestCase("foo.method", "s => s", "foo")
     @TestCase("foo.method", "function(s) { return s; }", "foo")
@@ -358,17 +380,38 @@ export class AssignmentTests {
     @TestCase("Foo.thisStaticLambdaProp", "foo+thisStaticLambdaProp")
     @TestCase("thisFunc", "foo+thisFunc")
     @TestCase("thisLambda", "foo+thisLambda")
+    @TestCase("s => s", "foo")
+    @TestCase("function(s) { return s; }", "foo")
+    @TestCase("function(this: Foo, s: string) { return s; }", "foo")
     @Test("Valid method argument")
     public validMethodArgument(func: string, expectResult: string): void {
         const code = `${AssignmentTests.funcAssignTestCode}
-                      const foo = new Foo();
-                      function takesMethod(meth: (this: Foo, s: string) => s) { foo.method = meth; }
+                      function takesMethod(meth: (this: Foo, s: string) => string) { foo.method = meth; }
                       takesMethod(${func});
                       return foo.method("foo");`;
         const result = util.transpileAndExecute(code);
         Expect(result).toBe(expectResult);
     }
 
+    @TestCase("foo.method", "foo+method")
+    @TestCase("foo.lambdaProp", "foo+lambdaProp")
+    @TestCase("Foo.thisStaticMethod", "foo+thisStaticMethod")
+    @TestCase("Foo.thisStaticLambdaProp", "foo+thisStaticLambdaProp")
+    @TestCase("thisFunc", "foo+thisFunc")
+    @TestCase("thisLambda", "foo+thisLambda")
+    @TestCase("s => s", "foo")
+    @TestCase("function(s) { return s; }", "foo")
+    @TestCase("function(this: Foo, s: string) { return s; }", "foo")
+    @Test("Valid method return")
+    public validMethodReturn(func: string, expectResult: string): void {
+        const code = `${AssignmentTests.funcAssignTestCode}
+                      function returnMethod(): (this: Foo, s: string) => string { return ${func}; }
+                      foo.method = returnMethod();
+                      return foo.method("foo");`;
+        const result = util.transpileAndExecute(code);
+        Expect(result).toBe(expectResult);
+    }
+
     @TestCase("func", "foo.method")
     @TestCase("func", "foo.lambdaProp")
     @TestCase("func", "Foo.thisStaticMethod")
@@ -413,6 +456,7 @@ export class AssignmentTests {
     @TestCase("Foo.thisStaticLambdaProp")
     @TestCase("thisFunc")
     @TestCase("thisLambda")
+    @TestCase("function(this: Foo, s: string) { return s; }")
     @Test("Invalid function argument")
     public invalidFunctionArgument(func: string): void {
         const code = `${AssignmentTests.funcAssignTestCode}
@@ -423,6 +467,22 @@ export class AssignmentTests {
             "Unsupported conversion from method to function \"fn\". To fix, wrap the method in an arrow function.");
     }
 
+    @TestCase("foo.method")
+    @TestCase("foo.lambdaProp")
+    @TestCase("Foo.thisStaticMethod")
+    @TestCase("Foo.thisStaticLambdaProp")
+    @TestCase("thisFunc")
+    @TestCase("thisLambda")
+    @TestCase("function(this: Foo, s: string) { return s; }")
+    @Test("Invalid function return")
+    public invalidFunctionReturn(func: string): void {
+        const code = `${AssignmentTests.funcAssignTestCode}
+                      function returnsFunc(): (s: string) => string { return ${func}; }`;
+        Expect(() => util.transpileString(code)).toThrowError(
+            TranspileError,
+            "Unsupported conversion from method to function. To fix, wrap the method in an arrow function.");
+    }
+
     @TestCase("foo.method", "func")
     @TestCase("foo.method", "lambda")
     @TestCase("foo.method", "Foo.staticMethod")
@@ -470,7 +530,8 @@ export class AssignmentTests {
         const code = `${AssignmentTests.funcAssignTestCode} ${func} = ${assignTo};`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
-            "Unsupported conversion from function to method. To fix, wrap the function in an arrow function.");
+            "Unsupported conversion from function to method. To fix, wrap the function in an arrow function or declare"
+            + " the function with an explicit 'this' parameter.");
     }
 
     @TestCase("func")
@@ -479,14 +540,33 @@ export class AssignmentTests {
     @TestCase("Foo.staticLambdaProp")
     @TestCase("foo.voidMethod")
     @TestCase("foo.voidLambdaProp")
+    @TestCase("function(this: void, s: string) { return s; }")
     @Test("Invalid method argument")
     public invalidMethodArgument(func: string): void {
         const code = `${AssignmentTests.funcAssignTestCode}
                       declare function takesMethod(meth: (this: Foo, s: string) => s);
                       takesMethod(${func});`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
-            "Unsupported conversion from function to method \"meth\". To fix, wrap the function in an arrow function.");
+            "Unsupported conversion from function to method \"meth\". To fix, wrap the function in an arrow function "
+            + "or declare the function with an explicit 'this' parameter.");
+    }
+
+    @TestCase("func")
+    @TestCase("lambda")
+    @TestCase("Foo.staticMethod")
+    @TestCase("Foo.staticLambdaProp")
+    @TestCase("foo.voidMethod")
+    @TestCase("foo.voidLambdaProp")
+    @TestCase("function(this: void, s: string) { return s; }")
+    @Test("Invalid method return")
+    public invalidMethodReturn(func: string): void {
+        const code = `${AssignmentTests.funcAssignTestCode}
+                      function returnsMethod(): (this: Foo, s: string) => s { return ${func}; }`;
+        Expect(() => util.transpileString(code)).toThrowError(
+            TranspileError,
+            "Unsupported conversion from function to method. To fix, wrap the function in an arrow function "
+            + "or declare the function with an explicit 'this' parameter.");
     }
 
     @Test("Interface method assignment")
@@ -547,7 +627,8 @@ export class AssignmentTests {
                       let [i, f]: [number, Meth] = getTuple();`;
         Expect(() => util.transpileString(code)).toThrowError(
             TranspileError,
-            "Unsupported conversion from function to method. To fix, wrap the function in an arrow function.");
+            "Unsupported conversion from function to method. To fix, wrap the function in an arrow function or declare"
+            + " the function with an explicit 'this' parameter.");
     }
 
     @Test("Valid interface method assignment")