filter using getiterationtypeofgeneratorfunctionreturntype

Author: gabritto

src/compiler/checker.ts

@@ -26777,11 +26777,9 @@ namespace ts {
                 if (contextualReturnType) {
                     const functionFlags = getFunctionFlags(func);
                     if (functionFlags & FunctionFlags.Generator) { // Generator or AsyncGenerator function
+                        const isAsyncGenerator = (functionFlags & FunctionFlags.Async) !== 0;
                         if (contextualReturnType.flags & TypeFlags.Union) {
-                            contextualReturnType = filterType(contextualReturnType, type => {
-                                const generator = createGeneratorReturnType(anyType, anyType, anyType, (functionFlags & FunctionFlags.Async) !== 0);
-                                return checkTypeAssignableTo(generator, type, /*errorNode*/ undefined);
-                            });
+                            contextualReturnType = filterType(contextualReturnType, type => !!getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, type, isAsyncGenerator));
                         }
                         const iterationReturnType = getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, contextualReturnType, (functionFlags & FunctionFlags.Async) !== 0);
                         if (!iterationReturnType) {
@@ -26816,16 +26814,11 @@ namespace ts {
             const func = getContainingFunction(node);
             if (func) {
                 const functionFlags = getFunctionFlags(func);
-                // let contextualReturnType = getContextualReturnType(func);
-                // const contextualReturnType = getContextualReturnType(func, contextFlags);
                 let contextualReturnType = getContextualReturnType(func, contextFlags);
                 if (contextualReturnType) {
                     const isAsyncGenerator = (functionFlags & FunctionFlags.Async) !== 0;
                     if (!node.asteriskToken && contextualReturnType.flags & TypeFlags.Union) {
-                        contextualReturnType = filterType(contextualReturnType, type => {
-                            const generator = createGeneratorReturnType(anyType, anyType, anyType, isAsyncGenerator);
-                            return checkTypeAssignableTo(generator, type, /*errorNode*/ undefined);
-                        });
+                        contextualReturnType = filterType(contextualReturnType, type => !!getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, type, isAsyncGenerator));
                     }
                     return node.asteriskToken
                         ? contextualReturnType

tests/baselines/reference/contextualTypeOnYield1.types

@@ -5,7 +5,7 @@ type FuncOrGeneratorFunc = () => (number | Generator<(arg: number) => void, any,
 
 const f: FuncOrGeneratorFunc = function*() {
 >f : FuncOrGeneratorFunc
->function*() {  yield (num) => console.log(num); // `num` should be inferred to have type `number`.} : () => Generator<(num: number) => void, void, any>
+>function*() {  yield (num) => console.log(num); // `num` should be inferred to have type `number`.} : () => Generator<(num: number) => void, void, unknown>
 
   yield (num) => console.log(num); // `num` should be inferred to have type `number`.
 >yield (num) => console.log(num) : any

tests/baselines/reference/contextualTypeOnYield2.types

@@ -5,7 +5,7 @@ type OrGen = () => (number | Generator<string, (arg: number) => void, undefined>
 
 const g: OrGen = function* () {
 >g : OrGen
->function* () {    return (num) => console.log(num);} : () => Generator<never, (num: number) => void, any>
+>function* () {    return (num) => console.log(num);} : () => Generator<never, (num: number) => void, unknown>
 
     return (num) => console.log(num);
 >(num) => console.log(num) : (num: number) => void