Make anyFunctionType a subtype of all function types (#1149)

Author: ahejlsberg

internal/checker/relater.go

@@ -4360,9 +4360,13 @@ func (r *Relater) signaturesRelatedTo(source *Type, target *Type, kind Signature
 	if r.relation == r.c.identityRelation {
 		return r.signaturesIdenticalTo(source, target, kind)
 	}
-	if target == r.c.anyFunctionType || r.relation != r.c.strictSubtypeRelation && source == r.c.anyFunctionType {
+	// With respect to signatures, the anyFunctionType wildcard is a subtype of every other function type.
+	if source == r.c.anyFunctionType {
 		return TernaryTrue
 	}
+	if target == r.c.anyFunctionType {
+		return TernaryFalse
+	}
 	sourceSignatures := r.c.getSignaturesOfType(source, kind)
 	targetSignatures := r.c.getSignaturesOfType(target, kind)
 	if kind == SignatureKindConstruct && len(sourceSignatures) != 0 && len(targetSignatures) != 0 {

testdata/baselines/reference/compiler/subtypeReductionWithAnyFunctionType.errors.txt

@@ -0,0 +1,31 @@
+subtypeReductionWithAnyFunctionType.ts(10,16): error TS7006: Parameter 'x' implicitly has an 'any' type.
+
+
+==== subtypeReductionWithAnyFunctionType.ts (1 errors) ====
+    // https://github.com/microsoft/typescript-go/issues/849
+    
+    declare function useMemo<T>(func: () => T): T;
+    
+    function getPredicate(alwaysTrue: boolean) {
+        const predicate: (input: string) => boolean = useMemo(() => {
+            if (alwaysTrue) {
+                return () => true;
+            }
+            return x => x.length > 0;
+                   ~
+!!! error TS7006: Parameter 'x' implicitly has an 'any' type.
+        });
+        return predicate;
+    }
+    
+    // https://github.com/microsoft/typescript-go/issues/1016
+    
+    declare function compact<T>(array: T[]): T[];
+    declare function makeFooer(): Fooer;
+    interface Fooer {
+        foo: (v: string) => string;
+    }
+    function f() {
+        const _ = compact([makeFooer(), { foo: (v) => v }]);
+    }
+    

testdata/baselines/reference/compiler/subtypeReductionWithAnyFunctionType.symbols

@@ -26,12 +26,42 @@ function getPredicate(alwaysTrue: boolean) {
         }
         return x => x.length > 0;
 >x : Symbol(x, Decl(subtypeReductionWithAnyFunctionType.ts, 9, 14))
->x.length : Symbol(length, Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(subtypeReductionWithAnyFunctionType.ts, 9, 14))
->length : Symbol(length, Decl(lib.es5.d.ts, --, --))
 
     });
     return predicate;
 >predicate : Symbol(predicate, Decl(subtypeReductionWithAnyFunctionType.ts, 5, 9))
 }
 
+// https://github.com/microsoft/typescript-go/issues/1016
+
+declare function compact<T>(array: T[]): T[];
+>compact : Symbol(compact, Decl(subtypeReductionWithAnyFunctionType.ts, 12, 1))
+>T : Symbol(T, Decl(subtypeReductionWithAnyFunctionType.ts, 16, 25))
+>array : Symbol(array, Decl(subtypeReductionWithAnyFunctionType.ts, 16, 28))
+>T : Symbol(T, Decl(subtypeReductionWithAnyFunctionType.ts, 16, 25))
+>T : Symbol(T, Decl(subtypeReductionWithAnyFunctionType.ts, 16, 25))
+
+declare function makeFooer(): Fooer;
+>makeFooer : Symbol(makeFooer, Decl(subtypeReductionWithAnyFunctionType.ts, 16, 45))
+>Fooer : Symbol(Fooer, Decl(subtypeReductionWithAnyFunctionType.ts, 17, 36))
+
+interface Fooer {
+>Fooer : Symbol(Fooer, Decl(subtypeReductionWithAnyFunctionType.ts, 17, 36))
+
+    foo: (v: string) => string;
+>foo : Symbol(foo, Decl(subtypeReductionWithAnyFunctionType.ts, 18, 17))
+>v : Symbol(v, Decl(subtypeReductionWithAnyFunctionType.ts, 19, 10))
+}
+function f() {
+>f : Symbol(f, Decl(subtypeReductionWithAnyFunctionType.ts, 20, 1))
+
+    const _ = compact([makeFooer(), { foo: (v) => v }]);
+>_ : Symbol(_, Decl(subtypeReductionWithAnyFunctionType.ts, 22, 9))
+>compact : Symbol(compact, Decl(subtypeReductionWithAnyFunctionType.ts, 12, 1))
+>makeFooer : Symbol(makeFooer, Decl(subtypeReductionWithAnyFunctionType.ts, 16, 45))
+>foo : Symbol(foo, Decl(subtypeReductionWithAnyFunctionType.ts, 22, 37))
+>v : Symbol(v, Decl(subtypeReductionWithAnyFunctionType.ts, 22, 44))
+>v : Symbol(v, Decl(subtypeReductionWithAnyFunctionType.ts, 22, 44))
+}
+

testdata/baselines/reference/compiler/subtypeReductionWithAnyFunctionType.types

@@ -14,9 +14,9 @@ function getPredicate(alwaysTrue: boolean) {
     const predicate: (input: string) => boolean = useMemo(() => {
 >predicate : (input: string) => boolean
 >input : string
->useMemo(() => {        if (alwaysTrue) {            return () => true;        }        return x => x.length > 0;    }) : (x: string) => boolean
+>useMemo(() => {        if (alwaysTrue) {            return () => true;        }        return x => x.length > 0;    }) : (x: any) => boolean
 >useMemo : <T>(func: () => T) => T
->() => {        if (alwaysTrue) {            return () => true;        }        return x => x.length > 0;    } : () => (x: string) => boolean
+>() => {        if (alwaysTrue) {            return () => true;        }        return x => x.length > 0;    } : () => (x: any) => boolean
 
         if (alwaysTrue) {
 >alwaysTrue : boolean
@@ -26,16 +26,47 @@ function getPredicate(alwaysTrue: boolean) {
 >true : true
         }
         return x => x.length > 0;
->x => x.length > 0 : (x: string) => boolean
->x : string
+>x => x.length > 0 : (x: any) => boolean
+>x : any
 >x.length > 0 : boolean
->x.length : number
->x : string
->length : number
+>x.length : any
+>x : any
+>length : any
 >0 : 0
 
     });
     return predicate;
 >predicate : (input: string) => boolean
 }
 
+// https://github.com/microsoft/typescript-go/issues/1016
+
+declare function compact<T>(array: T[]): T[];
+>compact : <T>(array: T[]) => T[]
+>array : T[]
+
+declare function makeFooer(): Fooer;
+>makeFooer : () => Fooer
+
+interface Fooer {
+    foo: (v: string) => string;
+>foo : (v: string) => string
+>v : string
+}
+function f() {
+>f : () => void
+
+    const _ = compact([makeFooer(), { foo: (v) => v }]);
+>_ : Fooer[]
+>compact([makeFooer(), { foo: (v) => v }]) : Fooer[]
+>compact : <T>(array: T[]) => T[]
+>[makeFooer(), { foo: (v) => v }] : Fooer[]
+>makeFooer() : Fooer
+>makeFooer : () => Fooer
+>{ foo: (v) => v } : { foo: (v: string) => string; }
+>foo : (v: string) => string
+>(v) => v : (v: string) => string
+>v : string
+>v : string
+}
+

testdata/tests/cases/compiler/subtypeReductionWithAnyFunctionType.ts

@@ -15,3 +15,14 @@ function getPredicate(alwaysTrue: boolean) {
     });
     return predicate;
 }
+
+// https://github.com/microsoft/typescript-go/issues/1016
+
+declare function compact<T>(array: T[]): T[];
+declare function makeFooer(): Fooer;
+interface Fooer {
+    foo: (v: string) => string;
+}
+function f() {
+    const _ = compact([makeFooer(), { foo: (v) => v }]);
+}