Function inference fixes (#469)

tomblind · web-flow · commit a30beba4f73a · 2019-03-09T09:58:18.000-07:00
* fixed function expression inference when assigning to tuples as casts

* removed FocusTest

* added fix for inference in constructors
diff --git a/src/TSHelper.ts b/src/TSHelper.ts
@@ -436,7 +436,7 @@ export class TSHelper {
             // Ignore expressions wrapped in parenthesis
             return this.inferAssignedType(expression.parent, checker);
 
-        } else if (ts.isCallExpression(expression.parent)) {
+        } else if (ts.isCallOrNewExpression(expression.parent)) {
             // Expression being passed as argument to a function
             const argumentIndex = expression.parent.arguments.indexOf(expression);
             if (argumentIndex >= 0) {
@@ -514,11 +514,22 @@ export class TSHelper {
         {
             // Expression assigned to variable
             return checker.getTypeAtLocation(expression.parent.left);
+
+        } else if (ts.isAssertionExpression(expression.parent)) {
+            // Expression being cast
+            return checker.getTypeFromTypeNode(expression.parent.type);
         }
 
         return checker.getTypeAtLocation(expression);
     }
 
+    public static getAllCallSignatures(type: ts.Type): ReadonlyArray<ts.Signature> {
+        if (type.isUnion()) {
+            return type.types.map(t => TSHelper.getAllCallSignatures(t)).reduce((a, b) => a.concat(b));
+        }
+        return type.getCallSignatures();
+    }
+
     public static getSignatureDeclarations(
         signatures: ReadonlyArray<ts.Signature>,
         checker: ts.TypeChecker
@@ -533,7 +544,7 @@ export class TSHelper {
                 // Infer type of function expressions/arrow functions
                 const inferredType = TSHelper.inferAssignedType(signatureDeclaration, checker);
                 if (inferredType) {
-                    const inferredSignatures = inferredType.getCallSignatures();
+                    const inferredSignatures = TSHelper.getAllCallSignatures(inferredType);
                     if (inferredSignatures.length > 0) {
                         signatureDeclarations.push(...inferredSignatures.map(s => s.getDeclaration()));
                         continue;
diff --git a/test/unit/assignments.spec.ts b/test/unit/assignments.spec.ts
@@ -973,6 +973,68 @@ export class AssignmentTests {
         Expect(util.transpileAndExecute(code)).toBe("foo");
     }
 
+    @TestCase("(this: void, s: string) => string", "s => s")
+    @TestCase("(this: any, s: string) => string", "s => s")
+    @TestCase("(s: string) => string", "s => s")
+    @TestCase("(this: void, s: string) => string", "function(s) { return s; }")
+    @TestCase("(this: any, s: string) => string", "function(s) { return s; }")
+    @TestCase("(s: string) => string", "function(s) { return s; }")
+    @Test("Function expression type inference in union")
+    public functionExpressionTypeInferenceInUnion(funcType: string, funcExp: string): void {
+        const code =
+            `type U = string | number | (${funcType});
+            const u: U = ${funcExp};
+            return (u as ${funcType})("foo");`;
+        Expect(util.transpileAndExecute(code)).toBe("foo");
+    }
+
+    @TestCase("(this: void, s: string) => string", "s => s")
+    @TestCase("(this: any, s: string) => string", "s => s")
+    @TestCase("(s: string) => string", "s => s")
+    @TestCase("(this: void, s: string) => string", "function(s) { return s; }")
+    @TestCase("(this: any, s: string) => string", "function(s) { return s; }")
+    @TestCase("(s: string) => string", "function(s) { return s; }")
+    @Test("Function expression type inference in as cast")
+    public functionExpressionTypeInferenceInAsCast(funcType: string, funcExp: string): void {
+        const code =
+            `const fn: ${funcType} = (${funcExp}) as (${funcType});
+            return fn("foo");`;
+            console.log(code);
+        Expect(util.transpileAndExecute(code)).toBe("foo");
+    }
+
+    @TestCase("(this: void, s: string) => string", "s => s")
+    @TestCase("(this: any, s: string) => string", "s => s")
+    @TestCase("(s: string) => string", "s => s")
+    @TestCase("(this: void, s: string) => string", "function(s) { return s; }")
+    @TestCase("(this: any, s: string) => string", "function(s) { return s; }")
+    @TestCase("(s: string) => string", "function(s) { return s; }")
+    @Test("Function expression type inference in type assertion")
+    public functionExpressionTypeInferenceInTypeAssert(funcType: string, funcExp: string): void {
+        const code =
+            `const fn: ${funcType} = <${funcType}>(${funcExp});
+            return fn("foo");`;
+        Expect(util.transpileAndExecute(code)).toBe("foo");
+    }
+
+    @TestCase("(this: void, s: string) => string", "s => s")
+    @TestCase("(this: any, s: string) => string", "s => s")
+    @TestCase("(s: string) => string", "s => s")
+    @TestCase("(this: void, s: string) => string", "function(s) { return s; }")
+    @TestCase("(this: any, s: string) => string", "function(s) { return s; }")
+    @TestCase("(s: string) => string", "function(s) { return s; }")
+    @Test("Function expression type inference in constructor")
+    public functionExpresssionTypeInferenceInConstructor(funcType: string, funcExp: string): void {
+        const code =
+            `class C {
+                result: string;
+                constructor(fn: (s: string) => string) { this.result = fn("foo"); }
+            }
+            const c = new C(s => s);
+            return c.result;`;
+        Expect(util.transpileAndExecute(code)).toBe("foo");
+    }
+
     @Test("String table access")
     public stringTableAccess(assignType: string): void {
         const code = `const dict : {[key:string]:any} = {};
