diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index 58b189d9e81d4..953334321c252 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -427,8 +427,8 @@ namespace ts.BuilderState {
                 const references = state.referencedMap.get(path);
                 if (references) {
                     const iterator = references.keys();
-                    for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
-                        queue.push(value as Path);
+                    for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+                        queue.push(iterResult.value as Path);
                     }
                 }
             }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 497788b6d7206..40b86ad679a98 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -7,6 +7,56 @@ namespace ts {
     let nextMergeId = 1;
     let nextFlowId = 1;
 
+    const enum IterationUse {
+        AllowsSyncIterablesFlag = 1 << 0,
+        AllowsAsyncIterablesFlag = 1 << 1,
+        AllowsStringInputFlag = 1 << 2,
+        ForOfFlag = 1 << 3,
+        YieldStarFlag = 1 << 4,
+        SpreadFlag = 1 << 5,
+        DestructuringFlag = 1 << 6,
+
+        // Spread, Destructuring, Array element assignment
+        Element = AllowsSyncIterablesFlag,
+        Spread = AllowsSyncIterablesFlag | SpreadFlag,
+        Destructuring = AllowsSyncIterablesFlag | DestructuringFlag,
+
+        ForOf = AllowsSyncIterablesFlag | AllowsStringInputFlag | ForOfFlag,
+        ForAwaitOf = AllowsSyncIterablesFlag | AllowsAsyncIterablesFlag | AllowsStringInputFlag | ForOfFlag,
+
+        YieldStar = AllowsSyncIterablesFlag | YieldStarFlag,
+        AsyncYieldStar = AllowsSyncIterablesFlag | AllowsAsyncIterablesFlag | YieldStarFlag,
+
+        GeneratorReturnType = AllowsSyncIterablesFlag,
+        AsyncGeneratorReturnType = AllowsAsyncIterablesFlag,
+
+    }
+
+    const enum IterationTypeKind {
+        Yield,
+        Return,
+        Next,
+    }
+
+    interface IterationTypesResolver {
+        iterableCacheKey: "iterationTypesOfAsyncIterable" | "iterationTypesOfIterable";
+        iteratorCacheKey: "iterationTypesOfAsyncIterator" | "iterationTypesOfIterator";
+        iteratorSymbolName: "asyncIterator" | "iterator";
+        getGlobalIteratorType: (reportErrors: boolean) => Type;
+        getGlobalIterableType: (reportErrors: boolean) => Type;
+        getGlobalIterableIteratorType: (reportErrors: boolean) => Type;
+        getGlobalGeneratorType: (reportErrors: boolean) => Type;
+        resolveIterationType: (type: Type, errorNode: Node | undefined) => Type | undefined;
+        mustHaveANextMethodDiagnostic: DiagnosticMessage;
+        mustBeAMethodDiagnostic: DiagnosticMessage;
+        mustHaveAValueDiagnostic: DiagnosticMessage;
+    }
+
+    const enum WideningKind {
+        Normal,
+        GeneratorYield
+    }
+
     export function getNodeId(node: Node): number {
         if (!node.id) {
             node.id = nextNodeId;
@@ -481,6 +531,44 @@ namespace ts {
 
         const enumNumberIndexInfo = createIndexInfo(stringType, /*isReadonly*/ true);
 
+        const iterationTypesCache = createMap<IterationTypes>(); // cache for common IterationTypes instances
+        const noIterationTypes: IterationTypes = {
+            get yieldType(): Type { throw new Error("Not supported"); },
+            get returnType(): Type { throw new Error("Not supported"); },
+            get nextType(): Type { throw new Error("Not supported"); },
+        };
+        const anyIterationTypes = createIterationTypes(anyType, anyType, anyType);
+        const anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType);
+        const defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType); // default iteration types for `Iterator`.
+
+        const asyncIterationTypesResolver: IterationTypesResolver = {
+            iterableCacheKey: "iterationTypesOfAsyncIterable",
+            iteratorCacheKey: "iterationTypesOfAsyncIterator",
+            iteratorSymbolName: "asyncIterator",
+            getGlobalIteratorType: getGlobalAsyncIteratorType,
+            getGlobalIterableType: getGlobalAsyncIterableType,
+            getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
+            getGlobalGeneratorType: getGlobalAsyncGeneratorType,
+            resolveIterationType: getAwaitedType,
+            mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
+            mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
+            mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property,
+        };
+
+        const syncIterationTypesResolver: IterationTypesResolver = {
+            iterableCacheKey: "iterationTypesOfIterable",
+            iteratorCacheKey: "iterationTypesOfIterator",
+            iteratorSymbolName: "iterator",
+            getGlobalIteratorType,
+            getGlobalIterableType,
+            getGlobalIterableIteratorType,
+            getGlobalGeneratorType,
+            resolveIterationType: (type, _errorNode) => type,
+            mustHaveANextMethodDiagnostic: Diagnostics.An_iterator_must_have_a_next_method,
+            mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
+            mustHaveAValueDiagnostic: Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property,
+        };
+
         interface DuplicateInfoForSymbol {
             readonly firstFileLocations: Node[];
             readonly secondFileLocations: Node[];
@@ -533,9 +621,13 @@ namespace ts {
         let deferredGlobalIterableType: GenericType;
         let deferredGlobalIteratorType: GenericType;
         let deferredGlobalIterableIteratorType: GenericType;
+        let deferredGlobalGeneratorType: GenericType;
+        let deferredGlobalIteratorYieldResultType: GenericType;
+        let deferredGlobalIteratorReturnResultType: GenericType;
         let deferredGlobalAsyncIterableType: GenericType;
         let deferredGlobalAsyncIteratorType: GenericType;
         let deferredGlobalAsyncIterableIteratorType: GenericType;
+        let deferredGlobalAsyncGeneratorType: GenericType;
         let deferredGlobalTemplateStringsArrayType: ObjectType;
         let deferredGlobalImportMetaType: ObjectType;
         let deferredGlobalExtractSymbol: Symbol;
@@ -5108,7 +5200,7 @@ namespace ts {
                 // This elementType will be used if the specific property corresponding to this index is not
                 // present (aka the tuple element property). This call also checks that the parentType is in
                 // fact an iterable or array (depending on target language).
-                const elementType = checkIteratedTypeOrElementType(parentType, pattern, /*allowStringInput*/ false, /*allowAsyncIterables*/ false);
+                const elementType = checkIteratedTypeOrElementType(IterationUse.Destructuring, parentType, undefinedType, pattern);
                 const index = pattern.elements.indexOf(declaration);
                 if (declaration.dotDotDotToken) {
                     // If the parent is a tuple type, the rest element has a tuple type of the
@@ -9340,25 +9432,41 @@ namespace ts {
         }
 
         function getGlobalAsyncIteratorType(reportErrors: boolean) {
-            return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
+            return deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
         }
 
         function getGlobalAsyncIterableIteratorType(reportErrors: boolean) {
             return deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
         }
 
+        function getGlobalAsyncGeneratorType(reportErrors: boolean) {
+            return deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
+        }
+
         function getGlobalIterableType(reportErrors: boolean) {
             return deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
         }
 
         function getGlobalIteratorType(reportErrors: boolean) {
-            return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
+            return deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
         }
 
         function getGlobalIterableIteratorType(reportErrors: boolean) {
             return deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
         }
 
+        function getGlobalGeneratorType(reportErrors: boolean) {
+            return deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
+        }
+
+        function getGlobalIteratorYieldResultType(reportErrors: boolean) {
+            return deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
+        }
+
+        function getGlobalIteratorReturnResultType(reportErrors: boolean) {
+            return deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult" as __String, /*arity*/ 1, reportErrors)) || emptyGenericType;
+        }
+
         function getGlobalTypeOrUndefined(name: __String, arity = 0): ObjectType | undefined {
             const symbol = getGlobalSymbol(name, SymbolFlags.Type, /*diagnostic*/ undefined);
             return symbol && <GenericType>getTypeOfGlobalSymbol(symbol, arity);
@@ -9387,20 +9495,22 @@ namespace ts {
             return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]);
         }
 
-        function createAsyncIterableType(iteratedType: Type): Type {
-            return createTypeFromGenericGlobalType(getGlobalAsyncIterableType(/*reportErrors*/ true), [iteratedType]);
-        }
-
-        function createAsyncIterableIteratorType(iteratedType: Type): Type {
-            return createTypeFromGenericGlobalType(getGlobalAsyncIterableIteratorType(/*reportErrors*/ true), [iteratedType]);
+        function createAsyncGeneratorType(yieldType: Type, returnType: Type, nextType: Type) {
+            const globalAsyncGeneratorType = getGlobalAsyncGeneratorType(/*reportErrors*/ true);
+            if (globalAsyncGeneratorType !== emptyGenericType) {
+                yieldType = getAwaitedType(yieldType) || unknownType;
+                returnType = getAwaitedType(returnType) || unknownType;
+                nextType = getAwaitedType(nextType) || unknownType;
+            }
+            return createTypeFromGenericGlobalType(globalAsyncGeneratorType, [yieldType, returnType, nextType]);
         }
 
         function createIterableType(iteratedType: Type): Type {
             return createTypeFromGenericGlobalType(getGlobalIterableType(/*reportErrors*/ true), [iteratedType]);
         }
 
-        function createIterableIteratorType(iteratedType: Type): Type {
-            return createTypeFromGenericGlobalType(getGlobalIterableIteratorType(/*reportErrors*/ true), [iteratedType]);
+        function createGeneratorType(yieldType: Type, returnType: Type, nextType: Type) {
+            return createTypeFromGenericGlobalType(getGlobalGeneratorType(/*reportErrors*/ true), [yieldType, returnType, nextType]);
         }
 
         function createArrayType(elementType: Type, readonly?: boolean): ObjectType {
@@ -14528,6 +14638,25 @@ namespace ts {
             return type;
         }
 
+        function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type: Type | undefined, contextualSignatureReturnType: Type | undefined, isAsync: boolean) {
+            if (type && isUnitType(type)) {
+                const contextualType = !contextualSignatureReturnType ? undefined :
+                    isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) :
+                    contextualSignatureReturnType;
+                type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+            }
+            return type;
+        }
+
+        function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type: Type | undefined, contextualSignatureReturnType: Type | undefined, kind: IterationTypeKind, isAsyncGenerator: boolean) {
+            if (type && isUnitType(type)) {
+                const contextualType = !contextualSignatureReturnType ? undefined :
+                    getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator);
+                type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+            }
+            return type;
+        }
+
         /**
          * Check if a Type was written as a tuple type literal.
          * Prefer using isTupleLikeType() unless the use of `elementTypes` is required.
@@ -14884,7 +15013,7 @@ namespace ts {
             return errorReported;
         }
 
-        function reportImplicitAny(declaration: Declaration, type: Type) {
+        function reportImplicitAny(declaration: Declaration, type: Type, wideningKind?: WideningKind) {
             const typeAsString = typeToString(getWidenedType(type));
             if (isInJSFile(declaration) && !isCheckJsEnabledForFile(getSourceFileOfNode(declaration), compilerOptions)) {
                 // Only report implicit any errors/suggestions in TS and ts-check JS files
@@ -14930,10 +15059,17 @@ namespace ts {
                 case SyntaxKind.FunctionExpression:
                 case SyntaxKind.ArrowFunction:
                     if (noImplicitAny && !(declaration as NamedDeclaration).name) {
-                        error(declaration, Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
+                        if (wideningKind === WideningKind.GeneratorYield) {
+                            error(declaration, Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString);
+                        }
+                        else {
+                            error(declaration, Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString);
+                        }
                         return;
                     }
-                    diagnostic = noImplicitAny ? Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type : Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage;
+                    diagnostic = !noImplicitAny ? Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage :
+                        wideningKind === WideningKind.GeneratorYield ? Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type :
+                            Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type;
                     break;
                 case SyntaxKind.MappedType:
                     if (noImplicitAny) {
@@ -14946,11 +15082,11 @@ namespace ts {
             errorOrSuggestion(noImplicitAny, declaration, diagnostic, declarationNameToString(getNameOfDeclaration(declaration)), typeAsString);
         }
 
-        function reportErrorsFromWidening(declaration: Declaration, type: Type) {
+        function reportErrorsFromWidening(declaration: Declaration, type: Type, wideningKind?: WideningKind) {
             if (produceDiagnostics && noImplicitAny && getObjectFlags(type) & ObjectFlags.ContainsWideningType) {
                 // Report implicit any error within type if possible, otherwise report error on declaration
                 if (!reportWideningErrorsInType(type)) {
-                    reportImplicitAny(declaration, type);
+                    reportImplicitAny(declaration, type, wideningKind);
                 }
             }
         }
@@ -15159,7 +15295,7 @@ namespace ts {
             return getTypeFromInference(inference) || unknownType;
         }
 
-        function* getUnmatchedProperties(source: Type, target: Type, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean) {
+        function* getUnmatchedProperties(source: Type, target: Type, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean): IterableIterator<Symbol> {
             const properties = target.flags & TypeFlags.Union ? getPossiblePropertiesOfUnionType(target as UnionType) : getPropertiesOfType(target);
             for (const targetProp of properties) {
                 if (requireOptionalProperties || !(targetProp.flags & SymbolFlags.Optional || getCheckFlags(targetProp) & CheckFlags.Partial)) {
@@ -15181,7 +15317,8 @@ namespace ts {
         }
 
         function getUnmatchedProperty(source: Type, target: Type, requireOptionalProperties: boolean, matchDiscriminantProperties: boolean): Symbol | undefined {
-            return getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next().value;
+            const result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next();
+            if (!result.done) return result.value;
         }
 
         function tupleTypesDefinitelyUnrelated(source: TupleTypeReference, target: TupleTypeReference) {
@@ -16160,12 +16297,12 @@ namespace ts {
 
         function getTypeOfDestructuredArrayElement(type: Type, index: number) {
             return everyType(type, isTupleLikeType) && getTupleElementType(type, index) ||
-                checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterables*/ false) ||
+                checkIteratedTypeOrElementType(IterationUse.Destructuring, type, undefinedType, /*errorNode*/ undefined) ||
                 errorType;
         }
 
         function getTypeOfDestructuredSpreadExpression(type: Type) {
-            return createArrayType(checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterables*/ false) || errorType);
+            return createArrayType(checkIteratedTypeOrElementType(IterationUse.Destructuring, type, undefinedType, /*errorNode*/ undefined) || errorType);
         }
 
         function getAssignedTypeOfBinaryExpression(node: BinaryExpression): Type {
@@ -18442,7 +18579,7 @@ namespace ts {
                 if (contextualReturnType) {
                     return node.asteriskToken
                         ? contextualReturnType
-                        : getIteratedTypeOfGenerator(contextualReturnType, (functionFlags & FunctionFlags.Async) !== 0);
+                        : getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Yield, contextualReturnType, (functionFlags & FunctionFlags.Async) !== 0);
                 }
             }
 
@@ -18675,7 +18812,7 @@ namespace ts {
         function getContextualTypeForElementExpression(arrayContextualType: Type | undefined, index: number): Type | undefined {
             return arrayContextualType && (
                 getTypeOfPropertyOfContextualType(arrayContextualType, "" + index as __String)
-                || getIteratedTypeOrElementType(arrayContextualType, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterables*/ false, /*checkAssignability*/ false));
+                || getIteratedTypeOrElementType(IterationUse.Element, arrayContextualType, undefinedType, /*errorNode*/ undefined, /*checkAssignability*/ false));
         }
 
         // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type.
@@ -18873,6 +19010,10 @@ namespace ts {
                 case SyntaxKind.AwaitExpression:
                     return getContextualTypeForAwaitOperand(<AwaitExpression>parent);
                 case SyntaxKind.CallExpression:
+                    if ((<CallExpression>parent).expression.kind === SyntaxKind.ImportKeyword) {
+                        return stringType;
+                    }
+                    /* falls through */
                 case SyntaxKind.NewExpression:
                     return getContextualTypeForArgument(<CallExpression | NewExpression>parent, node);
                 case SyntaxKind.TypeAssertionExpression:
@@ -19140,7 +19281,7 @@ namespace ts {
             }
 
             const arrayOrIterableType = checkExpression(node.expression, checkMode);
-            return checkIteratedTypeOrElementType(arrayOrIterableType, node.expression, /*allowStringInput*/ false, /*allowAsyncIterables*/ false);
+            return checkIteratedTypeOrElementType(IterationUse.Spread, arrayOrIterableType, undefinedType, node.expression);
         }
 
         function hasDefaultValue(node: BindingElement | Expression): boolean {
@@ -19173,7 +19314,7 @@ namespace ts {
                     // if there is no index type / iterated type.
                     const restArrayType = checkExpression((<SpreadElement>e).expression, checkMode, forceTuple);
                     const restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
-                        getIteratedTypeOrElementType(restArrayType, /*errorNode*/ undefined, /*allowStringInput*/ false, /*allowAsyncIterables*/ false, /*checkAssignability*/ false);
+                        getIteratedTypeOrElementType(IterationUse.Destructuring, restArrayType, undefinedType, /*errorNode*/ undefined, /*checkAssignability*/ false);
                     if (restElementType) {
                         elementTypes.push(restElementType);
                     }
@@ -22937,106 +23078,128 @@ namespace ts {
             }
 
             const functionFlags = getFunctionFlags(func);
-            let type: Type;
-            if (func.body.kind !== SyntaxKind.Block) {
-                type = checkExpressionCached(func.body, checkMode && checkMode & ~CheckMode.SkipGenericFunctions);
-                if (functionFlags & FunctionFlags.Async) {
+            const isAsync = (functionFlags & FunctionFlags.Async) !== 0;
+            const isGenerator = (functionFlags & FunctionFlags.Generator) !== 0;
+
+            let returnType: Type | undefined;
+            let yieldType: Type | undefined;
+            let nextType: Type | undefined;
+            let fallbackReturnType: Type = voidType;
+            if (func.body.kind !== SyntaxKind.Block) { // Async or normal arrow function
+                returnType = checkExpressionCached(func.body, checkMode && checkMode & ~CheckMode.SkipGenericFunctions);
+                if (isAsync) {
                     // From within an async function you can return either a non-promise value or a promise. Any
                     // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
                     // return type of the body should be unwrapped to its awaited type, which we will wrap in
                     // the native Promise<T> type later in this function.
-                    type = checkAwaitedType(type, /*errorNode*/ func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
+                    returnType = checkAwaitedType(returnType, /*errorNode*/ func, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
                 }
             }
-            else {
-                let types = checkAndAggregateReturnExpressionTypes(func, checkMode);
-                if (functionFlags & FunctionFlags.Generator) { // Generator or AsyncGenerator function
-                    types = concatenate(checkAndAggregateYieldOperandTypes(func, checkMode), types);
-                    if (!types || types.length === 0) {
-                        const iterableIteratorAny = functionFlags & FunctionFlags.Async
-                            ? createAsyncIterableIteratorType(anyType) // AsyncGenerator function
-                            : createIterableIteratorType(anyType); // Generator function
-                        if (noImplicitAny) {
-                            error(func.asteriskToken,
-                                Diagnostics.Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type, typeToString(iterableIteratorAny));
-                        }
-                        return iterableIteratorAny;
-                    }
+            else if (isGenerator) { // Generator or AsyncGenerator function
+                const returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode);
+                if (!returnTypes) {
+                    fallbackReturnType = neverType;
                 }
-                else {
-                    if (!types) {
-                        // For an async function, the return type will not be never, but rather a Promise for never.
-                        return functionFlags & FunctionFlags.Async
-                            ? createPromiseReturnType(func, neverType) // Async function
-                            : neverType; // Normal function
+                else if (returnTypes.length > 0) {
+                    returnType = getUnionType(returnTypes, UnionReduction.Subtype);
+                }
+                const { yieldTypes, nextTypes } = checkAndAggregateYieldOperandTypes(func, checkMode);
+                yieldType = some(yieldTypes) ? getUnionType(yieldTypes, UnionReduction.Subtype) : undefined;
+                nextType = some(nextTypes) ? getIntersectionType(nextTypes) : undefined;
+            }
+            else { // Async or normal function
+                const types = checkAndAggregateReturnExpressionTypes(func, checkMode);
+                if (!types) {
+                    // For an async function, the return type will not be never, but rather a Promise for never.
+                    return functionFlags & FunctionFlags.Async
+                        ? createPromiseReturnType(func, neverType) // Async function
+                        : neverType; // Normal function
+                }
+                if (types.length === 0) {
+                    // For an async function, the return type will not be void, but rather a Promise for void.
+                    return functionFlags & FunctionFlags.Async
+                        ? createPromiseReturnType(func, voidType) // Async function
+                        : voidType; // Normal function
+                }
+
+                // Return a union of the return expression types.
+                returnType = getUnionType(types, UnionReduction.Subtype);
+            }
+
+            if (returnType || yieldType || nextType) {
+                const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
+                if (!contextualSignature) {
+                    if (yieldType) reportErrorsFromWidening(func, yieldType, WideningKind.GeneratorYield);
+                    if (returnType) reportErrorsFromWidening(func, returnType);
+                    if (nextType) reportErrorsFromWidening(func, nextType);
+                }
+                if (returnType && isUnitType(returnType) ||
+                    yieldType && isUnitType(yieldType) ||
+                    nextType && isUnitType(nextType)) {
+                    const contextualType = !contextualSignature ? undefined :
+                        contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType :
+                        getReturnTypeOfSignature(contextualSignature);
+                    if (isGenerator) {
+                        yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, IterationTypeKind.Yield, isAsync);
+                        returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, IterationTypeKind.Return, isAsync);
+                        nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, IterationTypeKind.Next, isAsync);
                     }
-                    if (types.length === 0) {
-                        // For an async function, the return type will not be void, but rather a Promise for void.
-                        return functionFlags & FunctionFlags.Async
-                            ? createPromiseReturnType(func, voidType) // Async function
-                            : voidType; // Normal function
+                    else {
+                        returnType = getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(returnType, contextualType, isAsync);
                     }
                 }
 
-                // Return a union of the return expression types.
-                type = getUnionType(types, UnionReduction.Subtype);
+                if (yieldType) yieldType = getWidenedType(yieldType);
+                if (returnType) returnType = getWidenedType(returnType);
+                if (nextType) nextType = getWidenedType(nextType);
             }
 
-            const contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
-            if (!contextualSignature) {
-                reportErrorsFromWidening(func, type);
+            if (isGenerator) {
+                return createGeneratorReturnType(yieldType || neverType, returnType || fallbackReturnType, nextType || unknownType, isAsync);
             }
-
-            if (isUnitType(type)) {
-                let contextualType = !contextualSignature ? undefined :
-                    contextualSignature === getSignatureFromDeclaration(func) ? type :
-                    getReturnTypeOfSignature(contextualSignature);
-                if (contextualType) {
-                    switch (functionFlags & FunctionFlags.AsyncGenerator) {
-                        case FunctionFlags.AsyncGenerator:
-                            contextualType = getIteratedTypeOfGenerator(contextualType, /*isAsyncGenerator*/ true);
-                            break;
-                        case FunctionFlags.Generator:
-                            contextualType = getIteratedTypeOfGenerator(contextualType, /*isAsyncGenerator*/ false);
-                            break;
-                        case FunctionFlags.Async:
-                            contextualType = getPromisedTypeOfPromise(contextualType);
-                            break;
-                    }
-                }
-                type = getWidenedLiteralLikeTypeForContextualType(type, contextualType);
+            else {
+                // From within an async function you can return either a non-promise value or a promise. Any
+                // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
+                // return type of the body is awaited type of the body, wrapped in a native Promise<T> type.
+                return isAsync
+                    ? createPromiseType(returnType || fallbackReturnType)
+                    : returnType || fallbackReturnType;
             }
+        }
 
-            const widenedType = getWidenedType(type);
-            switch (functionFlags & FunctionFlags.AsyncGenerator) {
-                case FunctionFlags.AsyncGenerator:
-                    return createAsyncIterableIteratorType(widenedType);
-                case FunctionFlags.Generator:
-                    return createIterableIteratorType(widenedType);
-                case FunctionFlags.Async:
-                    // From within an async function you can return either a non-promise value or a promise. Any
-                    // Promise/A+ compatible implementation will always assimilate any foreign promise, so the
-                    // return type of the body is awaited type of the body, wrapped in a native Promise<T> type.
-                    return createPromiseType(widenedType);
-                default:
-                    return widenedType;
-            }
+        function createGeneratorReturnType(yieldType: Type, returnType: Type, nextType: Type, isAsyncGenerator: boolean) {
+            return isAsyncGenerator
+                ? createAsyncGeneratorType(yieldType, returnType, nextType)
+                : createGeneratorType(yieldType, returnType, nextType);
         }
 
-        function checkAndAggregateYieldOperandTypes(func: FunctionLikeDeclaration, checkMode: CheckMode | undefined): Type[] {
-            const aggregatedTypes: Type[] = [];
+        function checkAndAggregateYieldOperandTypes(func: FunctionLikeDeclaration, checkMode: CheckMode | undefined) {
+            const yieldTypes: Type[] = [];
+            const nextTypes: Type[] = [];
             const isAsync = (getFunctionFlags(func) & FunctionFlags.Async) !== 0;
             forEachYieldExpression(<Block>func.body, yieldExpression => {
-                pushIfUnique(aggregatedTypes, getYieldedTypeOfYieldExpression(yieldExpression, isAsync, checkMode));
+                const yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType;
+                pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync));
+                let nextType: Type | undefined;
+                if (yieldExpression.asteriskToken) {
+                    const iterationTypes = getIterationTypesOfIterable(
+                        yieldExpressionType,
+                        isAsync ? IterationUse.AsyncYieldStar : IterationUse.YieldStar,
+                        yieldExpression.expression);
+                    nextType = iterationTypes && iterationTypes.nextType;
+                }
+                else {
+                    nextType = getContextualType(yieldExpression);
+                }
+                if (nextType) pushIfUnique(nextTypes, nextType);
             });
-            return aggregatedTypes;
+            return { yieldTypes, nextTypes };
         }
 
-        function getYieldedTypeOfYieldExpression(node: YieldExpression, isAsync: boolean, checkMode?: CheckMode): Type | undefined {
+        function getYieldedTypeOfYieldExpression(node: YieldExpression, expressionType: Type, sentType: Type, isAsync: boolean): Type | undefined {
             const errorNode = node.expression || node;
-            const expressionType = node.expression ? checkExpression(node.expression, checkMode) : undefinedWideningType;
             // A `yield*` expression effectively yields everything that its operand yields
-            const yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(expressionType, errorNode, /*allowStringInput*/ false, isAsync) : expressionType;
+            const yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? IterationUse.AsyncYieldStar : IterationUse.YieldStar, expressionType, sentType, errorNode) : expressionType;
             return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken
                 ? Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
                 : Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
@@ -23182,8 +23345,11 @@ namespace ts {
                 return;
             }
 
+            const functionFlags = getFunctionFlags(func);
+            const type = returnType && getReturnOrPromisedType(returnType, functionFlags);
+
             // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions.
-            if (returnType && maybeTypeOfKind(returnType, TypeFlags.Any | TypeFlags.Void)) {
+            if (type && maybeTypeOfKind(type, TypeFlags.Any | TypeFlags.Void)) {
                 return;
             }
 
@@ -23195,20 +23361,20 @@ namespace ts {
 
             const hasExplicitReturn = func.flags & NodeFlags.HasExplicitReturn;
 
-            if (returnType && returnType.flags & TypeFlags.Never) {
+            if (type && type.flags & TypeFlags.Never) {
                 error(getEffectiveReturnTypeNode(func), Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point);
             }
-            else if (returnType && !hasExplicitReturn) {
+            else if (type && !hasExplicitReturn) {
                 // minimal check: function has syntactic return type annotation and no explicit return statements in the body
                 // this function does not conform to the specification.
                 // NOTE: having returnType !== undefined is a precondition for entering this branch so func.type will always be present
                 error(getEffectiveReturnTypeNode(func), Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
             }
-            else if (returnType && strictNullChecks && !isTypeAssignableTo(undefinedType, returnType)) {
+            else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
                 error(getEffectiveReturnTypeNode(func), Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
             }
             else if (compilerOptions.noImplicitReturns) {
-                if (!returnType) {
+                if (!type) {
                     // If return type annotation is omitted check if function has any explicit return statements.
                     // If it does not have any - its inferred return type is void - don't do any checks.
                     // Otherwise get inferred return type from function body and report error only if it is not void / anytype
@@ -23298,22 +23464,20 @@ namespace ts {
             }
         }
 
-        function getReturnOrPromisedType(node: FunctionLikeDeclaration | MethodSignature, functionFlags: FunctionFlags) {
-            const type = getReturnTypeFromAnnotation(node);
-            return type && ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async) ?
-                getAwaitedType(type) || errorType : type;
+        function getReturnOrPromisedType(type: Type | undefined, functionFlags: FunctionFlags) {
+            const isGenerator = !!(functionFlags & FunctionFlags.Generator);
+            const isAsync = !!(functionFlags & FunctionFlags.Async);
+            return type && isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, type, isAsync) || errorType :
+                type && isAsync ? getAwaitedType(type) || errorType :
+                type;
         }
 
         function checkFunctionExpressionOrObjectLiteralMethodDeferred(node: ArrowFunction | FunctionExpression | MethodDeclaration) {
             Debug.assert(node.kind !== SyntaxKind.MethodDeclaration || isObjectLiteralMethod(node));
 
             const functionFlags = getFunctionFlags(node);
-            const returnOrPromisedType = getReturnOrPromisedType(node, functionFlags);
-
-            if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function
-                // return is not necessary in the body of generators
-                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
-            }
+            const returnType = getReturnTypeFromAnnotation(node);
+            checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
 
             if (node.body) {
                 if (!getEffectiveReturnTypeNode(node)) {
@@ -23335,6 +23499,7 @@ namespace ts {
                     // check assignability of the awaited type of the expression body against the promised type of
                     // its return type annotation.
                     const exprType = checkExpression(node.body);
+                    const returnOrPromisedType = getReturnOrPromisedType(returnType, functionFlags);
                     if (returnOrPromisedType) {
                         if ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async) { // Async function
                             const awaitedType = checkAwaitedType(exprType, node.body, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
@@ -23737,7 +23902,7 @@ namespace ts {
             // This elementType will be used if the specific property corresponding to this index is not
             // present (aka the tuple element property). This call also checks that the parentType is in
             // fact an iterable or array (depending on target language).
-            const elementType = checkIteratedTypeOrElementType(sourceType, node, /*allowStringInput*/ false, /*allowAsyncIterables*/ false) || errorType;
+            const elementType = checkIteratedTypeOrElementType(IterationUse.Destructuring, sourceType, undefinedType, node) || errorType;
             for (let i = 0; i < elements.length; i++) {
                 checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, elementType, checkMode);
             }
@@ -24245,33 +24410,44 @@ namespace ts {
                 return anyType;
             }
 
+            const isAsync = (functionFlags & FunctionFlags.Async) !== 0;
             if (node.asteriskToken) {
                 // Async generator functions prior to ESNext require the __await, __asyncDelegator,
                 // and __asyncValues helpers
-                if ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.AsyncGenerator &&
-                    languageVersion < ScriptTarget.ESNext) {
+                if (isAsync && languageVersion < ScriptTarget.ESNext) {
                     checkExternalEmitHelpers(node, ExternalEmitHelpers.AsyncDelegatorIncludes);
                 }
 
                 // Generator functions prior to ES2015 require the __values helper
-                if ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Generator &&
-                    languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) {
+                if (!isAsync && languageVersion < ScriptTarget.ES2015 && compilerOptions.downlevelIteration) {
                     checkExternalEmitHelpers(node, ExternalEmitHelpers.Values);
                 }
             }
 
-            const isAsync = (functionFlags & FunctionFlags.Async) !== 0;
-            const yieldedType = getYieldedTypeOfYieldExpression(node, isAsync)!; // TODO: GH#18217
             // There is no point in doing an assignability check if the function
             // has no explicit return type because the return type is directly computed
             // from the yield expressions.
             const returnType = getReturnTypeFromAnnotation(func);
-            if (returnType) {
-                const signatureElementType = getIteratedTypeOfGenerator(returnType, isAsync) || anyType;
-                checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureElementType, node.expression || node, node.expression);
+            const iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync);
+            const signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType;
+            const signatureNextType = iterationTypes && iterationTypes.nextType || anyType;
+            const resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType;
+            const yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType;
+            const yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync);
+            if (returnType && yieldedType) {
+                checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression);
+            }
+
+            if (node.asteriskToken) {
+                const use = isAsync ? IterationUse.AsyncYieldStar : IterationUse.YieldStar;
+                return getIterationTypeOfIterable(use, IterationTypeKind.Return, yieldExpressionType, node.expression)
+                    || anyType;
+            }
+            else if (returnType) {
+                return getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Next, returnType, isAsync)
+                    || anyType;
             }
 
-            // Both yield and yield* expressions have type 'any'
             return anyType;
         }
 
@@ -24989,18 +25165,17 @@ namespace ts {
                             error(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
                         }
                         else {
-                            const generatorElementType = getIteratedTypeOfGenerator(returnType, (functionFlags & FunctionFlags.Async) !== 0) || anyType;
-                            const iterableIteratorInstantiation = functionFlags & FunctionFlags.Async
-                                ? createAsyncIterableIteratorType(generatorElementType) // AsyncGenerator function
-                                : createIterableIteratorType(generatorElementType); // Generator function
-
-                            // Naively, one could check that IterableIterator<any> is assignable to the return type annotation.
+                            // Naively, one could check that Generator<any, any, any> is assignable to the return type annotation.
                             // However, that would not catch the error in the following case.
                             //
                             //    interface BadGenerator extends Iterable<number>, Iterator<string> { }
                             //    function* g(): BadGenerator { } // Iterable and Iterator have different types!
                             //
-                            checkTypeAssignableTo(iterableIteratorInstantiation, returnType, returnTypeNode);
+                            const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Yield, returnType, (functionFlags & FunctionFlags.Async) !== 0) || anyType;
+                            const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, returnType, (functionFlags & FunctionFlags.Async) !== 0) || generatorYieldType;
+                            const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Next, returnType, (functionFlags & FunctionFlags.Async) !== 0) || unknownType;
+                            const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags & FunctionFlags.Async));
+                            checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
                         }
                     }
                     else if ((functionFlags & FunctionFlags.AsyncGenerator) === FunctionFlags.Async) {
@@ -25891,9 +26066,9 @@ namespace ts {
             }
         }
 
-        function getAwaitedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+        function getAwaitedTypeOfPromise(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
             const promisedType = getPromisedTypeOfPromise(type, errorNode);
-            return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage);
+            return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
         }
 
         /**
@@ -25961,11 +26136,11 @@ namespace ts {
          * Promise-like type; otherwise, it is the type of the expression. This is used to reflect
          * The runtime behavior of the `await` keyword.
          */
-        function checkAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage): Type {
-            return getAwaitedType(type, errorNode, diagnosticMessage) || errorType;
+        function checkAwaitedType(type: Type, errorNode: Node, diagnosticMessage: DiagnosticMessage, arg0?: string | number): Type {
+            return getAwaitedType(type, errorNode, diagnosticMessage, arg0) || errorType;
         }
 
-        function getAwaitedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage): Type | undefined {
+        function getAwaitedType(type: Type, errorNode?: Node, diagnosticMessage?: DiagnosticMessage, arg0?: string | number): Type | undefined {
             const typeAsAwaitable = <PromiseOrAwaitableType>type;
             if (typeAsAwaitable.awaitedTypeOfType) {
                 return typeAsAwaitable.awaitedTypeOfType;
@@ -25978,7 +26153,7 @@ namespace ts {
             if (type.flags & TypeFlags.Union) {
                 let types: Type[] | undefined;
                 for (const constituentType of (<UnionType>type).types) {
-                    types = append<Type>(types, getAwaitedType(constituentType, errorNode, diagnosticMessage));
+                    types = append<Type>(types, getAwaitedType(constituentType, errorNode, diagnosticMessage, arg0));
                 }
 
                 if (!types) {
@@ -26032,7 +26207,7 @@ namespace ts {
                 // Keep track of the type we're about to unwrap to avoid bad recursive promise types.
                 // See the comments above for more information.
                 awaitedTypeStack.push(type.id);
-                const awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage);
+                const awaitedType = getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
                 awaitedTypeStack.pop();
 
                 if (!awaitedType) {
@@ -26061,7 +26236,7 @@ namespace ts {
             if (thenFunction && getSignaturesOfType(thenFunction, SignatureKind.Call).length > 0) {
                 if (errorNode) {
                     if (!diagnosticMessage) return Debug.fail();
-                    error(errorNode, diagnosticMessage);
+                    error(errorNode, diagnosticMessage, arg0);
                 }
                 return undefined;
             }
@@ -26545,11 +26720,7 @@ namespace ts {
 
             const body = node.kind === SyntaxKind.MethodSignature ? undefined : node.body;
             checkSourceElement(body);
-
-            if ((functionFlags & FunctionFlags.Generator) === 0) { // Async function or normal function
-                const returnOrPromisedType = getReturnOrPromisedType(node, functionFlags);
-                checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnOrPromisedType);
-            }
+            checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node));
 
             if (produceDiagnostics && !getEffectiveReturnTypeNode(node)) {
                 // Report an implicit any error if there is no body, no explicit return type, and node is not a private method
@@ -27151,7 +27322,7 @@ namespace ts {
                     // check the binding pattern with empty elements
                     if (needCheckWidenedType) {
                         if (isArrayBindingPattern(node.name)) {
-                            checkIteratedTypeOrElementType(widenedType, node, /* allowStringInput */ false, /* allowAsyncIterables */ false);
+                            checkIteratedTypeOrElementType(IterationUse.Destructuring, widenedType, undefinedType, node);
                         }
                         else if (strictNullChecks) {
                             checkNonNullNonVoidType(widenedType, node);
@@ -27449,15 +27620,16 @@ namespace ts {
 
         function checkRightHandSideOfForOf(rhsExpression: Expression, awaitModifier: AwaitKeywordToken | undefined): Type {
             const expressionType = checkNonNullExpression(rhsExpression);
-            return checkIteratedTypeOrElementType(expressionType, rhsExpression, /*allowStringInput*/ true, awaitModifier !== undefined);
+            const use = awaitModifier ? IterationUse.ForAwaitOf : IterationUse.ForOf;
+            return checkIteratedTypeOrElementType(use, expressionType, undefinedType, rhsExpression);
         }
 
-        function checkIteratedTypeOrElementType(inputType: Type, errorNode: Node | undefined, allowStringInput: boolean, allowAsyncIterables: boolean): Type {
+        function checkIteratedTypeOrElementType(use: IterationUse, inputType: Type, sentType: Type, errorNode: Node | undefined): Type {
             if (isTypeAny(inputType)) {
                 return inputType;
             }
 
-            return getIteratedTypeOrElementType(inputType, errorNode, allowStringInput, allowAsyncIterables, /*checkAssignability*/ true) || anyType;
+            return getIteratedTypeOrElementType(use, inputType, sentType, errorNode, /*checkAssignability*/ true) || anyType;
         }
 
         /**
@@ -27465,7 +27637,8 @@ namespace ts {
          * we want to get the iterated type of an iterable for ES2015 or later, or the iterated type
          * of a iterable (if defined globally) or element type of an array like for ES2015 or earlier.
          */
-        function getIteratedTypeOrElementType(inputType: Type, errorNode: Node | undefined, allowStringInput: boolean, allowAsyncIterables: boolean, checkAssignability: boolean): Type | undefined {
+        function getIteratedTypeOrElementType(use: IterationUse, inputType: Type, sentType: Type, errorNode: Node | undefined, checkAssignability: boolean): Type | undefined {
+            const allowAsyncIterables = (use & IterationUse.AllowsAsyncIterablesFlag) !== 0;
             if (inputType === neverType) {
                 reportTypeNotIterableError(errorNode!, inputType, allowAsyncIterables); // TODO: GH#18217
                 return undefined;
@@ -27479,9 +27652,22 @@ namespace ts {
             // downlevelIteration is requested.
             if (uplevelIteration || downlevelIteration || allowAsyncIterables) {
                 // We only report errors for an invalid iterable type in ES2015 or higher.
-                const iteratedType = getIteratedTypeOfIterable(inputType, uplevelIteration ? errorNode : undefined, allowAsyncIterables, /*allowSyncIterables*/ true, checkAssignability);
-                if (iteratedType || uplevelIteration) {
-                    return iteratedType;
+                const iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : undefined);
+                if (checkAssignability) {
+                    if (iterationTypes) {
+                        const diagnostic =
+                            use & IterationUse.ForOfFlag ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 :
+                            use & IterationUse.SpreadFlag ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 :
+                            use & IterationUse.DestructuringFlag ? Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 :
+                            use & IterationUse.YieldStarFlag ? Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 :
+                            undefined;
+                        if (diagnostic) {
+                            checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic);
+                        }
+                    }
+                }
+                if (iterationTypes || uplevelIteration) {
+                    return iterationTypes && iterationTypes.yieldType;
                 }
             }
 
@@ -27492,7 +27678,7 @@ namespace ts {
             // If strings are permitted, remove any string-like constituents from the array type.
             // This allows us to find other non-string element types from an array unioned with
             // a string.
-            if (allowStringInput) {
+            if (use & IterationUse.AllowsStringInputFlag) {
                 if (arrayType.flags & TypeFlags.Union) {
                     // After we remove all types that are StringLike, we will know if there was a string constituent
                     // based on whether the result of filter is a new array.
@@ -27530,16 +27716,16 @@ namespace ts {
                     // want to say that number is not an array type. But if the input was just
                     // number and string input is allowed, we want to say that number is not an
                     // array type or a string type.
-                    const isIterable = !!getIteratedTypeOfIterable(inputType, /* errorNode */ undefined, allowAsyncIterables, /*allowSyncIterables*/ true, checkAssignability);
-                    const diagnostic = !allowStringInput || hasStringConstituent
+                    const yieldType = getIterationTypeOfIterable(use, IterationTypeKind.Yield, inputType, /*errorNode*/ undefined);
+                    const diagnostic = !(use & IterationUse.AllowsStringInputFlag) || hasStringConstituent
                         ? downlevelIteration
                             ? Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator
-                            : isIterable
+                            : yieldType
                                 ? Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators
                                 : Diagnostics.Type_0_is_not_an_array_type
                         : downlevelIteration
                             ? Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator
-                            : isIterable
+                            : yieldType
                                 ? Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators
                                 : Diagnostics.Type_0_is_not_an_array_type_or_a_string_type;
                     error(errorNode, diagnostic, typeToString(arrayType));
@@ -27561,33 +27747,82 @@ namespace ts {
         }
 
         /**
-         * We want to treat type as an iterable, and get the type it is an iterable of. The iterable
-         * must have the following structure (annotated with the names of the variables below):
-         *
-         *     { // iterable
-         *         [Symbol.iterator]: { // iteratorMethod
-         *             (): Iterator<T>
-         *         }
-         *     }
-         *
-         * For an async iterable, we expect the following structure:
+         * Gets the requested "iteration type" from an `Iterable`-like or `AsyncIterable`-like type.
+         */
+        function getIterationTypeOfIterable(use: IterationUse, typeKind: IterationTypeKind, inputType: Type, errorNode: Node | undefined): Type | undefined {
+            if (isTypeAny(inputType)) {
+                return undefined;
+            }
+
+            const iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode);
+            return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)];
+        }
+
+        function createIterationTypes(yieldType: Type = neverType, returnType: Type = neverType, nextType: Type = unknownType): IterationTypes {
+            // `yieldType` and `returnType` are defaulted to `neverType` they each will be combined
+            // via `getUnionType` when merging iteration types. `nextType` is defined as `unknownType`
+            // as it is combined via `getIntersectionType` when merging iteration types.
+
+            // Use the cache only for intrinsic types to keep it small as they are likely to be
+            // more frequently created (i.e. `Iterator<number, void, unknown>`). Iteration types
+            // are also cached on the type they are requested for, so we shouldn't need to maintain
+            // the cache for less-frequently used types.
+            if (yieldType.flags & TypeFlags.Intrinsic &&
+                returnType.flags & (TypeFlags.Any | TypeFlags.Never | TypeFlags.Unknown | TypeFlags.Void | TypeFlags.Undefined) &&
+                nextType.flags & (TypeFlags.Any | TypeFlags.Never | TypeFlags.Unknown | TypeFlags.Void | TypeFlags.Undefined)) {
+                const id = getTypeListId([yieldType, returnType, nextType]);
+                let iterationTypes = iterationTypesCache.get(id);
+                if (!iterationTypes) {
+                    iterationTypes = { yieldType, returnType, nextType };
+                    iterationTypesCache.set(id, iterationTypes);
+                }
+                return iterationTypes;
+            }
+            return { yieldType, returnType, nextType };
+        }
+
+        /**
+         * Combines multiple `IterationTypes` records.
          *
-         *     { // iterable
-         *         [Symbol.asyncIterator]: { // iteratorMethod
-         *             (): AsyncIterator<T>
-         *         }
-         *     }
+         * If `array` is empty or all elements are missing or are references to `noIterationTypes`,
+         * then `noIterationTypes` is returned. Otherwise, an `IterationTypes` record is returned
+         * for the combined iteration types.
+         */
+        function combineIterationTypes(array: (IterationTypes | undefined)[]) {
+            let yieldTypes: Type[] | undefined;
+            let returnTypes: Type[] | undefined;
+            let nextTypes: Type[] | undefined;
+            for (const iterationTypes of array) {
+                if (iterationTypes === undefined || iterationTypes === noIterationTypes) {
+                    continue;
+                }
+                if (iterationTypes === anyIterationTypes) {
+                    return anyIterationTypes;
+                }
+                yieldTypes = append(yieldTypes, iterationTypes.yieldType);
+                returnTypes = append(returnTypes, iterationTypes.returnType);
+                nextTypes = append(nextTypes, iterationTypes.nextType);
+            }
+            if (yieldTypes || returnTypes || nextTypes) {
+                return createIterationTypes(
+                    yieldTypes && getUnionType(yieldTypes),
+                    returnTypes && getUnionType(returnTypes),
+                    nextTypes && getIntersectionType(nextTypes));
+            }
+            return noIterationTypes;
+        }
+
+        /**
+         * Gets the *yield*, *return*, and *next* types from an `Iterable`-like or `AsyncIterable`-like type.
          *
-         * T is the type we are after. At every level that involves analyzing return types
-         * of signatures, we union the return types of all the signatures.
+         * At every level that involves analyzing return types of signatures, we union the return types of all the signatures.
          *
          * Another thing to note is that at any step of this process, we could run into a dead end,
          * meaning either the property is missing, or we run into the anyType. If either of these things
-         * happens, we return undefined to signal that we could not find the iterated type. If a property
-         * is missing, and the previous step did not result in 'any', then we also give an error if the
+         * happens, we return `undefined` to signal that we could not find the iteration type. If a property
+         * is missing, and the previous step did not result in `any`, then we also give an error if the
          * caller requested it. Then the caller can decide what to do in the case where there is no iterated
-         * type. This is different from returning anyType, because that would signify that we have matched the
-         * whole pattern and that T (above) is 'any'.
+         * type.
          *
          * For a **for-of** statement, `yield*` (in a normal generator), spread, array
          * destructuring, or normal generator we will only ever look for a `[Symbol.iterator]()`
@@ -27598,78 +27833,197 @@ namespace ts {
          * For a **for-await-of** statement or a `yield*` in an async generator we will look for
          * the `[Symbol.asyncIterator]()` method first, and then the `[Symbol.iterator]()` method.
          */
-        function getIteratedTypeOfIterable(type: Type, errorNode: Node | undefined, allowAsyncIterables: boolean, allowSyncIterables: boolean, checkAssignability: boolean): Type | undefined {
+        function getIterationTypesOfIterable(type: Type, use: IterationUse, errorNode: Node | undefined) {
             if (isTypeAny(type)) {
-                return undefined;
+                return anyIterationTypes;
             }
 
-            return mapType(type, getIteratedType);
-
-            function getIteratedType(type: Type) {
-                const typeAsIterable = <IterableOrIteratorType>type;
-                if (allowAsyncIterables) {
-                    if (typeAsIterable.iteratedTypeOfAsyncIterable) {
-                        return typeAsIterable.iteratedTypeOfAsyncIterable;
-                    }
-
-                    // As an optimization, if the type is an instantiation of the global `AsyncIterable<T>`
-                    // or the global `AsyncIterableIterator<T>` then just grab its type argument.
-                    if (isReferenceToType(type, getGlobalAsyncIterableType(/*reportErrors*/ false)) ||
-                        isReferenceToType(type, getGlobalAsyncIterableIteratorType(/*reportErrors*/ false))) {
-                        return typeAsIterable.iteratedTypeOfAsyncIterable = (<GenericType>type).typeArguments![0];
+            if (!(type.flags & TypeFlags.Union)) {
+                const iterationTypes = getIterationTypesOfIterableWorker(type, use, errorNode);
+                if (iterationTypes === noIterationTypes) {
+                    if (errorNode) {
+                        reportTypeNotIterableError(errorNode, type, !!(use & IterationUse.AllowsAsyncIterablesFlag));
                     }
+                    return undefined;
                 }
+                return iterationTypes;
+            }
 
-                if (allowSyncIterables) {
-                    if (typeAsIterable.iteratedTypeOfIterable) {
-                        return allowAsyncIterables
-                            ? typeAsIterable.iteratedTypeOfAsyncIterable = getAwaitedType(typeAsIterable.iteratedTypeOfIterable)
-                            : typeAsIterable.iteratedTypeOfIterable;
-                    }
+            const cacheKey = use & IterationUse.AllowsAsyncIterablesFlag ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable";
+            const cachedTypes = (type as IterableOrIteratorType)[cacheKey];
+            if (cachedTypes) return cachedTypes === noIterationTypes ? undefined : cachedTypes;
 
-                    // As an optimization, if the type is an instantiation of the global `Iterable<T>` or
-                    // `IterableIterator<T>` then just grab its type argument.
-                    if (isReferenceToType(type, getGlobalIterableType(/*reportErrors*/ false)) ||
-                        isReferenceToType(type, getGlobalIterableIteratorType(/*reportErrors*/ false))) {
-                        return allowAsyncIterables
-                            ? typeAsIterable.iteratedTypeOfAsyncIterable = getAwaitedType((<GenericType>type).typeArguments![0])
-                            : typeAsIterable.iteratedTypeOfIterable = (<GenericType>type).typeArguments![0];
+            let allIterationTypes: IterationTypes[] | undefined;
+            for (const constituent of (type as UnionType).types) {
+                const iterationTypes = getIterationTypesOfIterableWorker(constituent, use, errorNode);
+                if (iterationTypes === noIterationTypes) {
+                    if (errorNode) {
+                        reportTypeNotIterableError(errorNode, type, !!(use & IterationUse.AllowsAsyncIterablesFlag));
+                        errorNode = undefined;
                     }
                 }
+                else {
+                    allIterationTypes = append(allIterationTypes, iterationTypes);
+                }
+            }
 
-                const asyncMethodType = allowAsyncIterables && getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("asyncIterator"));
-                const methodType = asyncMethodType || (allowSyncIterables ? getTypeOfPropertyOfType(type, getPropertyNameForKnownSymbolName("iterator")) : undefined);
-                if (isTypeAny(methodType)) {
-                    return undefined;
+            const iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes;
+            (type as IterableOrIteratorType)[cacheKey] = iterationTypes;
+            return iterationTypes === noIterationTypes ? undefined : iterationTypes;
+        }
+
+        function getAsyncFromSyncIterationTypes(iterationTypes: IterationTypes, errorNode: Node | undefined) {
+            if (iterationTypes === noIterationTypes) return noIterationTypes;
+            if (iterationTypes === anyIterationTypes) return anyIterationTypes;
+            const { yieldType, returnType, nextType } = iterationTypes;
+            return createIterationTypes(
+                getAwaitedType(yieldType, errorNode) || anyType,
+                getAwaitedType(returnType, errorNode) || anyType,
+                nextType);
+        }
+
+        /**
+         * Gets the *yield*, *return*, and *next* types from a non-union type.
+         *
+         * If we are unable to find the *yield*, *return*, and *next* types, `noIterationTypes` is
+         * returned to indicate to the caller that it should report an error. Otherwise, an
+         * `IterationTypes` record is returned.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterable` instead.
+         */
+        function getIterationTypesOfIterableWorker(type: Type, use: IterationUse, errorNode: Node | undefined) {
+            if (isTypeAny(type)) {
+                return anyIterationTypes;
+            }
+
+            if (use & IterationUse.AllowsAsyncIterablesFlag) {
+                const iterationTypes =
+                    getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) ||
+                    getIterationTypesOfIterableFast(type, asyncIterationTypesResolver);
+                if (iterationTypes) {
+                    return iterationTypes;
                 }
+            }
 
-                const signatures = methodType ? getSignaturesOfType(methodType, SignatureKind.Call) : undefined;
-                if (!some(signatures)) {
-                    if (errorNode) {
-                        // only report on the first error
-                        reportTypeNotIterableError(errorNode, type, allowAsyncIterables);
-                        errorNode = undefined;
+            if (use & IterationUse.AllowsSyncIterablesFlag) {
+                const iterationTypes =
+                    getIterationTypesOfIterableCached(type, syncIterationTypesResolver) ||
+                    getIterationTypesOfIterableFast(type, syncIterationTypesResolver);
+                if (iterationTypes) {
+                    if (use & IterationUse.AllowsAsyncIterablesFlag) {
+                        // for a sync iterable in an async context, only use the cached types if they are valid.
+                        if (iterationTypes !== noIterationTypes) {
+                            return (type as IterableOrIteratorType).iterationTypesOfAsyncIterable = getAsyncFromSyncIterationTypes(iterationTypes, errorNode);
+                        }
+                    }
+                    else {
+                        return iterationTypes;
                     }
-                    return undefined;
                 }
+            }
 
-                const returnType = getUnionType(map(signatures, getReturnTypeOfSignature), UnionReduction.Subtype);
-                const iteratedType = getIteratedTypeOfIterator(returnType, errorNode, /*isAsyncIterator*/ !!asyncMethodType);
-                if (checkAssignability && errorNode && iteratedType) {
-                    // If `checkAssignability` was specified, we were called from
-                    // `checkIteratedTypeOrElementType`. As such, we need to validate that
-                    // the type passed in is actually an Iterable.
-                    checkTypeAssignableTo(type, asyncMethodType
-                        ? createAsyncIterableType(iteratedType)
-                        : createIterableType(iteratedType), errorNode);
+            if (use & IterationUse.AllowsAsyncIterablesFlag) {
+                const iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode);
+                if (iterationTypes !== noIterationTypes) {
+                    return iterationTypes;
                 }
+            }
 
-                if (iteratedType) {
-                    return allowAsyncIterables
-                        ? typeAsIterable.iteratedTypeOfAsyncIterable = asyncMethodType ? iteratedType : getAwaitedType(iteratedType)
-                        : typeAsIterable.iteratedTypeOfIterable = iteratedType;
+            if (use & IterationUse.AllowsSyncIterablesFlag) {
+                const iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode);
+                if (iterationTypes !== noIterationTypes) {
+                    if (use & IterationUse.AllowsAsyncIterablesFlag) {
+                        return (type as IterableOrIteratorType).iterationTypesOfAsyncIterable = iterationTypes
+                            ? getAsyncFromSyncIterationTypes(iterationTypes, errorNode)
+                            : noIterationTypes;
+                    }
+                    else {
+                        return iterationTypes;
+                    }
                 }
             }
+
+            return noIterationTypes;
+        }
+
+        /**
+         * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or
+         * `AsyncIterable`-like type from the cache.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterable` instead.
+         */
+        function getIterationTypesOfIterableCached(type: Type, resolver: IterationTypesResolver) {
+            return (type as IterableOrIteratorType)[resolver.iterableCacheKey];
+        }
+
+        /**
+         * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like
+         * type from from common heuristics.
+         *
+         * If we previously analyzed this type and found no iteration types, `noIterationTypes` is
+         * returned. If we found iteration types, an `IterationTypes` record is returned.
+         * Otherwise, we return `undefined` to indicate to the caller it should perform a more
+         * exhaustive analysis.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterable` instead.
+         */
+        function getIterationTypesOfIterableFast(type: Type, resolver: IterationTypesResolver) {
+            // As an optimization, if the type is an instantiation of one of the following global types, then
+            // just grab its related type argument:
+            // - `Iterable<T>` or `AsyncIterable<T>`
+            // - `IterableIterator<T>` or `AsyncIterableIterator<T>`
+            let globalType: Type;
+            if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(/*reportErrors*/ false)) ||
+                isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false))) {
+                const [yieldType] = (type as GenericType).typeArguments!;
+                // The "return" and "next" types of `Iterable` and `IterableIterator` are defined by the
+                // iteration types of their `[Symbol.iterator]()` method. The same is true for their async cousins.
+                // While we define these as `any` and `undefined` in our libs by default, a custom lib *could* use
+                // different definitions.
+                const globalIterationTypes =
+                    getIterationTypesOfIterableCached(globalType, resolver) ||
+                    getIterationTypesOfIterableSlow(globalType, resolver, /*errorNode*/ undefined);
+                const { returnType, nextType } = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
+                return (type as IterableOrIteratorType)[resolver.iterableCacheKey] = createIterationTypes(yieldType, returnType, nextType);
+            }
+
+            // As an optimization, if the type is an instantiation of the following global type, then
+            // just grab its related type arguments:
+            // - `Generator<T, TReturn, TNext>` or `AsyncGenerator<T, TReturn, TNext>`
+            if (isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) {
+                const [yieldType, returnType, nextType] = (type as GenericType).typeArguments!;
+                return (type as IterableOrIteratorType)[resolver.iterableCacheKey] = createIterationTypes(yieldType, returnType, nextType);
+            }
+        }
+
+        /**
+         * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like
+         * type from its members.
+         *
+         * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
+         * record is returned. Otherwise, `noIterationTypes` is returned.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterable` instead.
+         */
+        function getIterationTypesOfIterableSlow(type: Type, resolver: IterationTypesResolver, errorNode: Node | undefined) {
+            const method = getPropertyOfType(type, getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName));
+            const methodType = method && !(method.flags & SymbolFlags.Optional) ? getTypeOfSymbol(method) : undefined;
+            if (isTypeAny(methodType)) {
+                return (type as IterableOrIteratorType)[resolver.iterableCacheKey] = anyIterationTypes;
+            }
+
+            const signatures = methodType ? getSignaturesOfType(methodType, SignatureKind.Call) : undefined;
+            if (!some(signatures)) {
+                return (type as IterableOrIteratorType)[resolver.iterableCacheKey] = noIterationTypes;
+            }
+
+            const iteratorType = getUnionType(map(signatures, getReturnTypeOfSignature), UnionReduction.Subtype);
+            const iterationTypes = getIterationTypesOfIterator(iteratorType, resolver, errorNode) || noIterationTypes;
+            return (type as IterableOrIteratorType)[resolver.iterableCacheKey] = iterationTypes;
         }
 
         function reportTypeNotIterableError(errorNode: Node, type: Type, allowAsyncIterables: boolean): void {
@@ -27679,104 +28033,257 @@ namespace ts {
         }
 
         /**
-         * This function has very similar logic as getIteratedTypeOfIterable, except that it operates on
-         * Iterators instead of Iterables. Here is the structure:
+         * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type.
+         *
+         * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
+         * record is returned. Otherwise, `undefined` is returned.
+         */
+        function getIterationTypesOfIterator(type: Type, resolver: IterationTypesResolver, errorNode: Node | undefined) {
+            if (isTypeAny(type)) {
+                return anyIterationTypes;
+            }
+
+            const iterationTypes =
+                getIterationTypesOfIteratorCached(type, resolver) ||
+                getIterationTypesOfIteratorFast(type, resolver) ||
+                getIterationTypesOfIteratorSlow(type, resolver, errorNode);
+            return iterationTypes === noIterationTypes ? undefined : iterationTypes;
+        }
+
+        /**
+         * Gets the iteration types of an `Iterator`-like or `AsyncIterator`-like type from the
+         * cache.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterator` instead.
+         */
+        function getIterationTypesOfIteratorCached(type: Type, resolver: IterationTypesResolver) {
+            return (type as IterableOrIteratorType)[resolver.iteratorCacheKey];
+        }
+
+        /**
+         * Gets the iteration types of an `Iterator`-like or `AsyncIterator`-like type from the
+         * cache or from common heuristics.
          *
-         *  { // iterator
-         *      next: { // nextMethod
-         *          (): { // nextResult
-         *              value: T // nextValue
-         *          }
-         *      }
-         *  }
+         * If we previously analyzed this type and found no iteration types, `noIterationTypes` is
+         * returned. If we found iteration types, an `IterationTypes` record is returned.
+         * Otherwise, we return `undefined` to indicate to the caller it should perform a more
+         * exhaustive analysis.
          *
-         * For an async iterator, we expect the following structure:
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterator` instead.
+         */
+        function getIterationTypesOfIteratorFast(type: Type, resolver: IterationTypesResolver) {
+            // As an optimization, if the type is an instantiation of one of the following global types,
+            // then just grab its related type argument:
+            // - `IterableIterator<T>` or `AsyncIterableIterator<T>`
+            // - `Iterator<T, TReturn, TNext>` or `AsyncIterator<T, TReturn, TNext>`
+            // - `Generator<T, TReturn, TNext>` or `AsyncGenerator<T, TReturn, TNext>`
+            const globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false);
+            if (isReferenceToType(type, globalType)) {
+                const [yieldType] = (type as GenericType).typeArguments!;
+                // The "return" and "next" types of `IterableIterator` and `AsyncIterableIterator` are defined by the
+                // iteration types of their `next`, `return`, and `throw` methods. While we define these as `any`
+                // and `undefined` in our libs by default, a custom lib *could* use different definitions.
+                const globalIterationTypes =
+                    getIterationTypesOfIteratorCached(globalType, resolver) ||
+                    getIterationTypesOfIteratorSlow(globalType, resolver, /*errorNode*/ undefined);
+                const { returnType, nextType } = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes;
+                return (type as IterableOrIteratorType)[resolver.iteratorCacheKey] = createIterationTypes(yieldType, returnType, nextType);
+            }
+            if (isReferenceToType(type, resolver.getGlobalIteratorType(/*reportErrors*/ false)) ||
+                isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) {
+                const [yieldType, returnType, nextType] = (type as GenericType).typeArguments!;
+                return (type as IterableOrIteratorType)[resolver.iteratorCacheKey] = createIterationTypes(yieldType, returnType, nextType);
+            }
+        }
+
+        function isIteratorResult(type: Type, kind: IterationTypeKind.Yield | IterationTypeKind.Return) {
+            // From https://tc39.github.io/ecma262/#sec-iteratorresult-interface:
+            // > [done] is the result status of an iterator `next` method call. If the end of the iterator was reached `done` is `true`.
+            // > If the end was not reached `done` is `false` and a value is available.
+            // > If a `done` property (either own or inherited) does not exist, it is consider to have the value `false`.
+            const doneType = getTypeOfPropertyOfType(type, "done" as __String) || falseType;
+            return isTypeAssignableTo(kind === IterationTypeKind.Yield ? falseType : trueType, doneType);
+        }
+
+        function isYieldIteratorResult(type: Type) {
+            return isIteratorResult(type, IterationTypeKind.Yield);
+        }
+
+        function isReturnIteratorResult(type: Type) {
+            return isIteratorResult(type, IterationTypeKind.Return);
+        }
+
+        /**
+         * Gets the *yield* and *return* types of an `IteratorResult`-like type.
          *
-         *  { // iterator
-         *      next: { // nextMethod
-         *          (): PromiseLike<{ // nextResult
-         *              value: T // nextValue
-         *          }>
-         *      }
-         *  }
+         * If we are unable to determine a *yield* or a *return* type, `noIterationTypes` is
+         * returned to indicate to the caller that it should handle the error. Otherwise, an
+         * `IterationTypes` record is returned.
          */
-        function getIteratedTypeOfIterator(type: Type, errorNode: Node | undefined, isAsyncIterator: boolean): Type | undefined {
+        function getIterationTypesOfIteratorResult(type: Type) {
             if (isTypeAny(type)) {
-                return undefined;
+                return anyIterationTypes;
+            }
+
+            const cachedTypes = (type as IterableOrIteratorType).iterationTypesOfIteratorResult;
+            if (cachedTypes) {
+                return cachedTypes;
             }
 
-            const typeAsIterator = <IterableOrIteratorType>type;
-            if (isAsyncIterator ? typeAsIterator.iteratedTypeOfAsyncIterator : typeAsIterator.iteratedTypeOfIterator) {
-                return isAsyncIterator ? typeAsIterator.iteratedTypeOfAsyncIterator : typeAsIterator.iteratedTypeOfIterator;
+            // As an optimization, if the type is an instantiation of one of the global `IteratorYieldResult<T>`
+            // or `IteratorReturnResult<TReturn>` types, then just grab its type argument.
+            if (isReferenceToType(type, getGlobalIteratorYieldResultType(/*reportErrors*/ false))) {
+                const yieldType = (type as GenericType).typeArguments![0];
+                return (type as IterableOrIteratorType).iterationTypesOfIteratorResult = createIterationTypes(yieldType, /*returnType*/ undefined, /*nextType*/ undefined);
+            }
+            if (isReferenceToType(type, getGlobalIteratorReturnResultType(/*reportErrors*/ false))) {
+                const returnType = (type as GenericType).typeArguments![0];
+                return (type as IterableOrIteratorType).iterationTypesOfIteratorResult = createIterationTypes(/*yieldType*/ undefined, returnType, /*nextType*/ undefined);
             }
 
-            // As an optimization, if the type is an instantiation of the global `Iterator<T>` (for
-            // a non-async iterator) or the global `AsyncIterator<T>` (for an async-iterator) then
-            // just grab its type argument.
-            const getIteratorType = isAsyncIterator ? getGlobalAsyncIteratorType : getGlobalIteratorType;
-            if (isReferenceToType(type, getIteratorType(/*reportErrors*/ false))) {
-                return isAsyncIterator
-                    ? typeAsIterator.iteratedTypeOfAsyncIterator = (<GenericType>type).typeArguments![0]
-                    : typeAsIterator.iteratedTypeOfIterator = (<GenericType>type).typeArguments![0];
+            // Choose any constituents that can produce the requested iteration type.
+            const yieldIteratorResult = filterType(type, isYieldIteratorResult);
+            const yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value" as __String) : undefined;
+
+            const returnIteratorResult = filterType(type, isReturnIteratorResult);
+            const returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value" as __String) : undefined;
+
+            if (!yieldType && !returnType) {
+                return (type as IterableOrIteratorType).iterationTypesOfIteratorResult = noIterationTypes;
             }
 
-            // Both async and non-async iterators must have a `next` method.
-            const nextMethod = getTypeOfPropertyOfType(type, "next" as __String);
-            if (isTypeAny(nextMethod)) {
+            // From https://tc39.github.io/ecma262/#sec-iteratorresult-interface
+            // > ... If the iterator does not have a return value, `value` is `undefined`. In that case, the
+            // > `value` property may be absent from the conforming object if it does not inherit an explicit
+            // > `value` property.
+            return (type as IterableOrIteratorType).iterationTypesOfIteratorResult = createIterationTypes(yieldType, returnType || voidType, /*nextType*/ undefined);
+        }
+
+        /**
+         * Gets the *yield*, *return*, and *next* types of a the `next()`, `return()`, or
+         * `throw()` method of an `Iterator`-like or `AsyncIterator`-like type.
+         *
+         * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
+         * record is returned. Otherwise, we return `undefined`.
+         */
+        function getIterationTypesOfMethod(type: Type, resolver: IterationTypesResolver, methodName: "next" | "return" | "throw", errorNode: Node | undefined): IterationTypes | undefined {
+            const method = getPropertyOfType(type, methodName as __String);
+
+            // Ignore 'return' or 'throw' if they are missing.
+            if (!method && methodName !== "next") {
                 return undefined;
             }
 
-            const nextMethodSignatures = nextMethod ? getSignaturesOfType(nextMethod, SignatureKind.Call) : emptyArray;
-            if (nextMethodSignatures.length === 0) {
+            const methodType = method && !(methodName === "next" && (method.flags & SymbolFlags.Optional))
+                ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), TypeFacts.NEUndefinedOrNull)
+                : undefined;
+
+            if (isTypeAny(methodType)) {
+                // `return()` and `throw()` don't provide a *next* type.
+                return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext;
+            }
+
+            // Both async and non-async iterators *must* have a `next` method.
+            const methodSignatures = methodType ? getSignaturesOfType(methodType, SignatureKind.Call) : emptyArray;
+            if (methodSignatures.length === 0) {
                 if (errorNode) {
-                    error(errorNode, isAsyncIterator
-                        ? Diagnostics.An_async_iterator_must_have_a_next_method
-                        : Diagnostics.An_iterator_must_have_a_next_method);
+                    const diagnostic = methodName === "next"
+                        ? resolver.mustHaveANextMethodDiagnostic
+                        : resolver.mustBeAMethodDiagnostic;
+                    error(errorNode, diagnostic, methodName);
                 }
-                return undefined;
+                return methodName === "next" ? anyIterationTypes : undefined;
             }
 
-            let nextResult: Type | undefined = getUnionType(map(nextMethodSignatures, getReturnTypeOfSignature), UnionReduction.Subtype);
-            if (isTypeAny(nextResult)) {
-                return undefined;
+            // Extract the first parameter and return type of each signature.
+            let methodParameterTypes: Type[] | undefined;
+            let methodReturnTypes: Type[] | undefined;
+            for (const signature of methodSignatures) {
+                if (methodName !== "throw" && some(signature.parameters)) {
+                    methodParameterTypes = append(methodParameterTypes, getTypeAtPosition(signature, 0));
+                }
+                methodReturnTypes = append(methodReturnTypes, getReturnTypeOfSignature(signature));
             }
 
-            // For an async iterator, we must get the awaited type of the return type.
-            if (isAsyncIterator) {
-                nextResult = getAwaitedTypeOfPromise(nextResult, errorNode, Diagnostics.The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property);
-                if (isTypeAny(nextResult)) {
-                    return undefined;
+            // Resolve the *next* or *return* type from the first parameter of a `next()` or
+            // `return()` method, respectively.
+            let returnTypes: Type[] | undefined;
+            let nextType: Type | undefined;
+            if (methodName !== "throw") {
+                const methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType;
+                const resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType;
+                if (methodName === "next") {
+                    nextType = resolvedMethodParameterType;
+                }
+                else if (methodName === "return") {
+                    returnTypes = append(returnTypes, resolvedMethodParameterType);
                 }
             }
 
-            const nextValue = nextResult && getTypeOfPropertyOfType(nextResult, "value" as __String);
-            if (!nextValue) {
+            // Resolve the *yield* and *return* types from the return type of the method (i.e. `IteratorResult`)
+            let yieldType: Type;
+            const methodReturnType = methodReturnTypes ? getUnionType(methodReturnTypes, UnionReduction.Subtype) : neverType;
+            const resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType;
+            const iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType);
+            if (iterationTypes === noIterationTypes) {
                 if (errorNode) {
-                    error(errorNode, isAsyncIterator
-                        ? Diagnostics.The_type_returned_by_the_next_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property
-                        : Diagnostics.The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property);
+                    error(errorNode, resolver.mustHaveAValueDiagnostic, methodName);
                 }
-                return undefined;
+                yieldType = anyType;
+                returnTypes = append(returnTypes, anyType);
             }
+            else {
+                yieldType = iterationTypes.yieldType;
+                returnTypes = append(returnTypes, iterationTypes.returnType);
+            }
+
+            return createIterationTypes(yieldType, getUnionType(returnTypes), nextType);
+        }
 
-            return isAsyncIterator
-                ? typeAsIterator.iteratedTypeOfAsyncIterator = nextValue
-                : typeAsIterator.iteratedTypeOfIterator = nextValue;
+        /**
+         * Gets the *yield*, *return*, and *next* types of an `Iterator`-like or `AsyncIterator`-like
+         * type from its members.
+         *
+         * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes`
+         * record is returned. Otherwise, `noIterationTypes` is returned.
+         *
+         * NOTE: You probably don't want to call this directly and should be calling
+         * `getIterationTypesOfIterator` instead.
+         */
+        function getIterationTypesOfIteratorSlow(type: Type, resolver: IterationTypesResolver, errorNode: Node | undefined) {
+            const iterationTypes = combineIterationTypes([
+                getIterationTypesOfMethod(type, resolver, "next", errorNode),
+                getIterationTypesOfMethod(type, resolver, "return", errorNode),
+                getIterationTypesOfMethod(type, resolver, "throw", errorNode),
+            ]);
+            return (type as IterableOrIteratorType)[resolver.iteratorCacheKey] = iterationTypes;
         }
 
         /**
-         * A generator may have a return type of `Iterator<T>`, `Iterable<T>`, or
-         * `IterableIterator<T>`. An async generator may have a return type of `AsyncIterator<T>`,
-         * `AsyncIterable<T>`, or `AsyncIterableIterator<T>`. This function can be used to extract
-         * the iterated type from this return type for contextual typing and verifying signatures.
+         * Gets the requested "iteration type" from a type that is either `Iterable`-like, `Iterator`-like,
+         * `IterableIterator`-like, or `Generator`-like (for a non-async generator); or `AsyncIterable`-like,
+         * `AsyncIterator`-like, `AsyncIterableIterator`-like, or `AsyncGenerator`-like (for an async generator).
          */
-        function getIteratedTypeOfGenerator(returnType: Type, isAsyncGenerator: boolean): Type | undefined {
+        function getIterationTypeOfGeneratorFunctionReturnType(kind: IterationTypeKind, returnType: Type, isAsyncGenerator: boolean): Type | undefined {
             if (isTypeAny(returnType)) {
                 return undefined;
             }
 
-            return getIteratedTypeOfIterable(returnType, /*errorNode*/ undefined, /*allowAsyncIterables*/ isAsyncGenerator, /*allowSyncIterables*/ !isAsyncGenerator, /*checkAssignability*/ false)
-                || getIteratedTypeOfIterator(returnType, /*errorNode*/ undefined, isAsyncGenerator);
+            const iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator);
+            return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)];
+        }
+
+        function getIterationTypesOfGeneratorFunctionReturnType(type: Type, isAsyncGenerator: boolean) {
+            if (isTypeAny(type)) {
+                return anyIterationTypes;
+            }
+
+            const use = isAsyncGenerator ? IterationUse.AsyncGeneratorReturnType : IterationUse.GeneratorReturnType;
+            const resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver;
+            return getIterationTypesOfIterable(type, use, /*errorNode*/ undefined) ||
+                getIterationTypesOfIterator(type, resolver, /*errorNode*/ undefined);
         }
 
         function checkBreakOrContinueStatement(node: BreakOrContinueStatement) {
@@ -27786,10 +28293,16 @@ namespace ts {
             // TODO: Check that target label is valid
         }
 
+        function unwrapReturnType(returnType: Type, functionFlags: FunctionFlags) {
+            const isGenerator = !!(functionFlags & FunctionFlags.Generator);
+            const isAsync = !!(functionFlags & FunctionFlags.Async);
+            return isGenerator ? getIterationTypeOfGeneratorFunctionReturnType(IterationTypeKind.Return, returnType, isAsync) || errorType :
+                isAsync ? getPromisedTypeOfPromise(returnType) || errorType :
+                returnType;
+        }
+
         function isUnwrappedReturnTypeVoidOrAny(func: SignatureDeclaration, returnType: Type): boolean {
-            const unwrappedReturnType = (getFunctionFlags(func) & FunctionFlags.AsyncGenerator) === FunctionFlags.Async
-                ? getPromisedTypeOfPromise(returnType) // Async function
-                : returnType; // AsyncGenerator function, Generator function, or normal function
+            const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(func));
             return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, TypeFlags.Void | TypeFlags.AnyOrUnknown);
         }
 
@@ -27808,17 +28321,9 @@ namespace ts {
             const signature = getSignatureFromDeclaration(func);
             const returnType = getReturnTypeOfSignature(signature);
             const functionFlags = getFunctionFlags(func);
-            const isGenerator = functionFlags & FunctionFlags.Generator;
             if (strictNullChecks || node.expression || returnType.flags & TypeFlags.Never) {
                 const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
-                if (isGenerator) { // AsyncGenerator function or Generator function
-                    // A generator does not need its return expressions checked against its return type.
-                    // Instead, the yield expressions are checked against the element type.
-                    // TODO: Check return types of generators when return type tracking is added
-                    // for generators.
-                    return;
-                }
-                else if (func.kind === SyntaxKind.SetAccessor) {
+                if (func.kind === SyntaxKind.SetAccessor) {
                     if (node.expression) {
                         error(node, Diagnostics.Setters_cannot_return_a_value);
                     }
@@ -27829,22 +28334,19 @@ namespace ts {
                     }
                 }
                 else if (getReturnTypeFromAnnotation(func)) {
-                    if (functionFlags & FunctionFlags.Async) { // Async function
-                        const promisedType = getPromisedTypeOfPromise(returnType);
-                        const awaitedType = checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
-                        if (promisedType) {
-                            // If the function has a return type, but promisedType is
-                            // undefined, an error will be reported in checkAsyncFunctionReturnType
-                            // so we don't need to report one here.
-                            checkTypeAssignableToAndOptionallyElaborate(awaitedType, promisedType, node, node.expression);
-                        }
-                    }
-                    else {
-                        checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression);
+                    const unwrappedReturnType = unwrapReturnType(returnType, functionFlags);
+                    const unwrappedExprType = functionFlags & FunctionFlags.Async
+                        ? checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
+                        : exprType;
+                    if (unwrappedReturnType) {
+                        // If the function has a return type, but promisedType is
+                        // undefined, an error will be reported in checkAsyncFunctionReturnType
+                        // so we don't need to report one here.
+                        checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression);
                     }
                 }
             }
-            else if (func.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType) && !isGenerator) {
+            else if (func.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType)) {
                 // The function has a return type, but the return statement doesn't have an expression.
                 error(node, Diagnostics.Not_all_code_paths_return_a_value);
             }
@@ -30325,7 +30827,7 @@ namespace ts {
             const node = cast(expr.parent, isArrayLiteralExpression);
             //    [{ property1: p1, property2 }] = elems;
             const typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType;
-            const elementType = checkIteratedTypeOrElementType(typeOfArrayLiteral, expr.parent, /*allowStringInput*/ false, /*allowAsyncIterables*/ false) || errorType;
+            const elementType = checkIteratedTypeOrElementType(IterationUse.Destructuring, typeOfArrayLiteral, undefinedType, expr.parent) || errorType;
             return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType);
         }
 
@@ -32791,4 +33293,12 @@ namespace ts {
         export const LibraryManagedAttributes = "LibraryManagedAttributes" as __String;
         // tslint:enable variable-name
     }
+
+    function getIterationTypesKeyFromIterationTypeKind(typeKind: IterationTypeKind) {
+        switch (typeKind) {
+            case IterationTypeKind.Yield: return "yieldType";
+            case IterationTypeKind.Return: return "returnType";
+            case IterationTypeKind.Next: return "nextType";
+        }
+    }
 }
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 4747b89f08ccb..2c4c867fb678f 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -40,6 +40,7 @@ namespace ts {
         ["es2017.string", "lib.es2017.string.d.ts"],
         ["es2017.intl", "lib.es2017.intl.d.ts"],
         ["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"],
+        ["es2018.asyncgenerator", "lib.es2018.asyncgenerator.d.ts"],
         ["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["es2018.intl", "lib.es2018.intl.d.ts"],
         ["es2018.promise", "lib.es2018.promise.d.ts"],
@@ -1899,7 +1900,9 @@ namespace ts {
                 case "object":
                     return {};
                 default:
-                    return option.type.keys().next().value;
+                    const iterResult = option.type.keys().next();
+                    if (!iterResult.done) return iterResult.value;
+                    return Debug.fail("Expected 'option.type' to have entries.");
             }
         }
 
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index f1511b79c126b..545e5d7bdda06 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -24,7 +24,6 @@ namespace ts {
         " __sortedArrayBrand": any;
     }
 
-
     /** ES6 Map interface, only read methods included. */
     export interface ReadonlyMap<T> {
         get(key: string): T | undefined;
@@ -45,7 +44,7 @@ namespace ts {
 
     /** ES6 Iterator type. */
     export interface Iterator<T> {
-        next(): { value: T, done: false } | { value: never, done: true };
+        next(): { value: T, done?: false } | { value: never, done: true };
     }
 
     /** Array that is only intended to be pushed to, never read. */
@@ -297,12 +296,13 @@ namespace ts {
             forEach(action: (value: T, key: string) => void): void {
                 const iterator = this.entries();
                 while (true) {
-                    const { value: entry, done } = iterator.next();
-                    if (done) {
+                    const iterResult = iterator.next();
+                    if (iterResult.done) {
                         break;
                     }
 
-                    action(entry[1], entry[0]);
+                    const [key, value] = iterResult.value;
+                    action(value, key);
                 }
             }
         };
@@ -346,11 +346,11 @@ namespace ts {
 
     export function firstDefinedIterator<T, U>(iter: Iterator<T>, callback: (element: T) => U | undefined): U | undefined {
         while (true) {
-            const { value, done } = iter.next();
-            if (done) {
+            const iterResult = iter.next();
+            if (iterResult.done) {
                 return undefined;
             }
-            const result = callback(value);
+            const result = callback(iterResult.value);
             if (result !== undefined) {
                 return result;
             }
@@ -375,7 +375,7 @@ namespace ts {
                     return { value: undefined as never, done: true };
                 }
                 i++;
-                return { value: [arrayA[i - 1], arrayB[i - 1]], done: false };
+                return { value: [arrayA[i - 1], arrayB[i - 1]] as [T, U], done: false };
             }
         };
     }
@@ -567,7 +567,7 @@ namespace ts {
         return {
             next() {
                 const iterRes = iter.next();
-                return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false };
+                return iterRes.done ? iterRes as { done: true, value: never } : { value: mapFn(iterRes.value), done: false };
             }
         };
     }
@@ -678,7 +678,7 @@ namespace ts {
                     }
                     const iterRes = iter.next();
                     if (iterRes.done) {
-                        return iterRes;
+                        return iterRes as { done: true, value: never };
                     }
                     currentIter = getIterator(iterRes.value);
                 }
@@ -753,7 +753,7 @@ namespace ts {
                 while (true) {
                     const res = iter.next();
                     if (res.done) {
-                        return res;
+                        return res as { done: true, value: never };
                     }
                     const value = mapFn(res.value);
                     if (value !== undefined) {
@@ -1078,6 +1078,7 @@ namespace ts {
      * @param value The value to append to the array. If `value` is `undefined`, nothing is
      * appended.
      */
+    export function append<TArray extends any[] | undefined, TValue extends NonNullable<TArray>[number] | undefined>(to: TArray, value: TValue): [undefined, undefined] extends [TArray, TValue] ? TArray : NonNullable<TArray>[number][];
     export function append<T>(to: T[], value: T | undefined): T[];
     export function append<T>(to: T[] | undefined, value: T): T[];
     export function append<T>(to: T[] | undefined, value: T | undefined): T[] | undefined;
@@ -1402,8 +1403,8 @@ namespace ts {
     export function arrayFrom<T>(iterator: Iterator<T> | IterableIterator<T>): T[];
     export function arrayFrom<T, U>(iterator: Iterator<T> | IterableIterator<T>, map?: (t: T) => U): (T | U)[] {
         const result: (T | U)[] = [];
-        for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {
-            result.push(map ? map(value) : value);
+        for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+            result.push(map ? map(iterResult.value) : iterResult.value);
         }
         return result;
     }
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 7d178f1d47892..c404851af3e90 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1764,7 +1764,7 @@
         "category": "Error",
         "code": 2489
     },
-    "The type returned by the 'next()' method of an iterator must have a 'value' property.": {
+    "The type returned by the '{0}()' method of an iterator must have a 'value' property.": {
         "category": "Error",
         "code": 2490
     },
@@ -1992,7 +1992,7 @@
         "category": "Error",
         "code": 2546
     },
-    "The type returned by the 'next()' method of an async iterator must be a promise for a type with a 'value' property.": {
+    "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property.": {
         "category": "Error",
         "code": 2547
     },
@@ -2653,6 +2653,30 @@
         "category": "Error",
         "code": 2762
     },
+    "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but for-of will always send '{0}'.": {
+        "category": "Error",
+        "code": 2763
+    },
+    "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array spread will always send '{0}'.": {
+        "category": "Error",
+        "code": 2764
+    },
+    "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array destructuring will always send '{0}'.": {
+        "category": "Error",
+        "code": 2765
+    },
+    "Cannot delegate iteration to value because the 'next' method of its iterator expects type '{1}', but the containing generator will always send '{0}'.": {
+        "category": "Error",
+        "code": 2766
+    },
+    "The '{0}' property of an iterator must be a method.": {
+        "category": "Error",
+        "code": 2767
+    },
+    "The '{0}' property of an async iterator must be a method.": {
+        "category": "Error",
+        "code": 2768
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
@@ -4214,7 +4238,7 @@
         "category": "Error",
         "code": 7024
     },
-    "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type.": {
+    "Generator implicitly has yield type '{0}' because it does not yield any values. Consider supplying a return type annotation.": {
         "category": "Error",
         "code": 7025
     },
@@ -4336,6 +4360,11 @@
         "category": "Error",
         "code": 7054
     },
+    "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type.": {
+        "category": "Error",
+        "code": 7055
+    },
+
     "You cannot rename this element.": {
         "category": "Error",
         "code": 8000
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index b33536bab2a5e..c17e47724e4c1 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -148,7 +148,8 @@ namespace ts {
             const sourceIndexToNewSourceIndexMap: number[] = [];
             let nameIndexToNewNameIndexMap: number[] | undefined;
             const mappingIterator = decodeMappings(map.mappings);
-            for (let { value: raw, done } = mappingIterator.next(); !done; { value: raw, done } = mappingIterator.next()) {
+            for (let iterResult = mappingIterator.next(); !iterResult.done; iterResult = mappingIterator.next()) {
+                const raw = iterResult.value;
                 if (end && (
                     raw.generatedLine > end.line ||
                     (raw.generatedLine === end.line && raw.generatedCharacter > end.character))) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 91a4a5570ef24..a31e707f98496 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -4273,13 +4273,23 @@ namespace ts {
         regularType: ResolvedType;  // Regular version of fresh type
     }
 
+    /* @internal */
+    export interface IterationTypes {
+        readonly yieldType: Type;
+        readonly returnType: Type;
+        readonly nextType: Type;
+    }
+
     // Just a place to cache element types of iterables and iterators
     /* @internal */
     export interface IterableOrIteratorType extends ObjectType, UnionType {
-        iteratedTypeOfIterable?: Type;
-        iteratedTypeOfIterator?: Type;
-        iteratedTypeOfAsyncIterable?: Type;
-        iteratedTypeOfAsyncIterator?: Type;
+        iterationTypesOfGeneratorReturnType?: IterationTypes;
+        iterationTypesOfAsyncGeneratorReturnType?: IterationTypes;
+        iterationTypesOfIterable?: IterationTypes;
+        iterationTypesOfIterator?: IterationTypes;
+        iterationTypesOfAsyncIterable?: IterationTypes;
+        iterationTypesOfAsyncIterator?: IterationTypes;
+        iterationTypesOfIteratorResult?: IterationTypes;
     }
 
     /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 8b20ecda2041b..e9b23bdedf024 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -150,8 +150,8 @@ namespace ts {
     export function forEachEntry<T, U>(map: ReadonlyMap<T>, callback: (value: T, key: string) => U | undefined): U | undefined;
     export function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T> | ReadonlyMap<T>, callback: (value: T, key: (string & __String)) => U | undefined): U | undefined {
         const iterator = map.entries();
-        for (let { value: pair, done } = iterator.next(); !done; { value: pair, done } = iterator.next()) {
-            const [key, value] = pair;
+        for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+            const [key, value] = iterResult.value;
             const result = callback(value, key as (string & __String));
             if (result) {
                 return result;
@@ -165,8 +165,8 @@ namespace ts {
     export function forEachKey<T>(map: ReadonlyMap<{}>, callback: (key: string) => T | undefined): T | undefined;
     export function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<{}> | ReadonlyMap<{}>, callback: (key: string & __String) => T | undefined): T | undefined {
         const iterator = map.keys();
-        for (let { value: key, done } = iterator.next(); !done; { value: key, done } = iterator.next()) {
-            const result = callback(key as string & __String);
+        for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
+            const result = callback(iterResult.value as string & __String);
             if (result) {
                 return result;
             }
diff --git a/src/harness/sourceMapRecorder.ts b/src/harness/sourceMapRecorder.ts
index 893b17ff10650..829e047eade1b 100644
--- a/src/harness/sourceMapRecorder.ts
+++ b/src/harness/sourceMapRecorder.ts
@@ -301,7 +301,8 @@ namespace Harness.SourceMapRecorder {
 
             SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMapData.sourceMap, currentFile);
             const mapper = ts.decodeMappings(sourceMapData.sourceMap.mappings);
-            for (let { value: decodedSourceMapping, done } = mapper.next(); !done; { value: decodedSourceMapping, done } = mapper.next()) {
+            for (let iterResult = mapper.next(); !iterResult.done; iterResult = mapper.next()) {
+                const decodedSourceMapping = iterResult.value;
                 const currentSourceFile = ts.isSourceMapping(decodedSourceMapping)
                     ? program.getSourceFile(sourceMapData.inputSourceFileNames[decodedSourceMapping.sourceIndex])
                     : undefined;
@@ -335,7 +336,8 @@ namespace Harness.SourceMapRecorder {
 
             SourceMapSpanWriter.initializeSourceMapSpanWriter(sourceMapRecorder, sourceMap, currentFile);
             const mapper = ts.decodeMappings(sourceMap.mappings);
-            for (let { value: decodedSourceMapping, done } = mapper.next(); !done; { value: decodedSourceMapping, done } = mapper.next()) {
+            for (let iterResult = mapper.next(); !iterResult.done; iterResult = mapper.next()) {
+                const decodedSourceMapping = iterResult.value;
                 const currentSourceFile = ts.isSourceMapping(decodedSourceMapping)
                     ? getFile(sourceFileAbsolutePaths[decodedSourceMapping.sourceIndex])
                     : undefined;
diff --git a/src/harness/vfs.ts b/src/harness/vfs.ts
index ee9519f254c07..b20c04937f878 100644
--- a/src/harness/vfs.ts
+++ b/src/harness/vfs.ts
@@ -683,7 +683,7 @@ namespace vfs {
 
             if (isDirectory(node)) throw createIOError("EISDIR");
             if (!isFile(node)) throw createIOError("EBADF");
-            node.buffer = Buffer.isBuffer(data) ? data.slice() : ts.sys.bufferFrom!("" + data, encoding || "utf8");
+            node.buffer = Buffer.isBuffer(data) ? data.slice() : ts.sys.bufferFrom!("" + data, encoding || "utf8") as Buffer;
             node.size = node.buffer.byteLength;
             node.mtimeMs = time;
             node.ctimeMs = time;
@@ -1204,7 +1204,7 @@ namespace vfs {
                 }
             },
             readFileSync(path: string): Buffer {
-                return ts.sys.bufferFrom!(host.readFile(path)!, "utf8"); // TODO: GH#18217
+                return ts.sys.bufferFrom!(host.readFile(path)!, "utf8") as Buffer; // TODO: GH#18217
             }
         };
     }
diff --git a/src/lib/es2015.generator.d.ts b/src/lib/es2015.generator.d.ts
index 92bb8dca8685a..7c6929173a0e4 100644
--- a/src/lib/es2015.generator.d.ts
+++ b/src/lib/es2015.generator.d.ts
@@ -1,4 +1,12 @@
-interface Generator extends Iterator<any> { }
+/// <reference lib="es2015.iterable" />
+
+interface Generator<T = unknown, TReturn = any, TNext = unknown> extends Iterator<T, TReturn, TNext> {
+    // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return(value: TReturn): IteratorResult<T, TReturn>;
+    throw(e: any): IteratorResult<T, TReturn>;
+    [Symbol.iterator](): Generator<T, TReturn, TNext>;
+}
 
 interface GeneratorFunction {
     /**
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index faba45bc51895..937f99d3409a4 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -8,15 +8,23 @@ interface SymbolConstructor {
     readonly iterator: symbol;
 }
 
-interface IteratorResult<T> {
-    done: boolean;
-    value: T;
+interface IteratorYieldResult<TYield> {
+    done?: false;
+    value: TYield;
 }
 
-interface Iterator<T> {
-    next(value?: any): IteratorResult<T>;
-    return?(value?: any): IteratorResult<T>;
-    throw?(e?: any): IteratorResult<T>;
+interface IteratorReturnResult<TReturn> {
+    done: true;
+    value: TReturn;
+}
+
+type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+
+interface Iterator<T, TReturn = any, TNext = undefined> {
+    // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return?(value?: TReturn): IteratorResult<T, TReturn>;
+    throw?(e?: any): IteratorResult<T, TReturn>;
 }
 
 interface Iterable<T> {
diff --git a/src/lib/es2018.asyncgenerator.d.ts b/src/lib/es2018.asyncgenerator.d.ts
new file mode 100644
index 0000000000000..76275c92575c0
--- /dev/null
+++ b/src/lib/es2018.asyncgenerator.d.ts
@@ -0,0 +1,59 @@
+/// <reference lib="es2018.asynciterable" />
+
+interface AsyncGenerator<T = unknown, TReturn = any, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+    next(...args: [] | [TNext | PromiseLike<TNext>]): Promise<IteratorResult<T, TReturn>>;
+    return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw(e: any): Promise<IteratorResult<T, TReturn>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+}
+
+interface AsyncGeneratorFunction {
+    /**
+     * Creates a new AsyncGenerator object.
+     * @param args A list of arguments the function accepts.
+     */
+    new (...args: any[]): AsyncGenerator;
+    /**
+     * Creates a new AsyncGenerator object.
+     * @param args A list of arguments the function accepts.
+     */
+    (...args: any[]): AsyncGenerator;
+    /**
+     * The length of the arguments.
+     */
+    readonly length: number;
+    /**
+     * Returns the name of the function.
+     */
+    readonly name: string;
+    /**
+     * A reference to the prototype.
+     */
+    readonly prototype: AsyncGenerator;
+}
+
+interface AsyncGeneratorFunctionConstructor {
+    /**
+     * Creates a new AsyncGenerator function.
+     * @param args A list of arguments the function accepts.
+     */
+    new (...args: string[]): AsyncGeneratorFunction;
+    /**
+     * Creates a new AsyncGenerator function.
+     * @param args A list of arguments the function accepts.
+     */
+    (...args: string[]): AsyncGeneratorFunction;
+    /**
+     * The length of the arguments.
+     */
+    readonly length: number;
+    /**
+     * Returns the name of the function.
+     */
+    readonly name: string;
+    /**
+     * A reference to the prototype.
+     */
+    readonly prototype: AsyncGeneratorFunction;
+}
diff --git a/src/lib/es2018.asynciterable.d.ts b/src/lib/es2018.asynciterable.d.ts
index 11093af623dee..d5d83f31893bb 100644
--- a/src/lib/es2018.asynciterable.d.ts
+++ b/src/lib/es2018.asynciterable.d.ts
@@ -9,10 +9,11 @@ interface SymbolConstructor {
     readonly asyncIterator: symbol;
 }
 
-interface AsyncIterator<T> {
-    next(value?: any): Promise<IteratorResult<T>>;
-    return?(value?: any): Promise<IteratorResult<T>>;
-    throw?(e?: any): Promise<IteratorResult<T>>;
+interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+    // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+    next(...args: [] | [TNext | PromiseLike<TNext>]): Promise<IteratorResult<T, TReturn>>;
+    return?(value?: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
 }
 
 interface AsyncIterable<T> {
diff --git a/src/lib/es2018.d.ts b/src/lib/es2018.d.ts
index 2a20887b3ee22..b7670a81c3c44 100644
--- a/src/lib/es2018.d.ts
+++ b/src/lib/es2018.d.ts
@@ -1,4 +1,5 @@
 /// <reference lib="es2017" />
+/// <reference lib="es2018.asyncgenerator" />
 /// <reference lib="es2018.asynciterable" />
 /// <reference lib="es2018.promise" />
 /// <reference lib="es2018.regexp" />
diff --git a/src/lib/libs.json b/src/lib/libs.json
index ac2f2db5b6bb0..089689befdda1 100644
--- a/src/lib/libs.json
+++ b/src/lib/libs.json
@@ -31,6 +31,7 @@
         "es2017.string",
         "es2017.intl",
         "es2017.typedarrays",
+        "es2018.asyncgenerator",
         "es2018.asynciterable",
         "es2018.regexp",
         "es2018.promise",
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 10a7b66700930..81c56bb179b65 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -2832,8 +2832,9 @@ namespace ts.server {
             let assignOrphanScriptInfosToInferredProject = false;
             if (openFiles) {
                 while (true) {
-                    const { value: file, done } = openFiles.next();
-                    if (done) break;
+                    const iterResult = openFiles.next();
+                    if (iterResult.done) break;
+                    const file = iterResult.value;
                     const scriptInfo = this.getScriptInfo(file.fileName);
                     Debug.assert(!scriptInfo || !scriptInfo.isScriptOpen(), "Script should not exist and not be open already");
                     // Create script infos so we have the new content for all the open files before we do any updates to projects
@@ -2850,8 +2851,9 @@ namespace ts.server {
 
             if (changedFiles) {
                 while (true) {
-                    const { value: file, done } = changedFiles.next();
-                    if (done) break;
+                    const iterResult = changedFiles.next();
+                    if (iterResult.done) break;
+                    const file = iterResult.value;
                     const scriptInfo = this.getScriptInfo(file.fileName)!;
                     Debug.assert(!!scriptInfo);
                     // Make edits to script infos and marks containing project as dirty
@@ -2887,8 +2889,9 @@ namespace ts.server {
         /* @internal */
         applyChangesToFile(scriptInfo: ScriptInfo, changes: Iterator<TextChange>) {
             while (true) {
-                const { value: change, done } = changes.next();
-                if (done) break;
+                const iterResult = changes.next();
+                if (iterResult.done) break;
+                const change = iterResult.value;
                 scriptInfo.editContent(change.span.start, change.span.start + change.span.length, change.newText);
             }
         }
diff --git a/src/testRunner/parallel/host.ts b/src/testRunner/parallel/host.ts
index ee66fd738b0bd..50b18e39ac1af 100644
--- a/src/testRunner/parallel/host.ts
+++ b/src/testRunner/parallel/host.ts
@@ -295,8 +295,8 @@ namespace Harness.Parallel.Host {
                     worker.accumulatedOutput += d.toString();
                     console.log(`[Worker ${i}]`, d.toString());
                 };
-                worker.process.stderr.on("data", appendOutput);
-                worker.process.stdout.on("data", appendOutput);
+                worker.process.stderr!.on("data", appendOutput);
+                worker.process.stdout!.on("data", appendOutput);
                 const killChild = (timeout: TaskTimeout) => {
                     worker.process.kill();
                     console.error(`Worker exceeded ${timeout.duration}ms timeout ${worker.currentTasks && worker.currentTasks.length ? `while running test '${worker.currentTasks[0].file}'.` : `during test setup.`}`);
diff --git a/src/testRunner/unittests/config/commandLineParsing.ts b/src/testRunner/unittests/config/commandLineParsing.ts
index 3d1001c7daf85..d30c2a741dc8e 100644
--- a/src/testRunner/unittests/config/commandLineParsing.ts
+++ b/src/testRunner/unittests/config/commandLineParsing.ts
@@ -57,7 +57,7 @@ namespace ts {
             assertParseResult(["--lib", "es5,invalidOption", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.string', 'es2020.symbol.wellknown', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.string', 'es2020.symbol.wellknown', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         file: undefined,
@@ -259,7 +259,7 @@ namespace ts {
             assertParseResult(["--lib", "es5,", "es7", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.string', 'es2020.symbol.wellknown', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.string', 'es2020.symbol.wellknown', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         file: undefined,
@@ -278,7 +278,7 @@ namespace ts {
             assertParseResult(["--lib", "es5, ", "es7", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.string', 'es2020.symbol.wellknown', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asyncgenerator', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.object', 'es2019.string', 'es2019.symbol', 'es2020.string', 'es2020.symbol.wellknown', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         file: undefined,
diff --git a/src/testRunner/unittests/config/showConfig.ts b/src/testRunner/unittests/config/showConfig.ts
index afe8f878d279d..043e8382d2304 100644
--- a/src/testRunner/unittests/config/showConfig.ts
+++ b/src/testRunner/unittests/config/showConfig.ts
@@ -134,7 +134,9 @@ namespace ts {
                     break;
                 }
                 default: {
-                    const val = option.type.keys().next().value;
+                    const iterResult = option.type.keys().next();
+                    if (iterResult.done) return Debug.fail("Expected 'option.type' to have entries");
+                    const val = iterResult.value;
                     if (option.isTSConfigOnly) {
                         args = ["-p", "tsconfig.json"];
                         configObject = { compilerOptions: { [option.name]: val } };
diff --git a/src/testRunner/unittests/shimMap.ts b/src/testRunner/unittests/shimMap.ts
index a47a1d18205fd..c3e94c0840c05 100644
--- a/src/testRunner/unittests/shimMap.ts
+++ b/src/testRunner/unittests/shimMap.ts
@@ -68,12 +68,13 @@ namespace ts {
                 // Use an iterator.
                 const iterator = map.entries();
                 while (true) {
-                    const { value: tuple, done } = iterator.next();
-                    if (done) {
+                    const iterResult = iterator.next();
+                    if (iterResult.done) {
                         break;
                     }
 
-                    doForEach(tuple[1], tuple[0]);
+                    const [key, value] = iterResult.value;
+                    doForEach(value, key);
                 }
             }
 
diff --git a/src/testRunner/unittests/tsserver/helpers.ts b/src/testRunner/unittests/tsserver/helpers.ts
index 1c2383ab00443..63b854e8ce84e 100644
--- a/src/testRunner/unittests/tsserver/helpers.ts
+++ b/src/testRunner/unittests/tsserver/helpers.ts
@@ -438,10 +438,13 @@ namespace ts.projectSystem {
     export function configuredProjectAt(projectService: server.ProjectService, index: number) {
         const values = projectService.configuredProjects.values();
         while (index > 0) {
-            values.next();
+            const iterResult = values.next();
+            if (iterResult.done) return Debug.fail("Expected a result.");
             index--;
         }
-        return values.next().value;
+        const iterResult = values.next();
+        if (iterResult.done) return Debug.fail("Expected a result.");
+        return iterResult.value;
     }
 
     export function checkProjectActualFiles(project: server.Project, expectedFiles: ReadonlyArray<string>) {
diff --git a/src/tsconfig-base.json b/src/tsconfig-base.json
index 4d83436a5385a..c1081ed18263f 100644
--- a/src/tsconfig-base.json
+++ b/src/tsconfig-base.json
@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "pretty": true,
-        "lib": ["es2015.iterable", "es5"],
+        "lib": ["es2015.iterable", "es2015.generator", "es5"],
         "target": "es5",
         "rootDir": ".",
 
diff --git a/tests/baselines/reference/FunctionDeclaration11_es6.types b/tests/baselines/reference/FunctionDeclaration11_es6.types
index 0a312c2661cf2..c5053de9781a9 100644
--- a/tests/baselines/reference/FunctionDeclaration11_es6.types
+++ b/tests/baselines/reference/FunctionDeclaration11_es6.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration11_es6.ts ===
 function * yield() {
->yield : () => IterableIterator<any>
+>yield : () => Generator<never, void, unknown>
 }
diff --git a/tests/baselines/reference/FunctionDeclaration13_es6.types b/tests/baselines/reference/FunctionDeclaration13_es6.types
index b6f6aafd65814..011472ef73d96 100644
--- a/tests/baselines/reference/FunctionDeclaration13_es6.types
+++ b/tests/baselines/reference/FunctionDeclaration13_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration13_es6.ts ===
 function * foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
 
    // Legal to use 'yield' in a type context.
    var v: yield;
diff --git a/tests/baselines/reference/FunctionDeclaration1_es6.types b/tests/baselines/reference/FunctionDeclaration1_es6.types
index 548b1eb98d6f3..025cbe051c6c9 100644
--- a/tests/baselines/reference/FunctionDeclaration1_es6.types
+++ b/tests/baselines/reference/FunctionDeclaration1_es6.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration1_es6.ts ===
 function * foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
 }
diff --git a/tests/baselines/reference/FunctionDeclaration6_es6.types b/tests/baselines/reference/FunctionDeclaration6_es6.types
index 4cfb710a78177..e567b033ec6c7 100644
--- a/tests/baselines/reference/FunctionDeclaration6_es6.types
+++ b/tests/baselines/reference/FunctionDeclaration6_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration6_es6.ts ===
 function*foo(a = yield) {
->foo : (a?: any) => IterableIterator<any>
+>foo : (a?: any) => Generator<never, void, unknown>
 >a : any
 >yield : any
 }
diff --git a/tests/baselines/reference/FunctionDeclaration7_es6.types b/tests/baselines/reference/FunctionDeclaration7_es6.types
index d9635231e4a54..05df09ef780d1 100644
--- a/tests/baselines/reference/FunctionDeclaration7_es6.types
+++ b/tests/baselines/reference/FunctionDeclaration7_es6.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration7_es6.ts ===
 function*bar() {
->bar : () => IterableIterator<any>
+>bar : () => Generator<never, void, unknown>
 
   // 'yield' here is an identifier, and not a yield expression.
   function*foo(a = yield) {
->foo : (a?: any) => IterableIterator<any>
+>foo : (a?: any) => Generator<never, void, unknown>
 >a : any
 >yield : any
   }
diff --git a/tests/baselines/reference/FunctionDeclaration9_es6.types b/tests/baselines/reference/FunctionDeclaration9_es6.types
index 2b915b82a67b1..0c854f623f435 100644
--- a/tests/baselines/reference/FunctionDeclaration9_es6.types
+++ b/tests/baselines/reference/FunctionDeclaration9_es6.types
@@ -1,11 +1,11 @@
 === tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts ===
 function * foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
   var v = { [yield]: foo }
->v : { [x: number]: () => IterableIterator<any>; }
->{ [yield]: foo } : { [x: number]: () => IterableIterator<any>; }
->[yield] : () => IterableIterator<any>
+>v : { [x: number]: () => Generator<any, void, unknown>; }
+>{ [yield]: foo } : { [x: number]: () => Generator<any, void, unknown>; }
+>[yield] : () => Generator<any, void, unknown>
 >yield : any
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 }
diff --git a/tests/baselines/reference/FunctionExpression1_es6.types b/tests/baselines/reference/FunctionExpression1_es6.types
index 1bba41f11f2e7..1c56baf396a2a 100644
--- a/tests/baselines/reference/FunctionExpression1_es6.types
+++ b/tests/baselines/reference/FunctionExpression1_es6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/functionExpressions/FunctionExpression1_es6.ts ===
 var v = function * () { }
->v : () => IterableIterator<any>
->function * () { } : () => IterableIterator<any>
+>v : () => Generator<never, void, unknown>
+>function * () { } : () => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/FunctionExpression2_es6.types b/tests/baselines/reference/FunctionExpression2_es6.types
index 7a421dd1abfa4..8945268bf715d 100644
--- a/tests/baselines/reference/FunctionExpression2_es6.types
+++ b/tests/baselines/reference/FunctionExpression2_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionExpressions/FunctionExpression2_es6.ts ===
 var v = function * foo() { }
->v : () => IterableIterator<any>
->function * foo() { } : () => IterableIterator<any>
->foo : () => IterableIterator<any>
+>v : () => Generator<never, void, unknown>
+>function * foo() { } : () => Generator<never, void, unknown>
+>foo : () => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/FunctionPropertyAssignments1_es6.types b/tests/baselines/reference/FunctionPropertyAssignments1_es6.types
index 90b8615003e82..8fa1b03583086 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments1_es6.types
+++ b/tests/baselines/reference/FunctionPropertyAssignments1_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments1_es6.ts ===
 var v = { *foo() { } }
->v : { foo(): IterableIterator<any>; }
->{ *foo() { } } : { foo(): IterableIterator<any>; }
->foo : () => IterableIterator<any>
+>v : { foo(): Generator<never, void, unknown>; }
+>{ *foo() { } } : { foo(): Generator<never, void, unknown>; }
+>foo : () => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/FunctionPropertyAssignments2_es6.types b/tests/baselines/reference/FunctionPropertyAssignments2_es6.types
index 6b9a2da94086f..9ad073be7e909 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments2_es6.types
+++ b/tests/baselines/reference/FunctionPropertyAssignments2_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments2_es6.ts ===
 var v = { *() { } }
->v : { (Missing)(): IterableIterator<any>; }
->{ *() { } } : { (Missing)(): IterableIterator<any>; }
-> : () => IterableIterator<any>
+>v : { (Missing)(): Generator<never, void, unknown>; }
+>{ *() { } } : { (Missing)(): Generator<never, void, unknown>; }
+> : () => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/FunctionPropertyAssignments3_es6.types b/tests/baselines/reference/FunctionPropertyAssignments3_es6.types
index 9222f6e142de3..b49b766f1eb0d 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments3_es6.types
+++ b/tests/baselines/reference/FunctionPropertyAssignments3_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments3_es6.ts ===
 var v = { *{ } }
->v : { (Missing)(): IterableIterator<any>; }
->{ *{ } } : { (Missing)(): IterableIterator<any>; }
-> : () => IterableIterator<any>
+>v : { (Missing)(): Generator<never, void, unknown>; }
+>{ *{ } } : { (Missing)(): Generator<never, void, unknown>; }
+> : () => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/FunctionPropertyAssignments5_es6.types b/tests/baselines/reference/FunctionPropertyAssignments5_es6.types
index 9430360e9da25..18b2a7f33e50f 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments5_es6.types
+++ b/tests/baselines/reference/FunctionPropertyAssignments5_es6.types
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts ===
 var v = { *[foo()]() { } }
->v : { [x: number]: () => IterableIterator<any>; }
->{ *[foo()]() { } } : { [x: number]: () => IterableIterator<any>; }
->[foo()] : () => IterableIterator<any>
+>v : { [x: number]: () => Generator<never, void, unknown>; }
+>{ *[foo()]() { } } : { [x: number]: () => Generator<never, void, unknown>; }
+>[foo()] : () => Generator<never, void, unknown>
 >foo() : any
 >foo : any
 
diff --git a/tests/baselines/reference/FunctionPropertyAssignments6_es6.types b/tests/baselines/reference/FunctionPropertyAssignments6_es6.types
index 832acbd88406a..a7982dc2ca454 100644
--- a/tests/baselines/reference/FunctionPropertyAssignments6_es6.types
+++ b/tests/baselines/reference/FunctionPropertyAssignments6_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments6_es6.ts ===
 var v = { *<T>() { } }
->v : { (Missing)<T>(): IterableIterator<any>; }
->{ *<T>() { } } : { (Missing)<T>(): IterableIterator<any>; }
-> : <T>() => IterableIterator<any>
+>v : { (Missing)<T>(): Generator<never, void, unknown>; }
+>{ *<T>() { } } : { (Missing)<T>(): Generator<never, void, unknown>; }
+> : <T>() => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/MemberFunctionDeclaration1_es6.types b/tests/baselines/reference/MemberFunctionDeclaration1_es6.types
index 89eec59bb1c15..d002439563b3c 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration1_es6.types
+++ b/tests/baselines/reference/MemberFunctionDeclaration1_es6.types
@@ -3,5 +3,5 @@ class C {
 >C : C
 
    *foo() { }
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
 }
diff --git a/tests/baselines/reference/MemberFunctionDeclaration2_es6.types b/tests/baselines/reference/MemberFunctionDeclaration2_es6.types
index bfc83ccfd2794..761fd3c8bb824 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration2_es6.types
+++ b/tests/baselines/reference/MemberFunctionDeclaration2_es6.types
@@ -3,5 +3,5 @@ class C {
 >C : C
 
    public * foo() { }
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
 }
diff --git a/tests/baselines/reference/MemberFunctionDeclaration3_es6.types b/tests/baselines/reference/MemberFunctionDeclaration3_es6.types
index e855cfa730d86..97ecf7236b0ed 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration3_es6.types
+++ b/tests/baselines/reference/MemberFunctionDeclaration3_es6.types
@@ -3,6 +3,6 @@ class C {
 >C : C
 
    *[foo]() { }
->[foo] : () => IterableIterator<any>
+>[foo] : () => Generator<never, void, unknown>
 >foo : any
 }
diff --git a/tests/baselines/reference/MemberFunctionDeclaration4_es6.types b/tests/baselines/reference/MemberFunctionDeclaration4_es6.types
index 7717c30a449be..48b1bc1f5917f 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration4_es6.types
+++ b/tests/baselines/reference/MemberFunctionDeclaration4_es6.types
@@ -3,5 +3,5 @@ class C {
 >C : C
 
    *() { }
-> : () => IterableIterator<any>
+> : () => Generator<never, void, unknown>
 }
diff --git a/tests/baselines/reference/MemberFunctionDeclaration7_es6.types b/tests/baselines/reference/MemberFunctionDeclaration7_es6.types
index 8269f67237283..1ee2ffc1433b2 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration7_es6.types
+++ b/tests/baselines/reference/MemberFunctionDeclaration7_es6.types
@@ -3,5 +3,5 @@ class C {
 >C : C
 
    *foo<T>() { }
->foo : <T>() => IterableIterator<any>
+>foo : <T>() => Generator<never, void, unknown>
 }
diff --git a/tests/baselines/reference/YieldExpression10_es6.types b/tests/baselines/reference/YieldExpression10_es6.types
index 966baa031ed32..4f9f400a616fa 100644
--- a/tests/baselines/reference/YieldExpression10_es6.types
+++ b/tests/baselines/reference/YieldExpression10_es6.types
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression10_es6.ts ===
 var v = { * foo() {
->v : { foo(): IterableIterator<any>; }
->{ * foo() {    yield(foo);  }} : { foo(): IterableIterator<any>; }
->foo : () => IterableIterator<any>
+>v : { foo(): Generator<any, void, unknown>; }
+>{ * foo() {    yield(foo);  }} : { foo(): Generator<any, void, unknown>; }
+>foo : () => Generator<any, void, unknown>
 
     yield(foo);
 >yield(foo) : any
diff --git a/tests/baselines/reference/YieldExpression11_es6.types b/tests/baselines/reference/YieldExpression11_es6.types
index 01257e4f95fd9..0ddc8ba936c8c 100644
--- a/tests/baselines/reference/YieldExpression11_es6.types
+++ b/tests/baselines/reference/YieldExpression11_es6.types
@@ -3,7 +3,7 @@ class C {
 >C : C
 
   *foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
     yield(foo);
 >yield(foo) : any
diff --git a/tests/baselines/reference/YieldExpression13_es6.types b/tests/baselines/reference/YieldExpression13_es6.types
index 011ac1e09e8fe..5859828b8fe94 100644
--- a/tests/baselines/reference/YieldExpression13_es6.types
+++ b/tests/baselines/reference/YieldExpression13_es6.types
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression13_es6.ts ===
 function* foo() { yield }
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 >yield : any
 
diff --git a/tests/baselines/reference/YieldExpression16_es6.types b/tests/baselines/reference/YieldExpression16_es6.types
index 661d60a5b58ab..67b956a3cfcec 100644
--- a/tests/baselines/reference/YieldExpression16_es6.types
+++ b/tests/baselines/reference/YieldExpression16_es6.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression16_es6.ts ===
 function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
 
   function bar() {
 >bar : () => void
 
     yield foo;
 >yield foo : any
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
   }
 }
diff --git a/tests/baselines/reference/YieldExpression19_es6.types b/tests/baselines/reference/YieldExpression19_es6.types
index f57b175d53c92..cab1da911c555 100644
--- a/tests/baselines/reference/YieldExpression19_es6.types
+++ b/tests/baselines/reference/YieldExpression19_es6.types
@@ -1,17 +1,17 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression19_es6.ts ===
 function*foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<never, void, unknown>
 
   function bar() {
 >bar : () => void
 
     function* quux() {
->quux : () => IterableIterator<() => IterableIterator<any>>
+>quux : () => Generator<() => Generator<never, void, unknown>, void, unknown>
 
       yield(foo);
 >yield(foo) : any
->(foo) : () => IterableIterator<any>
->foo : () => IterableIterator<any>
+>(foo) : () => Generator<never, void, unknown>
+>foo : () => Generator<never, void, unknown>
     }
   }
 }
diff --git a/tests/baselines/reference/YieldExpression3_es6.types b/tests/baselines/reference/YieldExpression3_es6.types
index 9e2f810d91129..31ea178bc5ab9 100644
--- a/tests/baselines/reference/YieldExpression3_es6.types
+++ b/tests/baselines/reference/YieldExpression3_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression3_es6.ts ===
 function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
   yield
 >yield : any
diff --git a/tests/baselines/reference/YieldExpression4_es6.types b/tests/baselines/reference/YieldExpression4_es6.types
index 929bef38edd1d..c52f9222070e5 100644
--- a/tests/baselines/reference/YieldExpression4_es6.types
+++ b/tests/baselines/reference/YieldExpression4_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression4_es6.ts ===
 function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
   yield;
 >yield : any
diff --git a/tests/baselines/reference/YieldExpression5_es6.types b/tests/baselines/reference/YieldExpression5_es6.types
index 77a003d09228c..6ff16d8cd8db1 100644
--- a/tests/baselines/reference/YieldExpression5_es6.types
+++ b/tests/baselines/reference/YieldExpression5_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression5_es6.ts ===
 function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, any>
 
   yield*
 >yield* : any
diff --git a/tests/baselines/reference/YieldExpression7_es6.types b/tests/baselines/reference/YieldExpression7_es6.types
index 44dcc196c3bdc..8ebaa07ef604c 100644
--- a/tests/baselines/reference/YieldExpression7_es6.types
+++ b/tests/baselines/reference/YieldExpression7_es6.types
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression7_es6.ts ===
 function* foo() {
->foo : () => IterableIterator<typeof foo>
+>foo : () => Generator<typeof foo, void, unknown>
 
   yield foo
 >yield foo : any
->foo : () => IterableIterator<typeof foo>
+>foo : () => Generator<typeof foo, void, unknown>
 }
diff --git a/tests/baselines/reference/YieldExpression8_es6.types b/tests/baselines/reference/YieldExpression8_es6.types
index 67343e3fbfcc8..66935c18cc5c5 100644
--- a/tests/baselines/reference/YieldExpression8_es6.types
+++ b/tests/baselines/reference/YieldExpression8_es6.types
@@ -2,13 +2,13 @@
 yield(foo);
 >yield(foo) : any
 >yield : any
->foo : () => IterableIterator<typeof foo>
+>foo : () => Generator<typeof foo, void, unknown>
 
 function* foo() {
->foo : () => IterableIterator<typeof foo>
+>foo : () => Generator<typeof foo, void, unknown>
 
   yield(foo);
 >yield(foo) : any
->(foo) : () => IterableIterator<typeof foo>
->foo : () => IterableIterator<typeof foo>
+>(foo) : () => Generator<typeof foo, void, unknown>
+>foo : () => Generator<typeof foo, void, unknown>
 }
diff --git a/tests/baselines/reference/YieldExpression9_es6.types b/tests/baselines/reference/YieldExpression9_es6.types
index 109dc27058347..e277bc711c57b 100644
--- a/tests/baselines/reference/YieldExpression9_es6.types
+++ b/tests/baselines/reference/YieldExpression9_es6.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldExpression9_es6.ts ===
 var v = function*() {
->v : () => IterableIterator<any>
->function*() {  yield(foo);} : () => IterableIterator<any>
+>v : () => Generator<any, void, unknown>
+>function*() {  yield(foo);} : () => Generator<any, void, unknown>
 
   yield(foo);
 >yield(foo) : any
diff --git a/tests/baselines/reference/YieldStarExpression3_es6.types b/tests/baselines/reference/YieldStarExpression3_es6.types
index 5bc03855b196b..46d71934225df 100644
--- a/tests/baselines/reference/YieldStarExpression3_es6.types
+++ b/tests/baselines/reference/YieldStarExpression3_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldStarExpression3_es6.ts ===
 function *g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, void, any>
 
     yield *;
 >yield * : any
diff --git a/tests/baselines/reference/YieldStarExpression4_es6.types b/tests/baselines/reference/YieldStarExpression4_es6.types
index 86b727306d473..5a1ebbe6a6e12 100644
--- a/tests/baselines/reference/YieldStarExpression4_es6.types
+++ b/tests/baselines/reference/YieldStarExpression4_es6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/YieldStarExpression4_es6.ts ===
 function *g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, void, undefined>
 
     yield * [];
 >yield * [] : any
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 479ba22f2a1ab..dfb9947447fa6 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -53,7 +53,7 @@ declare namespace ts {
     interface Iterator<T> {
         next(): {
             value: T;
-            done: false;
+            done?: false;
         } | {
             value: never;
             done: true;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index c7e0403140f30..a0833bf618ebb 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -53,7 +53,7 @@ declare namespace ts {
     interface Iterator<T> {
         next(): {
             value: T;
-            done: false;
+            done?: false;
         } | {
             value: never;
             done: true;
diff --git a/tests/baselines/reference/asyncImportNestedYield.types b/tests/baselines/reference/asyncImportNestedYield.types
index f7fbfa8f96200..59cd72d54652a 100644
--- a/tests/baselines/reference/asyncImportNestedYield.types
+++ b/tests/baselines/reference/asyncImportNestedYield.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/asyncImportNestedYield.ts ===
 async function* foo() {
->foo : () => AsyncIterableIterator<string>
+>foo : () => AsyncGenerator<string, void, string>
 
     import((await import(yield "foo")).default);
 >import((await import(yield "foo")).default) : Promise<any>
diff --git a/tests/baselines/reference/asyncMethodWithSuper_es6.types b/tests/baselines/reference/asyncMethodWithSuper_es6.types
index ae78d8bc3adde..5dcc642146a93 100644
--- a/tests/baselines/reference/asyncMethodWithSuper_es6.types
+++ b/tests/baselines/reference/asyncMethodWithSuper_es6.types
@@ -336,7 +336,7 @@ class B extends A {
     }
 
     async * property_access_only_read_only_in_generator() {
->property_access_only_read_only_in_generator : () => AsyncIterableIterator<any>
+>property_access_only_read_only_in_generator : () => AsyncGenerator<never, void, unknown>
 
         // call with property access
         super.x();
@@ -372,7 +372,7 @@ class B extends A {
     }
 
     async * property_access_only_write_only_in_generator() {
->property_access_only_write_only_in_generator : () => AsyncIterableIterator<any>
+>property_access_only_write_only_in_generator : () => AsyncGenerator<never, void, unknown>
 
         const f = () => {};
 >f : () => void
@@ -420,7 +420,7 @@ class B extends A {
     }
 
     async * element_access_only_read_only_in_generator() {
->element_access_only_read_only_in_generator : () => AsyncIterableIterator<any>
+>element_access_only_read_only_in_generator : () => AsyncGenerator<never, void, unknown>
 
         // call with element access
         super["x"]();
@@ -456,7 +456,7 @@ class B extends A {
     }
 
     async * element_access_only_write_only_in_generator() {
->element_access_only_write_only_in_generator : () => AsyncIterableIterator<any>
+>element_access_only_write_only_in_generator : () => AsyncGenerator<never, void, unknown>
 
         const f = () => {};
 >f : () => void
diff --git a/tests/baselines/reference/awaitInNonAsyncFunction.types b/tests/baselines/reference/awaitInNonAsyncFunction.types
index 78b9a6c5a9027..1f52194877942 100644
--- a/tests/baselines/reference/awaitInNonAsyncFunction.types
+++ b/tests/baselines/reference/awaitInNonAsyncFunction.types
@@ -57,7 +57,7 @@ const arrowFunc = (p: Promise<number>) => {
 };
 
 function* generatorFunc(p: Promise<number>) {
->generatorFunc : (p: Promise<number>) => IterableIterator<number>
+>generatorFunc : (p: Promise<number>) => Generator<number, void, unknown>
 >p : Promise<number>
 
   for await (const _ of []);
diff --git a/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types
index cf93e7c2f4d21..5f9692654bafb 100644
--- a/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types
+++ b/tests/baselines/reference/blockScopedBindingsInDownlevelGenerator.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/blockScopedBindingsInDownlevelGenerator.ts ===
 function* a() {
->a : () => IterableIterator<number>
+>a : () => Generator<number, void, unknown>
 
   for (const i of [1,2,3]) {
 >i : number
diff --git a/tests/baselines/reference/capturedParametersInInitializers1.types b/tests/baselines/reference/capturedParametersInInitializers1.types
index 4819298d1afa3..aa0df80902e33 100644
--- a/tests/baselines/reference/capturedParametersInInitializers1.types
+++ b/tests/baselines/reference/capturedParametersInInitializers1.types
@@ -82,11 +82,11 @@ function foo6(y = () => (() => z)(), z = 1) {
 
 // ok - used inside immediately invoked generator function
 function foo7(y = (function*() {yield z})(), z = 1) {
->foo7 : (y?: IterableIterator<number>, z?: number) => void
->y : IterableIterator<number>
->(function*() {yield z})() : IterableIterator<number>
->(function*() {yield z}) : () => IterableIterator<number>
->function*() {yield z} : () => IterableIterator<number>
+>foo7 : (y?: Generator<number, void, unknown>, z?: number) => void
+>y : Generator<number, void, unknown>
+>(function*() {yield z})() : Generator<number, void, unknown>
+>(function*() {yield z}) : () => Generator<number, void, unknown>
+>function*() {yield z} : () => Generator<number, void, unknown>
 >yield z : any
 >z : number
 >z : number
diff --git a/tests/baselines/reference/castOfYield.errors.txt b/tests/baselines/reference/castOfYield.errors.txt
index 0d40a4dcd987d..90725000c909d 100644
--- a/tests/baselines/reference/castOfYield.errors.txt
+++ b/tests/baselines/reference/castOfYield.errors.txt
@@ -1,8 +1,8 @@
-error TS2318: Cannot find global type 'IterableIterator'.
+error TS2318: Cannot find global type 'Generator'.
 tests/cases/compiler/castOfYield.ts(4,14): error TS1109: Expression expected.
 
 
-!!! error TS2318: Cannot find global type 'IterableIterator'.
+!!! error TS2318: Cannot find global type 'Generator'.
 ==== tests/cases/compiler/castOfYield.ts (1 errors) ====
     function* f() {
         <number> (yield 0);
diff --git a/tests/baselines/reference/controlFlowIIFE.types b/tests/baselines/reference/controlFlowIIFE.types
index 2116cfaa2aef2..64207b27061b2 100644
--- a/tests/baselines/reference/controlFlowIIFE.types
+++ b/tests/baselines/reference/controlFlowIIFE.types
@@ -181,9 +181,9 @@ function f5() {
 >v : number
 
     (function*() {
->(function*() {        yield 1;        v = 1;    })() : IterableIterator<number>
->(function*() {        yield 1;        v = 1;    }) : () => IterableIterator<number>
->function*() {        yield 1;        v = 1;    } : () => IterableIterator<number>
+>(function*() {        yield 1;        v = 1;    })() : Generator<number, void, unknown>
+>(function*() {        yield 1;        v = 1;    }) : () => Generator<number, void, unknown>
+>function*() {        yield 1;        v = 1;    } : () => Generator<number, void, unknown>
 
         yield 1;
 >yield 1 : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types
index c6d6fb6758d13..54013c11fce41 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types
@@ -3,7 +3,7 @@ class C1 {
 >C1 : C1
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/C2.ts ===
@@ -11,7 +11,7 @@ class C2 {
 >C2 : C2
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = yield;
 >x : any
@@ -23,7 +23,7 @@ class C3 {
 >C3 : C3
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield 1;
 >x : any
@@ -36,7 +36,7 @@ class C4 {
 >C4 : C4
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
         const x = yield* [1];
 >x : any
@@ -50,14 +50,14 @@ class C5 {
 >C5 : C5
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
     }
@@ -67,7 +67,7 @@ class C6 {
 >C6 : C6
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = await 1;
 >x : 1
@@ -80,7 +80,7 @@ class C7 {
 >C7 : C7
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<never, number, unknown>
 
         return 1;
 >1 : 1
@@ -94,7 +94,7 @@ class C8 {
 >g : () => void
     }
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         this.g();
 >this.g() : void
@@ -115,7 +115,7 @@ class C9 extends B9 {
 >B9 : B9
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         super.g();
 >super.g() : void
diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types
index 17fefc54e8130..7c439f49b7fd3 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types
@@ -3,7 +3,7 @@ class C1 {
 >C1 : C1
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/C2.ts ===
@@ -11,7 +11,7 @@ class C2 {
 >C2 : C2
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = yield;
 >x : any
@@ -23,7 +23,7 @@ class C3 {
 >C3 : C3
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield 1;
 >x : any
@@ -36,7 +36,7 @@ class C4 {
 >C4 : C4
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
         const x = yield* [1];
 >x : any
@@ -50,14 +50,14 @@ class C5 {
 >C5 : C5
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
     }
@@ -67,7 +67,7 @@ class C6 {
 >C6 : C6
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = await 1;
 >x : 1
@@ -80,7 +80,7 @@ class C7 {
 >C7 : C7
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<never, number, unknown>
 
         return 1;
 >1 : 1
@@ -94,7 +94,7 @@ class C8 {
 >g : () => void
     }
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         this.g();
 >this.g() : void
@@ -115,7 +115,7 @@ class C9 extends B9 {
 >B9 : B9
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         super.g();
 >super.g() : void
diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types
index 5d636d2400c6f..bb62ad37038b2 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types
@@ -3,7 +3,7 @@ class C1 {
 >C1 : C1
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/C2.ts ===
@@ -11,7 +11,7 @@ class C2 {
 >C2 : C2
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = yield;
 >x : any
@@ -23,7 +23,7 @@ class C3 {
 >C3 : C3
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield 1;
 >x : any
@@ -36,7 +36,7 @@ class C4 {
 >C4 : C4
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
         const x = yield* [1];
 >x : any
@@ -50,14 +50,14 @@ class C5 {
 >C5 : C5
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
     }
@@ -67,7 +67,7 @@ class C6 {
 >C6 : C6
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = await 1;
 >x : 1
@@ -80,7 +80,7 @@ class C7 {
 >C7 : C7
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<never, number, unknown>
 
         return 1;
 >1 : 1
@@ -94,7 +94,7 @@ class C8 {
 >g : () => void
     }
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         this.g();
 >this.g() : void
@@ -115,7 +115,7 @@ class C9 extends B9 {
 >B9 : B9
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         super.g();
 >super.g() : void
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types
index 15ff1298b21ac..3dd1afd236d03 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F1.ts ===
 async function * f1() {
->f1 : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F2.ts ===
 async function * f2() {
->f2 : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<any, void, unknown>
 
     const x = yield;
 >x : any
@@ -12,7 +12,7 @@ async function * f2() {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F3.ts ===
 async function * f3() {
->f3 : () => AsyncIterableIterator<number>
+>f3 : () => AsyncGenerator<number, void, unknown>
 
     const x = yield 1;
 >x : any
@@ -21,7 +21,7 @@ async function * f3() {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F4.ts ===
 async function * f4() {
->f4 : () => AsyncIterableIterator<number>
+>f4 : () => AsyncGenerator<number, void, undefined>
 
     const x = yield* [1];
 >x : any
@@ -31,20 +31,20 @@ async function * f4() {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F5.ts ===
 async function * f5() {
->f5 : () => AsyncIterableIterator<number>
+>f5 : () => AsyncGenerator<number, void, unknown>
 
     const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F6.ts ===
 async function * f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -53,7 +53,7 @@ async function * f6() {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F7.ts ===
 async function * f7() {
->f7 : () => AsyncIterableIterator<number>
+>f7 : () => AsyncGenerator<never, number, unknown>
 
     return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types
index 8ffd5534e4086..9034f795efde6 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts ===
 async function * f1() {
->f1 : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts ===
 async function * f2() {
->f2 : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<any, void, unknown>
 
     const x = yield;
 >x : any
@@ -12,7 +12,7 @@ async function * f2() {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts ===
 async function * f3() {
->f3 : () => AsyncIterableIterator<number>
+>f3 : () => AsyncGenerator<number, void, unknown>
 
     const x = yield 1;
 >x : any
@@ -21,7 +21,7 @@ async function * f3() {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts ===
 async function * f4() {
->f4 : () => AsyncIterableIterator<number>
+>f4 : () => AsyncGenerator<number, void, undefined>
 
     const x = yield* [1];
 >x : any
@@ -31,20 +31,20 @@ async function * f4() {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts ===
 async function * f5() {
->f5 : () => AsyncIterableIterator<number>
+>f5 : () => AsyncGenerator<number, void, unknown>
 
     const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts ===
 async function * f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -53,7 +53,7 @@ async function * f6() {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts ===
 async function * f7() {
->f7 : () => AsyncIterableIterator<number>
+>f7 : () => AsyncGenerator<never, number, unknown>
 
     return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types
index 6220f5efd1eca..9771364486f05 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types
@@ -1,10 +1,10 @@
 === tests/cases/conformance/emitter/es5/asyncGenerators/F1.ts ===
 async function * f1() {
->f1 : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F2.ts ===
 async function * f2() {
->f2 : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<any, void, unknown>
 
     const x = yield;
 >x : any
@@ -12,7 +12,7 @@ async function * f2() {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F3.ts ===
 async function * f3() {
->f3 : () => AsyncIterableIterator<number>
+>f3 : () => AsyncGenerator<number, void, unknown>
 
     const x = yield 1;
 >x : any
@@ -21,7 +21,7 @@ async function * f3() {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F4.ts ===
 async function * f4() {
->f4 : () => AsyncIterableIterator<number>
+>f4 : () => AsyncGenerator<number, void, undefined>
 
     const x = yield* [1];
 >x : any
@@ -31,20 +31,20 @@ async function * f4() {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F5.ts ===
 async function * f5() {
->f5 : () => AsyncIterableIterator<number>
+>f5 : () => AsyncGenerator<number, void, unknown>
 
     const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F6.ts ===
 async function * f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -53,7 +53,7 @@ async function * f6() {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F7.ts ===
 async function * f7() {
->f7 : () => AsyncIterableIterator<number>
+>f7 : () => AsyncGenerator<never, number, unknown>
 
     return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types
index 1db2126b7ed83..ee48f52f77ad4 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F1.ts ===
 const f1 = async function * () {
->f1 : () => AsyncIterableIterator<any>
->async function * () {} : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
+>async function * () {} : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F2.ts ===
 const f2 = async function * () {
->f2 : () => AsyncIterableIterator<any>
->async function * () {    const x = yield;} : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<any, void, unknown>
+>async function * () {    const x = yield;} : () => AsyncGenerator<any, void, unknown>
 
     const x = yield;
 >x : any
@@ -14,8 +14,8 @@ const f2 = async function * () {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F3.ts ===
 const f3 = async function * () {
->f3 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield 1;} : () => AsyncIterableIterator<number>
+>f3 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    const x = yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     const x = yield 1;
 >x : any
@@ -24,8 +24,8 @@ const f3 = async function * () {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F4.ts ===
 const f4 = async function * () {
->f4 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield* [1];} : () => AsyncIterableIterator<number>
+>f4 : () => AsyncGenerator<number, void, undefined>
+>async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, undefined>
 
     const x = yield* [1];
 >x : any
@@ -35,22 +35,22 @@ const f4 = async function * () {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F5.ts ===
 const f5 = async function * () {
->f5 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator<number>
+>f5 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    const x = yield* (async function*() { yield 1; })();} : () => AsyncGenerator<number, void, unknown>
 
     const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F6.ts ===
 const f6 = async function * () {
->f6 : () => AsyncIterableIterator<any>
->async function * () {    const x = await 1;} : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    const x = await 1;} : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -59,8 +59,8 @@ const f6 = async function * () {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/F7.ts ===
 const f7 = async function * () {
->f7 : () => AsyncIterableIterator<number>
->async function * () {    return 1;} : () => AsyncIterableIterator<number>
+>f7 : () => AsyncGenerator<never, number, unknown>
+>async function * () {    return 1;} : () => AsyncGenerator<never, number, unknown>
 
     return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types
index 07ee0579bedab..8f09c423ecdbd 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F1.ts ===
 const f1 = async function * () {
->f1 : () => AsyncIterableIterator<any>
->async function * () {} : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
+>async function * () {} : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F2.ts ===
 const f2 = async function * () {
->f2 : () => AsyncIterableIterator<any>
->async function * () {    const x = yield;} : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<any, void, unknown>
+>async function * () {    const x = yield;} : () => AsyncGenerator<any, void, unknown>
 
     const x = yield;
 >x : any
@@ -14,8 +14,8 @@ const f2 = async function * () {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F3.ts ===
 const f3 = async function * () {
->f3 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield 1;} : () => AsyncIterableIterator<number>
+>f3 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    const x = yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     const x = yield 1;
 >x : any
@@ -24,8 +24,8 @@ const f3 = async function * () {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F4.ts ===
 const f4 = async function * () {
->f4 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield* [1];} : () => AsyncIterableIterator<number>
+>f4 : () => AsyncGenerator<number, void, undefined>
+>async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, undefined>
 
     const x = yield* [1];
 >x : any
@@ -35,22 +35,22 @@ const f4 = async function * () {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F5.ts ===
 const f5 = async function * () {
->f5 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator<number>
+>f5 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    const x = yield* (async function*() { yield 1; })();} : () => AsyncGenerator<number, void, unknown>
 
     const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F6.ts ===
 const f6 = async function * () {
->f6 : () => AsyncIterableIterator<any>
->async function * () {    const x = await 1;} : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    const x = await 1;} : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -59,8 +59,8 @@ const f6 = async function * () {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/F7.ts ===
 const f7 = async function * () {
->f7 : () => AsyncIterableIterator<number>
->async function * () {    return 1;} : () => AsyncIterableIterator<number>
+>f7 : () => AsyncGenerator<never, number, unknown>
+>async function * () {    return 1;} : () => AsyncGenerator<never, number, unknown>
 
     return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types
index e9da600bdbf1c..b92f49da91f92 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/emitter/es5/asyncGenerators/F1.ts ===
 const f1 = async function * () {
->f1 : () => AsyncIterableIterator<any>
->async function * () {} : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
+>async function * () {} : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F2.ts ===
 const f2 = async function * () {
->f2 : () => AsyncIterableIterator<any>
->async function * () {    const x = yield;} : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<any, void, unknown>
+>async function * () {    const x = yield;} : () => AsyncGenerator<any, void, unknown>
 
     const x = yield;
 >x : any
@@ -14,8 +14,8 @@ const f2 = async function * () {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F3.ts ===
 const f3 = async function * () {
->f3 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield 1;} : () => AsyncIterableIterator<number>
+>f3 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    const x = yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     const x = yield 1;
 >x : any
@@ -24,8 +24,8 @@ const f3 = async function * () {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F4.ts ===
 const f4 = async function * () {
->f4 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield* [1];} : () => AsyncIterableIterator<number>
+>f4 : () => AsyncGenerator<number, void, undefined>
+>async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, undefined>
 
     const x = yield* [1];
 >x : any
@@ -35,22 +35,22 @@ const f4 = async function * () {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F5.ts ===
 const f5 = async function * () {
->f5 : () => AsyncIterableIterator<number>
->async function * () {    const x = yield* (async function*() { yield 1; })();} : () => AsyncIterableIterator<number>
+>f5 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    const x = yield* (async function*() { yield 1; })();} : () => AsyncGenerator<number, void, unknown>
 
     const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F6.ts ===
 const f6 = async function * () {
->f6 : () => AsyncIterableIterator<any>
->async function * () {    const x = await 1;} : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    const x = await 1;} : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -59,8 +59,8 @@ const f6 = async function * () {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/F7.ts ===
 const f7 = async function * () {
->f7 : () => AsyncIterableIterator<number>
->async function * () {    return 1;} : () => AsyncIterableIterator<number>
+>f7 : () => AsyncGenerator<never, number, unknown>
+>async function * () {    return 1;} : () => AsyncGenerator<never, number, unknown>
 
     return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types
index 9e47fc9d98932..5d9d79da63429 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types
@@ -1,19 +1,19 @@
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O1.ts ===
 const o1 = {
->o1 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {    }} : { f(): AsyncIterableIterator<any>; }
+>o1 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O2.ts ===
 const o2 = {
->o2 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = yield;    }} : { f(): AsyncIterableIterator<any>; }
+>o2 : { f(): AsyncGenerator<any, void, unknown>; }
+>{    async * f() {        const x = yield;    }} : { f(): AsyncGenerator<any, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = yield;
 >x : any
@@ -22,11 +22,11 @@ const o2 = {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O3.ts ===
 const o3 = {
->o3 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o3 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        const x = yield 1;    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield 1;
 >x : any
@@ -36,11 +36,11 @@ const o3 = {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O4.ts ===
 const o4 = {
->o4 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield* [1];    }} : { f(): AsyncIterableIterator<number>; }
+>o4 : { f(): AsyncGenerator<number, void, undefined>; }
+>{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, undefined>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
         const x = yield* [1];
 >x : any
@@ -51,29 +51,29 @@ const o4 = {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O5.ts ===
 const o5 = {
->o5 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield* (async function*() { yield 1; })();    }} : { f(): AsyncIterableIterator<number>; }
+>o5 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        const x = yield* (async function*() { yield 1; })();    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
     }
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O6.ts ===
 const o6 = {
->o6 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = await 1;    }} : { f(): AsyncIterableIterator<any>; }
+>o6 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        const x = await 1;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = await 1;
 >x : 1
@@ -83,11 +83,11 @@ const o6 = {
 }
 === tests/cases/conformance/emitter/es2015/asyncGenerators/O7.ts ===
 const o7 = {
->o7 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        return 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o7 : { f(): AsyncGenerator<never, number, unknown>; }
+>{    async * f() {        return 1;    }} : { f(): AsyncGenerator<never, number, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<never, number, unknown>
 
         return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types
index 4b33425a7a47d..5b0b63b66e4e1 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types
@@ -1,19 +1,19 @@
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O1.ts ===
 const o1 = {
->o1 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {    }} : { f(): AsyncIterableIterator<any>; }
+>o1 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O2.ts ===
 const o2 = {
->o2 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = yield;    }} : { f(): AsyncIterableIterator<any>; }
+>o2 : { f(): AsyncGenerator<any, void, unknown>; }
+>{    async * f() {        const x = yield;    }} : { f(): AsyncGenerator<any, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = yield;
 >x : any
@@ -22,11 +22,11 @@ const o2 = {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O3.ts ===
 const o3 = {
->o3 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o3 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        const x = yield 1;    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield 1;
 >x : any
@@ -36,11 +36,11 @@ const o3 = {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O4.ts ===
 const o4 = {
->o4 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield* [1];    }} : { f(): AsyncIterableIterator<number>; }
+>o4 : { f(): AsyncGenerator<number, void, undefined>; }
+>{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, undefined>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
         const x = yield* [1];
 >x : any
@@ -51,29 +51,29 @@ const o4 = {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O5.ts ===
 const o5 = {
->o5 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield* (async function*() { yield 1; })();    }} : { f(): AsyncIterableIterator<number>; }
+>o5 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        const x = yield* (async function*() { yield 1; })();    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
     }
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O6.ts ===
 const o6 = {
->o6 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = await 1;    }} : { f(): AsyncIterableIterator<any>; }
+>o6 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        const x = await 1;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = await 1;
 >x : 1
@@ -83,11 +83,11 @@ const o6 = {
 }
 === tests/cases/conformance/emitter/es2018/asyncGenerators/O7.ts ===
 const o7 = {
->o7 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        return 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o7 : { f(): AsyncGenerator<never, number, unknown>; }
+>{    async * f() {        return 1;    }} : { f(): AsyncGenerator<never, number, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<never, number, unknown>
 
         return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types
index 390007605083d..b4ab8ea8480c9 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types
@@ -1,19 +1,19 @@
 === tests/cases/conformance/emitter/es5/asyncGenerators/O1.ts ===
 const o1 = {
->o1 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {    }} : { f(): AsyncIterableIterator<any>; }
+>o1 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/O2.ts ===
 const o2 = {
->o2 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = yield;    }} : { f(): AsyncIterableIterator<any>; }
+>o2 : { f(): AsyncGenerator<any, void, unknown>; }
+>{    async * f() {        const x = yield;    }} : { f(): AsyncGenerator<any, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = yield;
 >x : any
@@ -22,11 +22,11 @@ const o2 = {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/O3.ts ===
 const o3 = {
->o3 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o3 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        const x = yield 1;    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield 1;
 >x : any
@@ -36,11 +36,11 @@ const o3 = {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/O4.ts ===
 const o4 = {
->o4 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield* [1];    }} : { f(): AsyncIterableIterator<number>; }
+>o4 : { f(): AsyncGenerator<number, void, undefined>; }
+>{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, undefined>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
         const x = yield* [1];
 >x : any
@@ -51,29 +51,29 @@ const o4 = {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/O5.ts ===
 const o5 = {
->o5 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        const x = yield* (async function*() { yield 1; })();    }} : { f(): AsyncIterableIterator<number>; }
+>o5 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        const x = yield* (async function*() { yield 1; })();    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         const x = yield* (async function*() { yield 1; })();
->x : any
->yield* (async function*() { yield 1; })() : any
->(async function*() { yield 1; })() : AsyncIterableIterator<number>
->(async function*() { yield 1; }) : () => AsyncIterableIterator<number>
->async function*() { yield 1; } : () => AsyncIterableIterator<number>
+>x : void
+>yield* (async function*() { yield 1; })() : void
+>(async function*() { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function*() { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function*() { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
     }
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/O6.ts ===
 const o6 = {
->o6 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = await 1;    }} : { f(): AsyncIterableIterator<any>; }
+>o6 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        const x = await 1;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = await 1;
 >x : 1
@@ -83,11 +83,11 @@ const o6 = {
 }
 === tests/cases/conformance/emitter/es5/asyncGenerators/O7.ts ===
 const o7 = {
->o7 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        return 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o7 : { f(): AsyncGenerator<never, number, unknown>; }
+>{    async * f() {        return 1;    }} : { f(): AsyncGenerator<never, number, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<never, number, unknown>
 
         return 1;
 >1 : 1
diff --git a/tests/baselines/reference/emitter.forAwait.es2015.types b/tests/baselines/reference/emitter.forAwait.es2015.types
index e7d1c77f34652..3c345386c3735 100644
--- a/tests/baselines/reference/emitter.forAwait.es2015.types
+++ b/tests/baselines/reference/emitter.forAwait.es2015.types
@@ -25,7 +25,7 @@ async function f2() {
 }
 === tests/cases/conformance/emitter/es2015/forAwait/file3.ts ===
 async function* f3() {
->f3 : () => AsyncIterableIterator<any>
+>f3 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
@@ -37,7 +37,7 @@ async function* f3() {
 }
 === tests/cases/conformance/emitter/es2015/forAwait/file4.ts ===
 async function* f4() {
->f4 : () => AsyncIterableIterator<any>
+>f4 : () => AsyncGenerator<never, void, unknown>
 
     let x: any, y: any;
 >x : any
@@ -68,7 +68,7 @@ async function f5() {
 === tests/cases/conformance/emitter/es2015/forAwait/file6.ts ===
 // https://github.com/Microsoft/TypeScript/issues/21363
 async function* f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
diff --git a/tests/baselines/reference/emitter.forAwait.es2017.types b/tests/baselines/reference/emitter.forAwait.es2017.types
index f1dffdd280a72..19642ddd67706 100644
--- a/tests/baselines/reference/emitter.forAwait.es2017.types
+++ b/tests/baselines/reference/emitter.forAwait.es2017.types
@@ -25,7 +25,7 @@ async function f2() {
 }
 === tests/cases/conformance/emitter/es2017/forAwait/file3.ts ===
 async function* f3() {
->f3 : () => AsyncIterableIterator<any>
+>f3 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
@@ -37,7 +37,7 @@ async function* f3() {
 }
 === tests/cases/conformance/emitter/es2017/forAwait/file4.ts ===
 async function* f4() {
->f4 : () => AsyncIterableIterator<any>
+>f4 : () => AsyncGenerator<never, void, unknown>
 
     let x: any, y: any;
 >x : any
@@ -68,7 +68,7 @@ async function f5() {
 === tests/cases/conformance/emitter/es2017/forAwait/file6.ts ===
 // https://github.com/Microsoft/TypeScript/issues/21363
 async function* f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
diff --git a/tests/baselines/reference/emitter.forAwait.es2018.types b/tests/baselines/reference/emitter.forAwait.es2018.types
index c9954de364da1..a9b3a94dead77 100644
--- a/tests/baselines/reference/emitter.forAwait.es2018.types
+++ b/tests/baselines/reference/emitter.forAwait.es2018.types
@@ -25,7 +25,7 @@ async function f2() {
 }
 === tests/cases/conformance/emitter/es2018/forAwait/file3.ts ===
 async function* f3() {
->f3 : () => AsyncIterableIterator<any>
+>f3 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
@@ -37,7 +37,7 @@ async function* f3() {
 }
 === tests/cases/conformance/emitter/es2018/forAwait/file4.ts ===
 async function* f4() {
->f4 : () => AsyncIterableIterator<any>
+>f4 : () => AsyncGenerator<never, void, unknown>
 
     let x: any, y: any;
 >x : any
@@ -68,7 +68,7 @@ async function f5() {
 === tests/cases/conformance/emitter/es2018/forAwait/file6.ts ===
 // https://github.com/Microsoft/TypeScript/issues/21363
 async function* f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
diff --git a/tests/baselines/reference/emitter.forAwait.es5.types b/tests/baselines/reference/emitter.forAwait.es5.types
index fe0a49a901675..1452be304b6f3 100644
--- a/tests/baselines/reference/emitter.forAwait.es5.types
+++ b/tests/baselines/reference/emitter.forAwait.es5.types
@@ -25,7 +25,7 @@ async function f2() {
 }
 === tests/cases/conformance/emitter/es5/forAwait/file3.ts ===
 async function* f3() {
->f3 : () => AsyncIterableIterator<any>
+>f3 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
@@ -37,7 +37,7 @@ async function* f3() {
 }
 === tests/cases/conformance/emitter/es5/forAwait/file4.ts ===
 async function* f4() {
->f4 : () => AsyncIterableIterator<any>
+>f4 : () => AsyncGenerator<never, void, unknown>
 
     let x: any, y: any;
 >x : any
@@ -68,7 +68,7 @@ async function f5() {
 === tests/cases/conformance/emitter/es5/forAwait/file6.ts ===
 // https://github.com/Microsoft/TypeScript/issues/21363
 async function* f6() {
->f6 : () => AsyncIterableIterator<any>
+>f6 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
diff --git a/tests/baselines/reference/expressionsForbiddenInParameterInitializers.types b/tests/baselines/reference/expressionsForbiddenInParameterInitializers.types
index 6142c1066facc..f70d546fce274 100644
--- a/tests/baselines/reference/expressionsForbiddenInParameterInitializers.types
+++ b/tests/baselines/reference/expressionsForbiddenInParameterInitializers.types
@@ -8,7 +8,7 @@ export async function foo({ foo = await import("./bar") }) {
 }
 
 export function* foo2({ foo = yield "a" }) {
->foo2 : ({ foo }: { foo?: any; }) => IterableIterator<any>
+>foo2 : ({ foo }: { foo?: any; }) => Generator<never, void, unknown>
 >foo : any
 >yield "a" : any
 >"a" : "a"
diff --git a/tests/baselines/reference/for-of29.errors.txt b/tests/baselines/reference/for-of29.errors.txt
index 748fcf490505a..0f1bead3f13c9 100644
--- a/tests/baselines/reference/for-of29.errors.txt
+++ b/tests/baselines/reference/for-of29.errors.txt
@@ -1,5 +1,4 @@
-tests/cases/conformance/es6/for-ofStatements/for-of29.ts(5,15): error TS2322: Type '{ [Symbol.iterator]?(): Iterator<string>; }' is not assignable to type 'Iterable<string>'.
-  Property '[Symbol.iterator]' is optional in type '{ [Symbol.iterator]?(): Iterator<string>; }' but required in type 'Iterable<string>'.
+tests/cases/conformance/es6/for-ofStatements/for-of29.ts(5,15): error TS2488: Type '{ [Symbol.iterator]?(): Iterator<string, any, undefined>; }' must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== tests/cases/conformance/es6/for-ofStatements/for-of29.ts (1 errors) ====
@@ -9,6 +8,5 @@ tests/cases/conformance/es6/for-ofStatements/for-of29.ts(5,15): error TS2322: Ty
     
     for (var v of iterableWithOptionalIterator) { }
                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2322: Type '{ [Symbol.iterator]?(): Iterator<string>; }' is not assignable to type 'Iterable<string>'.
-!!! error TS2322:   Property '[Symbol.iterator]' is optional in type '{ [Symbol.iterator]?(): Iterator<string>; }' but required in type 'Iterable<string>'.
+!!! error TS2488: Type '{ [Symbol.iterator]?(): Iterator<string, any, undefined>; }' must have a '[Symbol.iterator]()' method that returns an iterator.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of29.types b/tests/baselines/reference/for-of29.types
index 51c820128937a..2f246b56860d5 100644
--- a/tests/baselines/reference/for-of29.types
+++ b/tests/baselines/reference/for-of29.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of29.ts ===
 var iterableWithOptionalIterator: {
->iterableWithOptionalIterator : { [Symbol.iterator]?(): Iterator<string>; }
+>iterableWithOptionalIterator : { [Symbol.iterator]?(): Iterator<string, any, undefined>; }
 
     [Symbol.iterator]?(): Iterator<string>
->[Symbol.iterator] : () => Iterator<string>
+>[Symbol.iterator] : () => Iterator<string, any, undefined>
 >Symbol.iterator : symbol
 >Symbol : SymbolConstructor
 >iterator : symbol
@@ -11,6 +11,6 @@ var iterableWithOptionalIterator: {
 };
 
 for (var v of iterableWithOptionalIterator) { }
->v : string
->iterableWithOptionalIterator : { [Symbol.iterator]?(): Iterator<string>; }
+>v : any
+>iterableWithOptionalIterator : { [Symbol.iterator]?(): Iterator<string, any, undefined>; }
 
diff --git a/tests/baselines/reference/for-of30.errors.txt b/tests/baselines/reference/for-of30.errors.txt
index b0091c90b57c3..5d9f5d4d1b65f 100644
--- a/tests/baselines/reference/for-of30.errors.txt
+++ b/tests/baselines/reference/for-of30.errors.txt
@@ -1,9 +1,4 @@
-tests/cases/conformance/es6/for-ofStatements/for-of30.ts(16,15): error TS2322: Type 'StringIterator' is not assignable to type 'Iterable<string>'.
-  Types of property '[Symbol.iterator]' are incompatible.
-    Type '() => StringIterator' is not assignable to type '() => Iterator<string>'.
-      Type 'StringIterator' is not assignable to type 'Iterator<string>'.
-        Types of property 'return' are incompatible.
-          Type 'number' is not assignable to type '(value?: any) => IteratorResult<string>'.
+tests/cases/conformance/es6/for-ofStatements/for-of30.ts(16,15): error TS2767: The 'return' property of an iterator must be a method.
 
 
 ==== tests/cases/conformance/es6/for-ofStatements/for-of30.ts (1 errors) ====
@@ -14,9 +9,9 @@ tests/cases/conformance/es6/for-ofStatements/for-of30.ts(16,15): error TS2322: T
                 value: ""
             }
         }
-        
+    
         return = 0;
-        
+    
         [Symbol.iterator]() {
             return this;
         }
@@ -24,9 +19,4 @@ tests/cases/conformance/es6/for-ofStatements/for-of30.ts(16,15): error TS2322: T
     
     for (var v of new StringIterator) { }
                   ~~~~~~~~~~~~~~~~~~
-!!! error TS2322: Type 'StringIterator' is not assignable to type 'Iterable<string>'.
-!!! error TS2322:   Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2322:     Type '() => StringIterator' is not assignable to type '() => Iterator<string>'.
-!!! error TS2322:       Type 'StringIterator' is not assignable to type 'Iterator<string>'.
-!!! error TS2322:         Types of property 'return' are incompatible.
-!!! error TS2322:           Type 'number' is not assignable to type '(value?: any) => IteratorResult<string>'.
\ No newline at end of file
+!!! error TS2767: The 'return' property of an iterator must be a method.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of30.js b/tests/baselines/reference/for-of30.js
index 935944db640e3..49d3fa8f46c83 100644
--- a/tests/baselines/reference/for-of30.js
+++ b/tests/baselines/reference/for-of30.js
@@ -6,9 +6,9 @@ class StringIterator {
             value: ""
         }
     }
-    
+
     return = 0;
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/baselines/reference/for-of30.symbols b/tests/baselines/reference/for-of30.symbols
index 779d8aa2b210d..f6fd0224ad767 100644
--- a/tests/baselines/reference/for-of30.symbols
+++ b/tests/baselines/reference/for-of30.symbols
@@ -13,10 +13,10 @@ class StringIterator {
 >value : Symbol(value, Decl(for-of30.ts, 3, 24))
         }
     }
-    
+
     return = 0;
 >return : Symbol(StringIterator.return, Decl(for-of30.ts, 6, 5))
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of30.ts, 8, 15))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
diff --git a/tests/baselines/reference/for-of30.types b/tests/baselines/reference/for-of30.types
index bd369223d7f5f..d415360dc6fa6 100644
--- a/tests/baselines/reference/for-of30.types
+++ b/tests/baselines/reference/for-of30.types
@@ -17,11 +17,11 @@ class StringIterator {
 >"" : ""
         }
     }
-    
+
     return = 0;
 >return : number
 >0 : 0
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => this
 >Symbol.iterator : symbol
diff --git a/tests/baselines/reference/for-of31.errors.txt b/tests/baselines/reference/for-of31.errors.txt
deleted file mode 100644
index 2b1a70529183b..0000000000000
--- a/tests/baselines/reference/for-of31.errors.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-tests/cases/conformance/es6/for-ofStatements/for-of31.ts(14,15): error TS2322: Type 'StringIterator' is not assignable to type 'Iterable<string>'.
-  Types of property '[Symbol.iterator]' are incompatible.
-    Type '() => StringIterator' is not assignable to type '() => Iterator<string>'.
-      Type 'StringIterator' is not assignable to type 'Iterator<string>'.
-        Types of property 'next' are incompatible.
-          Type '() => { value: string; }' is not assignable to type '(value?: any) => IteratorResult<string>'.
-            Property 'done' is missing in type '{ value: string; }' but required in type 'IteratorResult<string>'.
-
-
-==== tests/cases/conformance/es6/for-ofStatements/for-of31.ts (1 errors) ====
-    class StringIterator {
-        next() {
-            return {
-                // no done property
-                value: ""
-            }
-        }
-        
-        [Symbol.iterator]() {
-            return this;
-        }
-    }
-    
-    for (var v of new StringIterator) { }
-                  ~~~~~~~~~~~~~~~~~~
-!!! error TS2322: Type 'StringIterator' is not assignable to type 'Iterable<string>'.
-!!! error TS2322:   Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2322:     Type '() => StringIterator' is not assignable to type '() => Iterator<string>'.
-!!! error TS2322:       Type 'StringIterator' is not assignable to type 'Iterator<string>'.
-!!! error TS2322:         Types of property 'next' are incompatible.
-!!! error TS2322:           Type '() => { value: string; }' is not assignable to type '(value?: any) => IteratorResult<string>'.
-!!! error TS2322:             Property 'done' is missing in type '{ value: string; }' but required in type 'IteratorResult<string>'.
-!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:32:5: 'done' is declared here.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of31.js b/tests/baselines/reference/for-of31.js
index 84e24bed5a959..10bc33416c9d0 100644
--- a/tests/baselines/reference/for-of31.js
+++ b/tests/baselines/reference/for-of31.js
@@ -6,7 +6,7 @@ class StringIterator {
             value: ""
         }
     }
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/baselines/reference/for-of31.symbols b/tests/baselines/reference/for-of31.symbols
index 41b7d0a85d624..37b4f27aaa8cf 100644
--- a/tests/baselines/reference/for-of31.symbols
+++ b/tests/baselines/reference/for-of31.symbols
@@ -11,7 +11,7 @@ class StringIterator {
 >value : Symbol(value, Decl(for-of31.ts, 2, 16))
         }
     }
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of31.ts, 6, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
diff --git a/tests/baselines/reference/for-of31.types b/tests/baselines/reference/for-of31.types
index 843ce928c44e1..330c39578f391 100644
--- a/tests/baselines/reference/for-of31.types
+++ b/tests/baselines/reference/for-of31.types
@@ -14,7 +14,7 @@ class StringIterator {
 >"" : ""
         }
     }
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => this
 >Symbol.iterator : symbol
diff --git a/tests/baselines/reference/for-of34.errors.txt b/tests/baselines/reference/for-of34.errors.txt
index 2d53ecb0a208a..ecab8c91e1f1b 100644
--- a/tests/baselines/reference/for-of34.errors.txt
+++ b/tests/baselines/reference/for-of34.errors.txt
@@ -9,7 +9,7 @@ tests/cases/conformance/es6/for-ofStatements/for-of34.ts(11,10): error TS7022: '
 !!! error TS7023: 'next' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions.
             return v;
         }
-        
+    
         [Symbol.iterator]() {
             return this;
         }
diff --git a/tests/baselines/reference/for-of34.js b/tests/baselines/reference/for-of34.js
index 2d9af61d1a389..3cfb390890dda 100644
--- a/tests/baselines/reference/for-of34.js
+++ b/tests/baselines/reference/for-of34.js
@@ -3,7 +3,7 @@ class StringIterator {
     next() {
         return v;
     }
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/baselines/reference/for-of34.symbols b/tests/baselines/reference/for-of34.symbols
index 0b1e125275340..3ebe5624f9e5c 100644
--- a/tests/baselines/reference/for-of34.symbols
+++ b/tests/baselines/reference/for-of34.symbols
@@ -8,7 +8,7 @@ class StringIterator {
         return v;
 >v : Symbol(v, Decl(for-of34.ts, 10, 8))
     }
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of34.ts, 3, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
diff --git a/tests/baselines/reference/for-of34.types b/tests/baselines/reference/for-of34.types
index 5a4287e7843dd..3cb11706a1366 100644
--- a/tests/baselines/reference/for-of34.types
+++ b/tests/baselines/reference/for-of34.types
@@ -8,7 +8,7 @@ class StringIterator {
         return v;
 >v : any
     }
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => this
 >Symbol.iterator : symbol
diff --git a/tests/baselines/reference/for-of35.errors.txt b/tests/baselines/reference/for-of35.errors.txt
index 6f14a24fb96b6..fe4cc69cdaf5c 100644
--- a/tests/baselines/reference/for-of35.errors.txt
+++ b/tests/baselines/reference/for-of35.errors.txt
@@ -12,7 +12,7 @@ tests/cases/conformance/es6/for-ofStatements/for-of35.ts(14,10): error TS7022: '
                 value: v
             }
         }
-        
+    
         [Symbol.iterator]() {
             return this;
         }
diff --git a/tests/baselines/reference/for-of35.js b/tests/baselines/reference/for-of35.js
index a73f873d7ce38..769138664daf5 100644
--- a/tests/baselines/reference/for-of35.js
+++ b/tests/baselines/reference/for-of35.js
@@ -6,7 +6,7 @@ class StringIterator {
             value: v
         }
     }
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/baselines/reference/for-of35.symbols b/tests/baselines/reference/for-of35.symbols
index 4f21e538cad28..d2c9de2bd17b6 100644
--- a/tests/baselines/reference/for-of35.symbols
+++ b/tests/baselines/reference/for-of35.symbols
@@ -14,7 +14,7 @@ class StringIterator {
 >v : Symbol(v, Decl(for-of35.ts, 13, 8))
         }
     }
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of35.ts, 6, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
diff --git a/tests/baselines/reference/for-of35.types b/tests/baselines/reference/for-of35.types
index 0c80a6633b28a..66d1106073e73 100644
--- a/tests/baselines/reference/for-of35.types
+++ b/tests/baselines/reference/for-of35.types
@@ -17,7 +17,7 @@ class StringIterator {
 >v : any
         }
     }
-    
+
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => this
 >Symbol.iterator : symbol
diff --git a/tests/baselines/reference/generatorAssignability.errors.txt b/tests/baselines/reference/generatorAssignability.errors.txt
new file mode 100644
index 0000000000000..83e53f4a3fbc2
--- /dev/null
+++ b/tests/baselines/reference/generatorAssignability.errors.txt
@@ -0,0 +1,106 @@
+tests/cases/conformance/generators/generatorAssignability.ts(10,5): error TS2764: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array spread will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(14,5): error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(18,5): error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(22,1): error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(26,1): error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(30,11): error TS2763: Cannot iterate value because the 'next' method of its iterator expects type 'string', but for-of will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(35,21): error TS2763: Cannot iterate value because the 'next' method of its iterator expects type 'string', but for-of will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(39,21): error TS2763: Cannot iterate value because the 'next' method of its iterator expects type 'string', but for-of will always send 'undefined'.
+tests/cases/conformance/generators/generatorAssignability.ts(45,12): error TS2766: Cannot delegate iteration to value because the 'next' method of its iterator expects type 'string', but the containing generator will always send 'boolean'.
+tests/cases/conformance/generators/generatorAssignability.ts(51,12): error TS2766: Cannot delegate iteration to value because the 'next' method of its iterator expects type 'string', but the containing generator will always send 'boolean'.
+tests/cases/conformance/generators/generatorAssignability.ts(55,12): error TS2766: Cannot delegate iteration to value because the 'next' method of its iterator expects type 'string', but the containing generator will always send 'boolean'.
+
+
+==== tests/cases/conformance/generators/generatorAssignability.ts (11 errors) ====
+    declare let _: any;
+    declare const g1: Generator<number, void, string>;
+    declare const g2: Generator<number, void, undefined>;
+    declare const g3: Generator<number, void, boolean>;
+    declare const g4: AsyncGenerator<number, void, string>;
+    declare const g5: AsyncGenerator<number, void, undefined>;
+    declare const g6: AsyncGenerator<number, void, boolean>;
+    
+    // spread iterable
+    [...g1]; // error
+        ~~
+!!! error TS2764: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array spread will always send 'undefined'.
+    [...g2]; // ok
+    
+    // binding pattern over iterable
+    let [x1] = g1; // error
+        ~~~~
+!!! error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+    let [x2] = g2; // ok
+    
+    // binding rest pattern over iterable
+    let [...y1] = g1; // error
+        ~~~~~~~
+!!! error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+    let [...y2] = g2; // ok
+    
+    // assignment pattern over iterable
+    [_] = g1; // error
+    ~~~
+!!! error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+    [_] = g2; // ok
+    
+    // assignment rest pattern over iterable
+    [..._] = g1; // error
+    ~~~~~~
+!!! error TS2765: Cannot iterate value because the 'next' method of its iterator expects type 'string', but array destructuring will always send 'undefined'.
+    [..._] = g2; // ok
+    
+    // for-of over iterable
+    for (_ of g1); // error
+              ~~
+!!! error TS2763: Cannot iterate value because the 'next' method of its iterator expects type 'string', but for-of will always send 'undefined'.
+    for (_ of g2); // ok
+    
+    async function asyncfn() {
+        // for-await-of over iterable
+        for await (_ of g1); // error
+                        ~~
+!!! error TS2763: Cannot iterate value because the 'next' method of its iterator expects type 'string', but for-of will always send 'undefined'.
+        for await (_ of g2); // ok
+    
+        // for-await-of over asynciterable
+        for await (_ of g4); // error
+                        ~~
+!!! error TS2763: Cannot iterate value because the 'next' method of its iterator expects type 'string', but for-of will always send 'undefined'.
+        for await (_ of g5); // ok
+    }
+    
+    function* f1(): Generator<number, void, boolean> {
+        // yield* over iterable
+        yield* g1; // error
+               ~~
+!!! error TS2766: Cannot delegate iteration to value because the 'next' method of its iterator expects type 'string', but the containing generator will always send 'boolean'.
+        yield* g3; // ok
+    }
+    
+    async function* f2(): AsyncGenerator<number, void, boolean> {
+        // yield* over iterable
+        yield* g1; // error
+               ~~
+!!! error TS2766: Cannot delegate iteration to value because the 'next' method of its iterator expects type 'string', but the containing generator will always send 'boolean'.
+        yield* g3; // ok
+    
+        // yield* over asynciterable
+        yield* g4; // error
+               ~~
+!!! error TS2766: Cannot delegate iteration to value because the 'next' method of its iterator expects type 'string', but the containing generator will always send 'boolean'.
+        yield* g6; // ok
+    }
+    
+    async function f3() {
+        const syncGenerator = function*() {
+            yield 1;
+            yield 2;
+        };
+    
+        const o = {[Symbol.asyncIterator]: syncGenerator};
+    
+        for await (const x of o) {
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorAssignability.symbols b/tests/baselines/reference/generatorAssignability.symbols
new file mode 100644
index 0000000000000..8773011c67787
--- /dev/null
+++ b/tests/baselines/reference/generatorAssignability.symbols
@@ -0,0 +1,157 @@
+=== tests/cases/conformance/generators/generatorAssignability.ts ===
+declare let _: any;
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+
+declare const g1: Generator<number, void, string>;
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+declare const g2: Generator<number, void, undefined>;
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+declare const g3: Generator<number, void, boolean>;
+>g3 : Symbol(g3, Decl(generatorAssignability.ts, 3, 13))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+declare const g4: AsyncGenerator<number, void, string>;
+>g4 : Symbol(g4, Decl(generatorAssignability.ts, 4, 13))
+>AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --))
+
+declare const g5: AsyncGenerator<number, void, undefined>;
+>g5 : Symbol(g5, Decl(generatorAssignability.ts, 5, 13))
+>AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --))
+
+declare const g6: AsyncGenerator<number, void, boolean>;
+>g6 : Symbol(g6, Decl(generatorAssignability.ts, 6, 13))
+>AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --))
+
+// spread iterable
+[...g1]; // error
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+[...g2]; // ok
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+// binding pattern over iterable
+let [x1] = g1; // error
+>x1 : Symbol(x1, Decl(generatorAssignability.ts, 13, 5))
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+let [x2] = g2; // ok
+>x2 : Symbol(x2, Decl(generatorAssignability.ts, 14, 5))
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+// binding rest pattern over iterable
+let [...y1] = g1; // error
+>y1 : Symbol(y1, Decl(generatorAssignability.ts, 17, 5))
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+let [...y2] = g2; // ok
+>y2 : Symbol(y2, Decl(generatorAssignability.ts, 18, 5))
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+// assignment pattern over iterable
+[_] = g1; // error
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+[_] = g2; // ok
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+// assignment rest pattern over iterable
+[..._] = g1; // error
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+[..._] = g2; // ok
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+// for-of over iterable
+for (_ of g1); // error
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+for (_ of g2); // ok
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+async function asyncfn() {
+>asyncfn : Symbol(asyncfn, Decl(generatorAssignability.ts, 30, 14))
+
+    // for-await-of over iterable
+    for await (_ of g1); // error
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+    for await (_ of g2); // ok
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g2 : Symbol(g2, Decl(generatorAssignability.ts, 2, 13))
+
+    // for-await-of over asynciterable
+    for await (_ of g4); // error
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g4 : Symbol(g4, Decl(generatorAssignability.ts, 4, 13))
+
+    for await (_ of g5); // ok
+>_ : Symbol(_, Decl(generatorAssignability.ts, 0, 11))
+>g5 : Symbol(g5, Decl(generatorAssignability.ts, 5, 13))
+}
+
+function* f1(): Generator<number, void, boolean> {
+>f1 : Symbol(f1, Decl(generatorAssignability.ts, 40, 1))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+    // yield* over iterable
+    yield* g1; // error
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+    yield* g3; // ok
+>g3 : Symbol(g3, Decl(generatorAssignability.ts, 3, 13))
+}
+
+async function* f2(): AsyncGenerator<number, void, boolean> {
+>f2 : Symbol(f2, Decl(generatorAssignability.ts, 46, 1))
+>AsyncGenerator : Symbol(AsyncGenerator, Decl(lib.es2018.asyncgenerator.d.ts, --, --))
+
+    // yield* over iterable
+    yield* g1; // error
+>g1 : Symbol(g1, Decl(generatorAssignability.ts, 1, 13))
+
+    yield* g3; // ok
+>g3 : Symbol(g3, Decl(generatorAssignability.ts, 3, 13))
+
+    // yield* over asynciterable
+    yield* g4; // error
+>g4 : Symbol(g4, Decl(generatorAssignability.ts, 4, 13))
+
+    yield* g6; // ok
+>g6 : Symbol(g6, Decl(generatorAssignability.ts, 6, 13))
+}
+
+async function f3() {
+>f3 : Symbol(f3, Decl(generatorAssignability.ts, 56, 1))
+
+    const syncGenerator = function*() {
+>syncGenerator : Symbol(syncGenerator, Decl(generatorAssignability.ts, 59, 9))
+
+        yield 1;
+        yield 2;
+    };
+
+    const o = {[Symbol.asyncIterator]: syncGenerator};
+>o : Symbol(o, Decl(generatorAssignability.ts, 64, 9))
+>[Symbol.asyncIterator] : Symbol([Symbol.asyncIterator], Decl(generatorAssignability.ts, 64, 15))
+>Symbol.asyncIterator : Symbol(SymbolConstructor.asyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
+>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
+>asyncIterator : Symbol(SymbolConstructor.asyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
+>syncGenerator : Symbol(syncGenerator, Decl(generatorAssignability.ts, 59, 9))
+
+    for await (const x of o) {
+>x : Symbol(x, Decl(generatorAssignability.ts, 66, 20))
+>o : Symbol(o, Decl(generatorAssignability.ts, 64, 9))
+    }
+}
+
diff --git a/tests/baselines/reference/generatorAssignability.types b/tests/baselines/reference/generatorAssignability.types
new file mode 100644
index 0000000000000..c498104aeba7a
--- /dev/null
+++ b/tests/baselines/reference/generatorAssignability.types
@@ -0,0 +1,177 @@
+=== tests/cases/conformance/generators/generatorAssignability.ts ===
+declare let _: any;
+>_ : any
+
+declare const g1: Generator<number, void, string>;
+>g1 : Generator<number, void, string>
+
+declare const g2: Generator<number, void, undefined>;
+>g2 : Generator<number, void, undefined>
+
+declare const g3: Generator<number, void, boolean>;
+>g3 : Generator<number, void, boolean>
+
+declare const g4: AsyncGenerator<number, void, string>;
+>g4 : AsyncGenerator<number, void, string>
+
+declare const g5: AsyncGenerator<number, void, undefined>;
+>g5 : AsyncGenerator<number, void, undefined>
+
+declare const g6: AsyncGenerator<number, void, boolean>;
+>g6 : AsyncGenerator<number, void, boolean>
+
+// spread iterable
+[...g1]; // error
+>[...g1] : number[]
+>...g1 : number
+>g1 : Generator<number, void, string>
+
+[...g2]; // ok
+>[...g2] : number[]
+>...g2 : number
+>g2 : Generator<number, void, undefined>
+
+// binding pattern over iterable
+let [x1] = g1; // error
+>x1 : number
+>g1 : Generator<number, void, string>
+
+let [x2] = g2; // ok
+>x2 : number
+>g2 : Generator<number, void, undefined>
+
+// binding rest pattern over iterable
+let [...y1] = g1; // error
+>y1 : number[]
+>g1 : Generator<number, void, string>
+
+let [...y2] = g2; // ok
+>y2 : number[]
+>g2 : Generator<number, void, undefined>
+
+// assignment pattern over iterable
+[_] = g1; // error
+>[_] = g1 : Generator<number, void, string>
+>[_] : [any]
+>_ : any
+>g1 : Generator<number, void, string>
+
+[_] = g2; // ok
+>[_] = g2 : Generator<number, void, undefined>
+>[_] : [any]
+>_ : any
+>g2 : Generator<number, void, undefined>
+
+// assignment rest pattern over iterable
+[..._] = g1; // error
+>[..._] = g1 : Generator<number, void, string>
+>[..._] : any[]
+>..._ : any
+>_ : any
+>g1 : Generator<number, void, string>
+
+[..._] = g2; // ok
+>[..._] = g2 : Generator<number, void, undefined>
+>[..._] : any[]
+>..._ : any
+>_ : any
+>g2 : Generator<number, void, undefined>
+
+// for-of over iterable
+for (_ of g1); // error
+>_ : any
+>g1 : Generator<number, void, string>
+
+for (_ of g2); // ok
+>_ : any
+>g2 : Generator<number, void, undefined>
+
+async function asyncfn() {
+>asyncfn : () => Promise<void>
+
+    // for-await-of over iterable
+    for await (_ of g1); // error
+>_ : any
+>g1 : Generator<number, void, string>
+
+    for await (_ of g2); // ok
+>_ : any
+>g2 : Generator<number, void, undefined>
+
+    // for-await-of over asynciterable
+    for await (_ of g4); // error
+>_ : any
+>g4 : AsyncGenerator<number, void, string>
+
+    for await (_ of g5); // ok
+>_ : any
+>g5 : AsyncGenerator<number, void, undefined>
+}
+
+function* f1(): Generator<number, void, boolean> {
+>f1 : () => Generator<number, void, boolean>
+
+    // yield* over iterable
+    yield* g1; // error
+>yield* g1 : void
+>g1 : Generator<number, void, string>
+
+    yield* g3; // ok
+>yield* g3 : void
+>g3 : Generator<number, void, boolean>
+}
+
+async function* f2(): AsyncGenerator<number, void, boolean> {
+>f2 : () => AsyncGenerator<number, void, boolean>
+
+    // yield* over iterable
+    yield* g1; // error
+>yield* g1 : void
+>g1 : Generator<number, void, string>
+
+    yield* g3; // ok
+>yield* g3 : void
+>g3 : Generator<number, void, boolean>
+
+    // yield* over asynciterable
+    yield* g4; // error
+>yield* g4 : void
+>g4 : AsyncGenerator<number, void, string>
+
+    yield* g6; // ok
+>yield* g6 : void
+>g6 : AsyncGenerator<number, void, boolean>
+}
+
+async function f3() {
+>f3 : () => Promise<void>
+
+    const syncGenerator = function*() {
+>syncGenerator : () => Generator<1 | 2, void, unknown>
+>function*() {        yield 1;        yield 2;    } : () => Generator<1 | 2, void, unknown>
+
+        yield 1;
+>yield 1 : any
+>1 : 1
+
+        yield 2;
+>yield 2 : any
+>2 : 2
+
+    };
+
+    const o = {[Symbol.asyncIterator]: syncGenerator};
+>o : { [Symbol.asyncIterator]: () => Generator<1 | 2, void, unknown>; }
+>{[Symbol.asyncIterator]: syncGenerator} : { [Symbol.asyncIterator]: () => Generator<1 | 2, void, unknown>; }
+>[Symbol.asyncIterator] : () => Generator<1 | 2, void, unknown>
+>Symbol.asyncIterator : symbol
+>Symbol : SymbolConstructor
+>asyncIterator : symbol
+>syncGenerator : () => Generator<1 | 2, void, unknown>
+
+    for await (const x of o) {
+>x : 1 | 2
+>o : { [Symbol.asyncIterator]: () => Generator<1 | 2, void, unknown>; }
+    }
+}
+
diff --git a/tests/baselines/reference/generatorES6InAMDModule.types b/tests/baselines/reference/generatorES6InAMDModule.types
index 9a12a72f0055a..a1b06edc34625 100644
--- a/tests/baselines/reference/generatorES6InAMDModule.types
+++ b/tests/baselines/reference/generatorES6InAMDModule.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/generatorES6InAMDModule.ts ===
 export function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
     yield
 >yield : any
diff --git a/tests/baselines/reference/generatorES6_1.types b/tests/baselines/reference/generatorES6_1.types
index 13ac7c05844a6..e1046c8548e26 100644
--- a/tests/baselines/reference/generatorES6_1.types
+++ b/tests/baselines/reference/generatorES6_1.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/generatorES6_1.ts ===
 function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
     yield
 >yield : any
diff --git a/tests/baselines/reference/generatorES6_2.types b/tests/baselines/reference/generatorES6_2.types
index a95a0008d4fe4..61fc7db71a7f9 100644
--- a/tests/baselines/reference/generatorES6_2.types
+++ b/tests/baselines/reference/generatorES6_2.types
@@ -3,7 +3,7 @@ class C {
 >C : C
 
     public * foo() {
->foo : () => IterableIterator<number>
+>foo : () => Generator<number, void, unknown>
 
         yield 1
 >yield 1 : any
diff --git a/tests/baselines/reference/generatorES6_3.types b/tests/baselines/reference/generatorES6_3.types
index e237cbd3510a2..2b72e71132278 100644
--- a/tests/baselines/reference/generatorES6_3.types
+++ b/tests/baselines/reference/generatorES6_3.types
@@ -1,7 +1,7 @@
 === tests/cases/compiler/generatorES6_3.ts ===
 var v = function*() {
->v : () => IterableIterator<number>
->function*() {    yield 0} : () => IterableIterator<number>
+>v : () => Generator<number, void, unknown>
+>function*() {    yield 0} : () => Generator<number, void, unknown>
 
     yield 0
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorES6_4.types b/tests/baselines/reference/generatorES6_4.types
index fa19d8f3ae2d5..31945d0d3e6a5 100644
--- a/tests/baselines/reference/generatorES6_4.types
+++ b/tests/baselines/reference/generatorES6_4.types
@@ -1,10 +1,10 @@
 === tests/cases/compiler/generatorES6_4.ts ===
 var v = { 
->v : { foo(): IterableIterator<number>; }
->{    *foo() {       yield 0   }} : { foo(): IterableIterator<number>; }
+>v : { foo(): Generator<number, void, unknown>; }
+>{    *foo() {       yield 0   }} : { foo(): Generator<number, void, unknown>; }
 
    *foo() {
->foo : () => IterableIterator<number>
+>foo : () => Generator<number, void, unknown>
 
        yield 0
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorES6_5.types b/tests/baselines/reference/generatorES6_5.types
index 12396f69e242a..6ff6105b498ca 100644
--- a/tests/baselines/reference/generatorES6_5.types
+++ b/tests/baselines/reference/generatorES6_5.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/generatorES6_5.ts ===
 function* foo() {
->foo : () => IterableIterator<any>
+>foo : () => Generator<any, void, unknown>
 
     yield a ? b : c;
 >yield a ? b : c : any
diff --git a/tests/baselines/reference/generatorES6_6.types b/tests/baselines/reference/generatorES6_6.types
index 7306b6ed99ae4..05e0bcc7f88b2 100644
--- a/tests/baselines/reference/generatorES6_6.types
+++ b/tests/baselines/reference/generatorES6_6.types
@@ -3,7 +3,7 @@ class C {
 >C : C
 
   *[Symbol.iterator]() {
->[Symbol.iterator] : () => IterableIterator<number>
+>[Symbol.iterator] : () => Generator<number, void, unknown>
 >Symbol.iterator : symbol
 >Symbol : SymbolConstructor
 >iterator : symbol
diff --git a/tests/baselines/reference/generatorExplicitReturnType.errors.txt b/tests/baselines/reference/generatorExplicitReturnType.errors.txt
new file mode 100644
index 0000000000000..4841e62bba7df
--- /dev/null
+++ b/tests/baselines/reference/generatorExplicitReturnType.errors.txt
@@ -0,0 +1,41 @@
+tests/cases/conformance/generators/generatorExplicitReturnType.ts(2,5): error TS2322: Type 'undefined' is not assignable to type 'number'.
+tests/cases/conformance/generators/generatorExplicitReturnType.ts(3,11): error TS2322: Type '"a"' is not assignable to type 'number'.
+tests/cases/conformance/generators/generatorExplicitReturnType.ts(4,11): error TS2322: Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/generators/generatorExplicitReturnType.ts(5,5): error TS2322: Type '10' is not assignable to type 'boolean'.
+tests/cases/conformance/generators/generatorExplicitReturnType.ts(16,11): error TS2322: Type 'symbol' is not assignable to type 'number'.
+
+
+==== tests/cases/conformance/generators/generatorExplicitReturnType.ts (5 errors) ====
+    function* g1(): Generator<number, boolean, string> {
+        yield; // error
+        ~~~~~
+!!! error TS2322: Type 'undefined' is not assignable to type 'number'.
+        yield "a"; // error
+              ~~~
+!!! error TS2322: Type '"a"' is not assignable to type 'number'.
+        const x: number = yield 1; // error
+              ~
+!!! error TS2322: Type 'string' is not assignable to type 'number'.
+        return 10; // error
+        ~~~~~~~~~~
+!!! error TS2322: Type '10' is not assignable to type 'boolean'.
+    }
+    
+    function* g2(): Generator<number, boolean, string> {
+        const x = yield 1;
+        return true;
+    }
+    
+    declare const generator: Generator<number, symbol, string>;
+    
+    function* g3(): Generator<number, boolean, string> {
+        const x: number = yield* generator; // error
+              ~
+!!! error TS2322: Type 'symbol' is not assignable to type 'number'.
+        return true;
+    }
+    
+    function* g4(): Generator<number, boolean, string> {
+        const x = yield* generator;
+        return true;
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorExplicitReturnType.js b/tests/baselines/reference/generatorExplicitReturnType.js
new file mode 100644
index 0000000000000..1669a2905e5df
--- /dev/null
+++ b/tests/baselines/reference/generatorExplicitReturnType.js
@@ -0,0 +1,44 @@
+//// [generatorExplicitReturnType.ts]
+function* g1(): Generator<number, boolean, string> {
+    yield; // error
+    yield "a"; // error
+    const x: number = yield 1; // error
+    return 10; // error
+}
+
+function* g2(): Generator<number, boolean, string> {
+    const x = yield 1;
+    return true;
+}
+
+declare const generator: Generator<number, symbol, string>;
+
+function* g3(): Generator<number, boolean, string> {
+    const x: number = yield* generator; // error
+    return true;
+}
+
+function* g4(): Generator<number, boolean, string> {
+    const x = yield* generator;
+    return true;
+}
+
+//// [generatorExplicitReturnType.js]
+function* g1() {
+    yield; // error
+    yield "a"; // error
+    const x = yield 1; // error
+    return 10; // error
+}
+function* g2() {
+    const x = yield 1;
+    return true;
+}
+function* g3() {
+    const x = yield* generator; // error
+    return true;
+}
+function* g4() {
+    const x = yield* generator;
+    return true;
+}
diff --git a/tests/baselines/reference/generatorExplicitReturnType.symbols b/tests/baselines/reference/generatorExplicitReturnType.symbols
new file mode 100644
index 0000000000000..fb3676a8b78a6
--- /dev/null
+++ b/tests/baselines/reference/generatorExplicitReturnType.symbols
@@ -0,0 +1,48 @@
+=== tests/cases/conformance/generators/generatorExplicitReturnType.ts ===
+function* g1(): Generator<number, boolean, string> {
+>g1 : Symbol(g1, Decl(generatorExplicitReturnType.ts, 0, 0))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+    yield; // error
+    yield "a"; // error
+    const x: number = yield 1; // error
+>x : Symbol(x, Decl(generatorExplicitReturnType.ts, 3, 9))
+
+    return 10; // error
+}
+
+function* g2(): Generator<number, boolean, string> {
+>g2 : Symbol(g2, Decl(generatorExplicitReturnType.ts, 5, 1))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+    const x = yield 1;
+>x : Symbol(x, Decl(generatorExplicitReturnType.ts, 8, 9))
+
+    return true;
+}
+
+declare const generator: Generator<number, symbol, string>;
+>generator : Symbol(generator, Decl(generatorExplicitReturnType.ts, 12, 13))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+function* g3(): Generator<number, boolean, string> {
+>g3 : Symbol(g3, Decl(generatorExplicitReturnType.ts, 12, 59))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+    const x: number = yield* generator; // error
+>x : Symbol(x, Decl(generatorExplicitReturnType.ts, 15, 9))
+>generator : Symbol(generator, Decl(generatorExplicitReturnType.ts, 12, 13))
+
+    return true;
+}
+
+function* g4(): Generator<number, boolean, string> {
+>g4 : Symbol(g4, Decl(generatorExplicitReturnType.ts, 17, 1))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+    const x = yield* generator;
+>x : Symbol(x, Decl(generatorExplicitReturnType.ts, 20, 9))
+>generator : Symbol(generator, Decl(generatorExplicitReturnType.ts, 12, 13))
+
+    return true;
+}
diff --git a/tests/baselines/reference/generatorExplicitReturnType.types b/tests/baselines/reference/generatorExplicitReturnType.types
new file mode 100644
index 0000000000000..6e05722d049db
--- /dev/null
+++ b/tests/baselines/reference/generatorExplicitReturnType.types
@@ -0,0 +1,58 @@
+=== tests/cases/conformance/generators/generatorExplicitReturnType.ts ===
+function* g1(): Generator<number, boolean, string> {
+>g1 : () => Generator<number, boolean, string>
+
+    yield; // error
+>yield : string
+
+    yield "a"; // error
+>yield "a" : string
+>"a" : "a"
+
+    const x: number = yield 1; // error
+>x : number
+>yield 1 : string
+>1 : 1
+
+    return 10; // error
+>10 : 10
+}
+
+function* g2(): Generator<number, boolean, string> {
+>g2 : () => Generator<number, boolean, string>
+
+    const x = yield 1;
+>x : string
+>yield 1 : string
+>1 : 1
+
+    return true;
+>true : true
+}
+
+declare const generator: Generator<number, symbol, string>;
+>generator : Generator<number, symbol, string>
+
+function* g3(): Generator<number, boolean, string> {
+>g3 : () => Generator<number, boolean, string>
+
+    const x: number = yield* generator; // error
+>x : number
+>yield* generator : symbol
+>generator : Generator<number, symbol, string>
+
+    return true;
+>true : true
+}
+
+function* g4(): Generator<number, boolean, string> {
+>g4 : () => Generator<number, boolean, string>
+
+    const x = yield* generator;
+>x : symbol
+>yield* generator : symbol
+>generator : Generator<number, symbol, string>
+
+    return true;
+>true : true
+}
diff --git a/tests/baselines/reference/generatorImplicitAny.js b/tests/baselines/reference/generatorImplicitAny.js
new file mode 100644
index 0000000000000..ee12d8052b831
--- /dev/null
+++ b/tests/baselines/reference/generatorImplicitAny.js
@@ -0,0 +1,5 @@
+//// [generatorImplicitAny.ts]
+function* g() {}
+
+//// [generatorImplicitAny.js]
+function* g() { }
diff --git a/tests/baselines/reference/generatorImplicitAny.symbols b/tests/baselines/reference/generatorImplicitAny.symbols
new file mode 100644
index 0000000000000..3c3929e9ab37c
--- /dev/null
+++ b/tests/baselines/reference/generatorImplicitAny.symbols
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/generators/generatorImplicitAny.ts ===
+function* g() {}
+>g : Symbol(g, Decl(generatorImplicitAny.ts, 0, 0))
+
diff --git a/tests/baselines/reference/generatorImplicitAny.types b/tests/baselines/reference/generatorImplicitAny.types
new file mode 100644
index 0000000000000..a63d19b7fbe06
--- /dev/null
+++ b/tests/baselines/reference/generatorImplicitAny.types
@@ -0,0 +1,4 @@
+=== tests/cases/conformance/generators/generatorImplicitAny.ts ===
+function* g() {}
+>g : () => Generator<never, void, unknown>
+
diff --git a/tests/baselines/reference/generatorNoImplicitReturns.types b/tests/baselines/reference/generatorNoImplicitReturns.types
index 666ce4db474c0..f8a2a073487ae 100644
--- a/tests/baselines/reference/generatorNoImplicitReturns.types
+++ b/tests/baselines/reference/generatorNoImplicitReturns.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorNoImplicitReturns.ts ===
  
 function* testGenerator () { 
->testGenerator : () => IterableIterator<string>
+>testGenerator : () => Generator<string, void, unknown>
 
   if (Math.random() > 0.5) { 
 >Math.random() > 0.5 : boolean
diff --git a/tests/baselines/reference/generatorReturnExpressionIsChecked.types b/tests/baselines/reference/generatorReturnExpressionIsChecked.types
index f77ec0b37290f..4abe3721a8ec5 100644
--- a/tests/baselines/reference/generatorReturnExpressionIsChecked.types
+++ b/tests/baselines/reference/generatorReturnExpressionIsChecked.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/generatorReturnExpressionIsChecked.ts ===
 function* f(): Iterator<number> {
->f : () => Iterator<number>
+>f : () => Iterator<number, any, undefined>
 
     return invalid;
 >invalid : any
diff --git a/tests/baselines/reference/generatorReturnTypeInference.js b/tests/baselines/reference/generatorReturnTypeInference.js
new file mode 100644
index 0000000000000..d3350d5248694
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInference.js
@@ -0,0 +1,236 @@
+//// [generatorReturnTypeInference.ts]
+declare const iterableIterator: IterableIterator<number>;
+declare const generator: Generator<number, string, boolean>;
+declare const never: never;
+
+function* g000() { // Generator<never, void, unknown>
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<undefined, void, unknown>
+    yield;
+}
+
+function* g002() { // Generator<number, void, unknown>
+    yield 1;
+}
+
+function* g003() { // Generator<never, void, undefined>
+    yield* [];
+}
+
+function* g004() { // Generator<number, void, undefined>
+    yield* iterableIterator;
+}
+
+function* g005() { // Generator<number, void, boolean>
+    const x = yield* generator;
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+    yield 1;
+    yield 2;
+}
+
+function* g007() { // Generator<never, void, unknown>
+    yield never;
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+    return 1;
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+    if (Math.random()) return 1;
+    return 2;
+}
+
+function* g104() { // Generator<never, never, unknown>
+    return never;
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+    let a: string = yield 1;
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+    let a: string = yield 1;
+    let b: number = yield 2;
+}
+
+declare function f1(x: string): void;
+declare function f1(x: number): void;
+
+function* g203() { // Generator<number, void, string>
+	const x = f1(yield 1);
+}
+
+declare function f2<T>(x: T): T;
+
+function* g204() { // Generator<number, void, any>
+	const x = f2(yield 1);
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<undefined, void, unknown>
+    yield;
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+    yield 1;
+    return;
+}
+
+function* g303() { // Generator<undefined, string, unknown>
+    yield;
+    return "a";
+}
+
+function* g304() { // Generator<number, string, unknown>
+    yield 1;
+    return "a";
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+    if (Math.random()) yield 1;
+    yield 2;
+    if (Math.random()) return "a";
+    return "b";
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+    const a: "hi" = yield 1;
+    return true;
+}
+
+function* g307<T>() { // Generator<number, T, T>
+    const a: T = yield 0;
+    return a;
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+    const a: T = yield x;
+    return a;
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+    const a: V = yield x;
+    return y;
+}
+
+function* g310() { // Generator<undefined, void, [(1 | undefined)?, (2 | undefined)?]>
+	const [a = 1, b = 2] = yield;
+}
+
+function* g311() { // Generator<undefined, void, string>
+	yield* (function*() {
+		const y: string = yield;
+	})();
+}
+
+
+//// [generatorReturnTypeInference.js]
+function* g000() {
+}
+// 'yield' iteration type inference
+function* g001() {
+    yield;
+}
+function* g002() {
+    yield 1;
+}
+function* g003() {
+    yield* [];
+}
+function* g004() {
+    yield* iterableIterator;
+}
+function* g005() {
+    const x = yield* generator;
+}
+function* g006() {
+    yield 1;
+    yield 2;
+}
+function* g007() {
+    yield never;
+}
+// 'return' iteration type inference
+function* g102() {
+    return 1;
+}
+function* g103() {
+    if (Math.random())
+        return 1;
+    return 2;
+}
+function* g104() {
+    return never;
+}
+// 'next' iteration type inference
+function* g201() {
+    let a = yield 1;
+}
+function* g202() {
+    let a = yield 1;
+    let b = yield 2;
+}
+function* g203() {
+    const x = f1(yield 1);
+}
+function* g204() {
+    const x = f2(yield 1);
+}
+// mixed iteration types inference
+function* g301() {
+    yield;
+    return;
+}
+function* g302() {
+    yield 1;
+    return;
+}
+function* g303() {
+    yield;
+    return "a";
+}
+function* g304() {
+    yield 1;
+    return "a";
+}
+function* g305() {
+    if (Math.random())
+        yield 1;
+    yield 2;
+    if (Math.random())
+        return "a";
+    return "b";
+}
+function* g306() {
+    const a = yield 1;
+    return true;
+}
+function* g307() {
+    const a = yield 0;
+    return a;
+}
+function* g308(x) {
+    const a = yield x;
+    return a;
+}
+function* g309(x, y) {
+    const a = yield x;
+    return y;
+}
+function* g310() {
+    const [a = 1, b = 2] = yield;
+}
+function* g311() {
+    yield* (function* () {
+        const y = yield;
+    })();
+}
diff --git a/tests/baselines/reference/generatorReturnTypeInference.symbols b/tests/baselines/reference/generatorReturnTypeInference.symbols
new file mode 100644
index 0000000000000..9af5773a118c1
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInference.symbols
@@ -0,0 +1,258 @@
+=== tests/cases/conformance/generators/generatorReturnTypeInference.ts ===
+declare const iterableIterator: IterableIterator<number>;
+>iterableIterator : Symbol(iterableIterator, Decl(generatorReturnTypeInference.ts, 0, 13))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+
+declare const generator: Generator<number, string, boolean>;
+>generator : Symbol(generator, Decl(generatorReturnTypeInference.ts, 1, 13))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+declare const never: never;
+>never : Symbol(never, Decl(generatorReturnTypeInference.ts, 2, 13))
+
+function* g000() { // Generator<never, void, unknown>
+>g000 : Symbol(g000, Decl(generatorReturnTypeInference.ts, 2, 27))
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<undefined, void, unknown>
+>g001 : Symbol(g001, Decl(generatorReturnTypeInference.ts, 5, 1))
+
+    yield;
+}
+
+function* g002() { // Generator<number, void, unknown>
+>g002 : Symbol(g002, Decl(generatorReturnTypeInference.ts, 10, 1))
+
+    yield 1;
+}
+
+function* g003() { // Generator<never, void, undefined>
+>g003 : Symbol(g003, Decl(generatorReturnTypeInference.ts, 14, 1))
+
+    yield* [];
+}
+
+function* g004() { // Generator<number, void, undefined>
+>g004 : Symbol(g004, Decl(generatorReturnTypeInference.ts, 18, 1))
+
+    yield* iterableIterator;
+>iterableIterator : Symbol(iterableIterator, Decl(generatorReturnTypeInference.ts, 0, 13))
+}
+
+function* g005() { // Generator<number, void, boolean>
+>g005 : Symbol(g005, Decl(generatorReturnTypeInference.ts, 22, 1))
+
+    const x = yield* generator;
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 25, 9))
+>generator : Symbol(generator, Decl(generatorReturnTypeInference.ts, 1, 13))
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+>g006 : Symbol(g006, Decl(generatorReturnTypeInference.ts, 26, 1))
+
+    yield 1;
+    yield 2;
+}
+
+function* g007() { // Generator<never, void, unknown>
+>g007 : Symbol(g007, Decl(generatorReturnTypeInference.ts, 31, 1))
+
+    yield never;
+>never : Symbol(never, Decl(generatorReturnTypeInference.ts, 2, 13))
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+>g102 : Symbol(g102, Decl(generatorReturnTypeInference.ts, 35, 1))
+
+    return 1;
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+>g103 : Symbol(g103, Decl(generatorReturnTypeInference.ts, 40, 1))
+
+    if (Math.random()) return 1;
+>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+
+    return 2;
+}
+
+function* g104() { // Generator<never, never, unknown>
+>g104 : Symbol(g104, Decl(generatorReturnTypeInference.ts, 45, 1))
+
+    return never;
+>never : Symbol(never, Decl(generatorReturnTypeInference.ts, 2, 13))
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+>g201 : Symbol(g201, Decl(generatorReturnTypeInference.ts, 49, 1))
+
+    let a: string = yield 1;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 53, 7))
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+>g202 : Symbol(g202, Decl(generatorReturnTypeInference.ts, 54, 1))
+
+    let a: string = yield 1;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 57, 7))
+
+    let b: number = yield 2;
+>b : Symbol(b, Decl(generatorReturnTypeInference.ts, 58, 7))
+}
+
+declare function f1(x: string): void;
+>f1 : Symbol(f1, Decl(generatorReturnTypeInference.ts, 59, 1), Decl(generatorReturnTypeInference.ts, 61, 37))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 61, 20))
+
+declare function f1(x: number): void;
+>f1 : Symbol(f1, Decl(generatorReturnTypeInference.ts, 59, 1), Decl(generatorReturnTypeInference.ts, 61, 37))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 62, 20))
+
+function* g203() { // Generator<number, void, string>
+>g203 : Symbol(g203, Decl(generatorReturnTypeInference.ts, 62, 37))
+
+	const x = f1(yield 1);
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 65, 6))
+>f1 : Symbol(f1, Decl(generatorReturnTypeInference.ts, 59, 1), Decl(generatorReturnTypeInference.ts, 61, 37))
+}
+
+declare function f2<T>(x: T): T;
+>f2 : Symbol(f2, Decl(generatorReturnTypeInference.ts, 66, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 68, 20))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 68, 23))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 68, 20))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 68, 20))
+
+function* g204() { // Generator<number, void, any>
+>g204 : Symbol(g204, Decl(generatorReturnTypeInference.ts, 68, 32))
+
+	const x = f2(yield 1);
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 71, 6))
+>f2 : Symbol(f2, Decl(generatorReturnTypeInference.ts, 66, 1))
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<undefined, void, unknown>
+>g301 : Symbol(g301, Decl(generatorReturnTypeInference.ts, 72, 1))
+
+    yield;
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+>g302 : Symbol(g302, Decl(generatorReturnTypeInference.ts, 79, 1))
+
+    yield 1;
+    return;
+}
+
+function* g303() { // Generator<undefined, string, unknown>
+>g303 : Symbol(g303, Decl(generatorReturnTypeInference.ts, 84, 1))
+
+    yield;
+    return "a";
+}
+
+function* g304() { // Generator<number, string, unknown>
+>g304 : Symbol(g304, Decl(generatorReturnTypeInference.ts, 89, 1))
+
+    yield 1;
+    return "a";
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+>g305 : Symbol(g305, Decl(generatorReturnTypeInference.ts, 94, 1))
+
+    if (Math.random()) yield 1;
+>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+
+    yield 2;
+    if (Math.random()) return "a";
+>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+
+    return "b";
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+>g306 : Symbol(g306, Decl(generatorReturnTypeInference.ts, 101, 1))
+
+    const a: "hi" = yield 1;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 104, 9))
+
+    return true;
+}
+
+function* g307<T>() { // Generator<number, T, T>
+>g307 : Symbol(g307, Decl(generatorReturnTypeInference.ts, 106, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 108, 15))
+
+    const a: T = yield 0;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 109, 9))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 108, 15))
+
+    return a;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 109, 9))
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+>g308 : Symbol(g308, Decl(generatorReturnTypeInference.ts, 111, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 113, 15))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 113, 18))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 113, 15))
+
+    const a: T = yield x;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 114, 9))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 113, 15))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 113, 18))
+
+    return a;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 114, 9))
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+>g309 : Symbol(g309, Decl(generatorReturnTypeInference.ts, 116, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 118, 15))
+>U : Symbol(U, Decl(generatorReturnTypeInference.ts, 118, 17))
+>V : Symbol(V, Decl(generatorReturnTypeInference.ts, 118, 20))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 118, 24))
+>T : Symbol(T, Decl(generatorReturnTypeInference.ts, 118, 15))
+>y : Symbol(y, Decl(generatorReturnTypeInference.ts, 118, 29))
+>U : Symbol(U, Decl(generatorReturnTypeInference.ts, 118, 17))
+
+    const a: V = yield x;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 119, 9))
+>V : Symbol(V, Decl(generatorReturnTypeInference.ts, 118, 20))
+>x : Symbol(x, Decl(generatorReturnTypeInference.ts, 118, 24))
+
+    return y;
+>y : Symbol(y, Decl(generatorReturnTypeInference.ts, 118, 29))
+}
+
+function* g310() { // Generator<undefined, void, [(1 | undefined)?, (2 | undefined)?]>
+>g310 : Symbol(g310, Decl(generatorReturnTypeInference.ts, 121, 1))
+
+	const [a = 1, b = 2] = yield;
+>a : Symbol(a, Decl(generatorReturnTypeInference.ts, 124, 8))
+>b : Symbol(b, Decl(generatorReturnTypeInference.ts, 124, 14))
+}
+
+function* g311() { // Generator<undefined, void, string>
+>g311 : Symbol(g311, Decl(generatorReturnTypeInference.ts, 125, 1))
+
+	yield* (function*() {
+		const y: string = yield;
+>y : Symbol(y, Decl(generatorReturnTypeInference.ts, 129, 7))
+
+	})();
+}
+
diff --git a/tests/baselines/reference/generatorReturnTypeInference.types b/tests/baselines/reference/generatorReturnTypeInference.types
new file mode 100644
index 0000000000000..a0942c9b70003
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInference.types
@@ -0,0 +1,308 @@
+=== tests/cases/conformance/generators/generatorReturnTypeInference.ts ===
+declare const iterableIterator: IterableIterator<number>;
+>iterableIterator : IterableIterator<number>
+
+declare const generator: Generator<number, string, boolean>;
+>generator : Generator<number, string, boolean>
+
+declare const never: never;
+>never : never
+
+function* g000() { // Generator<never, void, unknown>
+>g000 : () => Generator<never, void, unknown>
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<undefined, void, unknown>
+>g001 : () => Generator<undefined, void, unknown>
+
+    yield;
+>yield : any
+}
+
+function* g002() { // Generator<number, void, unknown>
+>g002 : () => Generator<number, void, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+}
+
+function* g003() { // Generator<never, void, undefined>
+>g003 : () => Generator<never, void, undefined>
+
+    yield* [];
+>yield* [] : any
+>[] : never[]
+}
+
+function* g004() { // Generator<number, void, undefined>
+>g004 : () => Generator<number, void, undefined>
+
+    yield* iterableIterator;
+>yield* iterableIterator : any
+>iterableIterator : IterableIterator<number>
+}
+
+function* g005() { // Generator<number, void, boolean>
+>g005 : () => Generator<number, void, boolean>
+
+    const x = yield* generator;
+>x : string
+>yield* generator : string
+>generator : Generator<number, string, boolean>
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+>g006 : () => Generator<1 | 2, void, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+
+    yield 2;
+>yield 2 : any
+>2 : 2
+}
+
+function* g007() { // Generator<never, void, unknown>
+>g007 : () => Generator<never, void, unknown>
+
+    yield never;
+>yield never : any
+>never : never
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+>g102 : () => Generator<never, number, unknown>
+
+    return 1;
+>1 : 1
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+>g103 : () => Generator<never, 1 | 2, unknown>
+
+    if (Math.random()) return 1;
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>1 : 1
+
+    return 2;
+>2 : 2
+}
+
+function* g104() { // Generator<never, never, unknown>
+>g104 : () => Generator<never, never, unknown>
+
+    return never;
+>never : never
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+>g201 : () => Generator<number, void, string>
+
+    let a: string = yield 1;
+>a : string
+>yield 1 : any
+>1 : 1
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+>g202 : () => Generator<1 | 2, void, never>
+
+    let a: string = yield 1;
+>a : string
+>yield 1 : any
+>1 : 1
+
+    let b: number = yield 2;
+>b : number
+>yield 2 : any
+>2 : 2
+}
+
+declare function f1(x: string): void;
+>f1 : { (x: string): void; (x: number): void; }
+>x : string
+
+declare function f1(x: number): void;
+>f1 : { (x: string): void; (x: number): void; }
+>x : number
+
+function* g203() { // Generator<number, void, string>
+>g203 : () => Generator<number, void, string>
+
+	const x = f1(yield 1);
+>x : void
+>f1(yield 1) : void
+>f1 : { (x: string): void; (x: number): void; }
+>yield 1 : any
+>1 : 1
+}
+
+declare function f2<T>(x: T): T;
+>f2 : <T>(x: T) => T
+>x : T
+
+function* g204() { // Generator<number, void, any>
+>g204 : () => Generator<number, void, any>
+
+	const x = f2(yield 1);
+>x : any
+>f2(yield 1) : any
+>f2 : <T>(x: T) => T
+>yield 1 : any
+>1 : 1
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<undefined, void, unknown>
+>g301 : () => Generator<undefined, void, unknown>
+
+    yield;
+>yield : any
+
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+>g302 : () => Generator<number, void, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+
+    return;
+}
+
+function* g303() { // Generator<undefined, string, unknown>
+>g303 : () => Generator<undefined, string, unknown>
+
+    yield;
+>yield : any
+
+    return "a";
+>"a" : "a"
+}
+
+function* g304() { // Generator<number, string, unknown>
+>g304 : () => Generator<number, string, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+
+    return "a";
+>"a" : "a"
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+>g305 : () => Generator<1 | 2, "a" | "b", unknown>
+
+    if (Math.random()) yield 1;
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>yield 1 : any
+>1 : 1
+
+    yield 2;
+>yield 2 : any
+>2 : 2
+
+    if (Math.random()) return "a";
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>"a" : "a"
+
+    return "b";
+>"b" : "b"
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+>g306 : () => Generator<number, boolean, "hi">
+
+    const a: "hi" = yield 1;
+>a : "hi"
+>yield 1 : any
+>1 : 1
+
+    return true;
+>true : true
+}
+
+function* g307<T>() { // Generator<number, T, T>
+>g307 : <T>() => Generator<number, T, T>
+
+    const a: T = yield 0;
+>a : T
+>yield 0 : any
+>0 : 0
+
+    return a;
+>a : T
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+>g308 : <T>(x: T) => Generator<T, T, T>
+>x : T
+
+    const a: T = yield x;
+>a : T
+>yield x : any
+>x : T
+
+    return a;
+>a : T
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+>g309 : <T, U, V>(x: T, y: U) => Generator<T, U, V>
+>x : T
+>y : U
+
+    const a: V = yield x;
+>a : V
+>yield x : any
+>x : T
+
+    return y;
+>y : U
+}
+
+function* g310() { // Generator<undefined, void, [(1 | undefined)?, (2 | undefined)?]>
+>g310 : () => Generator<undefined, void, [(1 | undefined)?, (2 | undefined)?]>
+
+	const [a = 1, b = 2] = yield;
+>a : any
+>1 : 1
+>b : any
+>2 : 2
+>yield : any
+}
+
+function* g311() { // Generator<undefined, void, string>
+>g311 : () => Generator<undefined, void, string>
+
+	yield* (function*() {
+>yield* (function*() {		const y: string = yield;	})() : void
+>(function*() {		const y: string = yield;	})() : Generator<undefined, void, string>
+>(function*() {		const y: string = yield;	}) : () => Generator<undefined, void, string>
+>function*() {		const y: string = yield;	} : () => Generator<undefined, void, string>
+
+		const y: string = yield;
+>y : string
+>yield : any
+
+	})();
+}
+
diff --git a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.errors.txt b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.errors.txt
new file mode 100644
index 0000000000000..ebab0e585c73d
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.errors.txt
@@ -0,0 +1,156 @@
+tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts(9,11): error TS7055: 'g001', which lacks return-type annotation, implicitly has an 'any' yield type.
+tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts(17,11): error TS7055: 'g003', which lacks return-type annotation, implicitly has an 'any' yield type.
+tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts(79,11): error TS7055: 'g301', which lacks return-type annotation, implicitly has an 'any' yield type.
+tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts(89,11): error TS7055: 'g303', which lacks return-type annotation, implicitly has an 'any' yield type.
+tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts(126,11): error TS7055: 'g310', which lacks return-type annotation, implicitly has an 'any' yield type.
+tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts(131,10): error TS7025: Generator implicitly has yield type 'any' because it does not yield any values. Consider supplying a return type annotation.
+
+
+==== tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts (6 errors) ====
+    declare const iterableIterator: IterableIterator<number>;
+    declare const generator: Generator<number, string, boolean>;
+    declare const never: never;
+    
+    function* g000() { // Generator<never, void, unknown>
+    }
+    
+    // 'yield' iteration type inference
+    function* g001() { // Generator<any (implicit), void, unknown>
+              ~~~~
+!!! error TS7055: 'g001', which lacks return-type annotation, implicitly has an 'any' yield type.
+        yield;
+    }
+    
+    function* g002() { // Generator<number, void, unknown>
+        yield 1;
+    }
+    
+    function* g003() { // Generator<any (implicit), void, unknown>
+              ~~~~
+!!! error TS7055: 'g003', which lacks return-type annotation, implicitly has an 'any' yield type.
+        // NOTE: In strict mode, `[]` produces the type `never[]`.
+        //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
+        yield* [];
+    }
+    
+    function* g004() { // Generator<number, void, undefined>
+        yield* iterableIterator;
+    }
+    
+    function* g005() { // Generator<number, void, boolean>
+        const x = yield* generator;
+    }
+    
+    function* g006() { // Generator<1 | 2, void, unknown>
+        yield 1;
+        yield 2;
+    }
+    
+    function* g007() { // Generator<never, void, unknown>
+        yield never;
+    }
+    
+    // 'return' iteration type inference
+    function* g102() { // Generator<never, number, unknown>
+        return 1;
+    }
+    
+    function* g103() { // Generator<never, 1 | 2, unknown>
+        if (Math.random()) return 1;
+        return 2;
+    }
+    
+    function* g104() { // Generator<never, never, unknown>
+        return never;
+    }
+    
+    // 'next' iteration type inference
+    function* g201() { // Generator<number, void, string>
+        let a: string = yield 1;
+    }
+    
+    function* g202() { // Generator<1 | 2, void, never>
+        let a: string = yield 1;
+        let b: number = yield 2;
+    }
+    
+    declare function f1(x: string): void;
+    declare function f1(x: number): void;
+    
+    function* g203() { // Generator<number, void, string>
+    	const x = f1(yield 1);
+    }
+    
+    declare function f2<T>(x: T): T;
+    
+    function* g204() { // Generator<number, void, any>
+    	const x = f2(yield 1);
+    }
+    
+    // mixed iteration types inference
+    
+    function* g301() { // Generator<any (implicit), void, unknown>
+              ~~~~
+!!! error TS7055: 'g301', which lacks return-type annotation, implicitly has an 'any' yield type.
+        yield;
+        return;
+    }
+    
+    function* g302() { // Generator<number, void, unknown>
+        yield 1;
+        return;
+    }
+    
+    function* g303() { // Generator<any (implicit), string, unknown>
+              ~~~~
+!!! error TS7055: 'g303', which lacks return-type annotation, implicitly has an 'any' yield type.
+        yield;
+        return "a";
+    }
+    
+    function* g304() { // Generator<number, string, unknown>
+        yield 1;
+        return "a";
+    }
+    
+    function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+        if (Math.random()) yield 1;
+        yield 2;
+        if (Math.random()) return "a";
+        return "b";
+    }
+    
+    function* g306() { // Generator<number, boolean, "hi">
+        const a: "hi" = yield 1;
+        return true;
+    }
+    
+    function* g307<T>() { // Generator<number, T, T>
+        const a: T = yield 0;
+        return a;
+    }
+    
+    function* g308<T>(x: T) { // Generator<T, T, T>
+        const a: T = yield x;
+        return a;
+    }
+    
+    function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+        const a: V = yield x;
+        return y;
+    }
+    
+    function* g310() { // Generator<any (implicit), void, [(1 | undefined)?, (2 | undefined)?]>
+              ~~~~
+!!! error TS7055: 'g310', which lacks return-type annotation, implicitly has an 'any' yield type.
+    	const [a = 1, b = 2] = yield;
+    }
+    
+    function* g311() { // Generator<any (implicit), void, string>
+    	yield* (function*() {
+    	        ~~~~~~~~
+!!! error TS7025: Generator implicitly has yield type 'any' because it does not yield any values. Consider supplying a return type annotation.
+    		const y: string = yield;
+    	})();
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.js b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.js
new file mode 100644
index 0000000000000..272a92d1504ea
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.js
@@ -0,0 +1,240 @@
+//// [generatorReturnTypeInferenceNonStrict.ts]
+declare const iterableIterator: IterableIterator<number>;
+declare const generator: Generator<number, string, boolean>;
+declare const never: never;
+
+function* g000() { // Generator<never, void, unknown>
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<any (implicit), void, unknown>
+    yield;
+}
+
+function* g002() { // Generator<number, void, unknown>
+    yield 1;
+}
+
+function* g003() { // Generator<any (implicit), void, unknown>
+    // NOTE: In strict mode, `[]` produces the type `never[]`.
+    //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
+    yield* [];
+}
+
+function* g004() { // Generator<number, void, undefined>
+    yield* iterableIterator;
+}
+
+function* g005() { // Generator<number, void, boolean>
+    const x = yield* generator;
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+    yield 1;
+    yield 2;
+}
+
+function* g007() { // Generator<never, void, unknown>
+    yield never;
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+    return 1;
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+    if (Math.random()) return 1;
+    return 2;
+}
+
+function* g104() { // Generator<never, never, unknown>
+    return never;
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+    let a: string = yield 1;
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+    let a: string = yield 1;
+    let b: number = yield 2;
+}
+
+declare function f1(x: string): void;
+declare function f1(x: number): void;
+
+function* g203() { // Generator<number, void, string>
+	const x = f1(yield 1);
+}
+
+declare function f2<T>(x: T): T;
+
+function* g204() { // Generator<number, void, any>
+	const x = f2(yield 1);
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<any (implicit), void, unknown>
+    yield;
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+    yield 1;
+    return;
+}
+
+function* g303() { // Generator<any (implicit), string, unknown>
+    yield;
+    return "a";
+}
+
+function* g304() { // Generator<number, string, unknown>
+    yield 1;
+    return "a";
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+    if (Math.random()) yield 1;
+    yield 2;
+    if (Math.random()) return "a";
+    return "b";
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+    const a: "hi" = yield 1;
+    return true;
+}
+
+function* g307<T>() { // Generator<number, T, T>
+    const a: T = yield 0;
+    return a;
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+    const a: T = yield x;
+    return a;
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+    const a: V = yield x;
+    return y;
+}
+
+function* g310() { // Generator<any (implicit), void, [(1 | undefined)?, (2 | undefined)?]>
+	const [a = 1, b = 2] = yield;
+}
+
+function* g311() { // Generator<any (implicit), void, string>
+	yield* (function*() {
+		const y: string = yield;
+	})();
+}
+
+
+//// [generatorReturnTypeInferenceNonStrict.js]
+function* g000() {
+}
+// 'yield' iteration type inference
+function* g001() {
+    yield;
+}
+function* g002() {
+    yield 1;
+}
+function* g003() {
+    // NOTE: In strict mode, `[]` produces the type `never[]`.
+    //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
+    yield* [];
+}
+function* g004() {
+    yield* iterableIterator;
+}
+function* g005() {
+    const x = yield* generator;
+}
+function* g006() {
+    yield 1;
+    yield 2;
+}
+function* g007() {
+    yield never;
+}
+// 'return' iteration type inference
+function* g102() {
+    return 1;
+}
+function* g103() {
+    if (Math.random())
+        return 1;
+    return 2;
+}
+function* g104() {
+    return never;
+}
+// 'next' iteration type inference
+function* g201() {
+    let a = yield 1;
+}
+function* g202() {
+    let a = yield 1;
+    let b = yield 2;
+}
+function* g203() {
+    const x = f1(yield 1);
+}
+function* g204() {
+    const x = f2(yield 1);
+}
+// mixed iteration types inference
+function* g301() {
+    yield;
+    return;
+}
+function* g302() {
+    yield 1;
+    return;
+}
+function* g303() {
+    yield;
+    return "a";
+}
+function* g304() {
+    yield 1;
+    return "a";
+}
+function* g305() {
+    if (Math.random())
+        yield 1;
+    yield 2;
+    if (Math.random())
+        return "a";
+    return "b";
+}
+function* g306() {
+    const a = yield 1;
+    return true;
+}
+function* g307() {
+    const a = yield 0;
+    return a;
+}
+function* g308(x) {
+    const a = yield x;
+    return a;
+}
+function* g309(x, y) {
+    const a = yield x;
+    return y;
+}
+function* g310() {
+    const [a = 1, b = 2] = yield;
+}
+function* g311() {
+    yield* (function* () {
+        const y = yield;
+    })();
+}
diff --git a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.symbols b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.symbols
new file mode 100644
index 0000000000000..2ff827d66c9a9
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.symbols
@@ -0,0 +1,260 @@
+=== tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts ===
+declare const iterableIterator: IterableIterator<number>;
+>iterableIterator : Symbol(iterableIterator, Decl(generatorReturnTypeInferenceNonStrict.ts, 0, 13))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.es2015.iterable.d.ts, --, --))
+
+declare const generator: Generator<number, string, boolean>;
+>generator : Symbol(generator, Decl(generatorReturnTypeInferenceNonStrict.ts, 1, 13))
+>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --))
+
+declare const never: never;
+>never : Symbol(never, Decl(generatorReturnTypeInferenceNonStrict.ts, 2, 13))
+
+function* g000() { // Generator<never, void, unknown>
+>g000 : Symbol(g000, Decl(generatorReturnTypeInferenceNonStrict.ts, 2, 27))
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<any (implicit), void, unknown>
+>g001 : Symbol(g001, Decl(generatorReturnTypeInferenceNonStrict.ts, 5, 1))
+
+    yield;
+}
+
+function* g002() { // Generator<number, void, unknown>
+>g002 : Symbol(g002, Decl(generatorReturnTypeInferenceNonStrict.ts, 10, 1))
+
+    yield 1;
+}
+
+function* g003() { // Generator<any (implicit), void, unknown>
+>g003 : Symbol(g003, Decl(generatorReturnTypeInferenceNonStrict.ts, 14, 1))
+
+    // NOTE: In strict mode, `[]` produces the type `never[]`.
+    //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
+    yield* [];
+}
+
+function* g004() { // Generator<number, void, undefined>
+>g004 : Symbol(g004, Decl(generatorReturnTypeInferenceNonStrict.ts, 20, 1))
+
+    yield* iterableIterator;
+>iterableIterator : Symbol(iterableIterator, Decl(generatorReturnTypeInferenceNonStrict.ts, 0, 13))
+}
+
+function* g005() { // Generator<number, void, boolean>
+>g005 : Symbol(g005, Decl(generatorReturnTypeInferenceNonStrict.ts, 24, 1))
+
+    const x = yield* generator;
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 27, 9))
+>generator : Symbol(generator, Decl(generatorReturnTypeInferenceNonStrict.ts, 1, 13))
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+>g006 : Symbol(g006, Decl(generatorReturnTypeInferenceNonStrict.ts, 28, 1))
+
+    yield 1;
+    yield 2;
+}
+
+function* g007() { // Generator<never, void, unknown>
+>g007 : Symbol(g007, Decl(generatorReturnTypeInferenceNonStrict.ts, 33, 1))
+
+    yield never;
+>never : Symbol(never, Decl(generatorReturnTypeInferenceNonStrict.ts, 2, 13))
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+>g102 : Symbol(g102, Decl(generatorReturnTypeInferenceNonStrict.ts, 37, 1))
+
+    return 1;
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+>g103 : Symbol(g103, Decl(generatorReturnTypeInferenceNonStrict.ts, 42, 1))
+
+    if (Math.random()) return 1;
+>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+
+    return 2;
+}
+
+function* g104() { // Generator<never, never, unknown>
+>g104 : Symbol(g104, Decl(generatorReturnTypeInferenceNonStrict.ts, 47, 1))
+
+    return never;
+>never : Symbol(never, Decl(generatorReturnTypeInferenceNonStrict.ts, 2, 13))
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+>g201 : Symbol(g201, Decl(generatorReturnTypeInferenceNonStrict.ts, 51, 1))
+
+    let a: string = yield 1;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 55, 7))
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+>g202 : Symbol(g202, Decl(generatorReturnTypeInferenceNonStrict.ts, 56, 1))
+
+    let a: string = yield 1;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 59, 7))
+
+    let b: number = yield 2;
+>b : Symbol(b, Decl(generatorReturnTypeInferenceNonStrict.ts, 60, 7))
+}
+
+declare function f1(x: string): void;
+>f1 : Symbol(f1, Decl(generatorReturnTypeInferenceNonStrict.ts, 61, 1), Decl(generatorReturnTypeInferenceNonStrict.ts, 63, 37))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 63, 20))
+
+declare function f1(x: number): void;
+>f1 : Symbol(f1, Decl(generatorReturnTypeInferenceNonStrict.ts, 61, 1), Decl(generatorReturnTypeInferenceNonStrict.ts, 63, 37))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 64, 20))
+
+function* g203() { // Generator<number, void, string>
+>g203 : Symbol(g203, Decl(generatorReturnTypeInferenceNonStrict.ts, 64, 37))
+
+	const x = f1(yield 1);
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 67, 6))
+>f1 : Symbol(f1, Decl(generatorReturnTypeInferenceNonStrict.ts, 61, 1), Decl(generatorReturnTypeInferenceNonStrict.ts, 63, 37))
+}
+
+declare function f2<T>(x: T): T;
+>f2 : Symbol(f2, Decl(generatorReturnTypeInferenceNonStrict.ts, 68, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 70, 20))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 70, 23))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 70, 20))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 70, 20))
+
+function* g204() { // Generator<number, void, any>
+>g204 : Symbol(g204, Decl(generatorReturnTypeInferenceNonStrict.ts, 70, 32))
+
+	const x = f2(yield 1);
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 73, 6))
+>f2 : Symbol(f2, Decl(generatorReturnTypeInferenceNonStrict.ts, 68, 1))
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<any (implicit), void, unknown>
+>g301 : Symbol(g301, Decl(generatorReturnTypeInferenceNonStrict.ts, 74, 1))
+
+    yield;
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+>g302 : Symbol(g302, Decl(generatorReturnTypeInferenceNonStrict.ts, 81, 1))
+
+    yield 1;
+    return;
+}
+
+function* g303() { // Generator<any (implicit), string, unknown>
+>g303 : Symbol(g303, Decl(generatorReturnTypeInferenceNonStrict.ts, 86, 1))
+
+    yield;
+    return "a";
+}
+
+function* g304() { // Generator<number, string, unknown>
+>g304 : Symbol(g304, Decl(generatorReturnTypeInferenceNonStrict.ts, 91, 1))
+
+    yield 1;
+    return "a";
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+>g305 : Symbol(g305, Decl(generatorReturnTypeInferenceNonStrict.ts, 96, 1))
+
+    if (Math.random()) yield 1;
+>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+
+    yield 2;
+    if (Math.random()) return "a";
+>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
+>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
+
+    return "b";
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+>g306 : Symbol(g306, Decl(generatorReturnTypeInferenceNonStrict.ts, 103, 1))
+
+    const a: "hi" = yield 1;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 106, 9))
+
+    return true;
+}
+
+function* g307<T>() { // Generator<number, T, T>
+>g307 : Symbol(g307, Decl(generatorReturnTypeInferenceNonStrict.ts, 108, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 110, 15))
+
+    const a: T = yield 0;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 111, 9))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 110, 15))
+
+    return a;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 111, 9))
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+>g308 : Symbol(g308, Decl(generatorReturnTypeInferenceNonStrict.ts, 113, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 115, 15))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 115, 18))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 115, 15))
+
+    const a: T = yield x;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 116, 9))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 115, 15))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 115, 18))
+
+    return a;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 116, 9))
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+>g309 : Symbol(g309, Decl(generatorReturnTypeInferenceNonStrict.ts, 118, 1))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 15))
+>U : Symbol(U, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 17))
+>V : Symbol(V, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 20))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 24))
+>T : Symbol(T, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 15))
+>y : Symbol(y, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 29))
+>U : Symbol(U, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 17))
+
+    const a: V = yield x;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 121, 9))
+>V : Symbol(V, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 20))
+>x : Symbol(x, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 24))
+
+    return y;
+>y : Symbol(y, Decl(generatorReturnTypeInferenceNonStrict.ts, 120, 29))
+}
+
+function* g310() { // Generator<any (implicit), void, [(1 | undefined)?, (2 | undefined)?]>
+>g310 : Symbol(g310, Decl(generatorReturnTypeInferenceNonStrict.ts, 123, 1))
+
+	const [a = 1, b = 2] = yield;
+>a : Symbol(a, Decl(generatorReturnTypeInferenceNonStrict.ts, 126, 8))
+>b : Symbol(b, Decl(generatorReturnTypeInferenceNonStrict.ts, 126, 14))
+}
+
+function* g311() { // Generator<any (implicit), void, string>
+>g311 : Symbol(g311, Decl(generatorReturnTypeInferenceNonStrict.ts, 127, 1))
+
+	yield* (function*() {
+		const y: string = yield;
+>y : Symbol(y, Decl(generatorReturnTypeInferenceNonStrict.ts, 131, 7))
+
+	})();
+}
+
diff --git a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types
new file mode 100644
index 0000000000000..4d6754d85bf62
--- /dev/null
+++ b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types
@@ -0,0 +1,310 @@
+=== tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts ===
+declare const iterableIterator: IterableIterator<number>;
+>iterableIterator : IterableIterator<number>
+
+declare const generator: Generator<number, string, boolean>;
+>generator : Generator<number, string, boolean>
+
+declare const never: never;
+>never : never
+
+function* g000() { // Generator<never, void, unknown>
+>g000 : () => Generator<never, void, unknown>
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<any (implicit), void, unknown>
+>g001 : () => Generator<any, void, unknown>
+
+    yield;
+>yield : any
+}
+
+function* g002() { // Generator<number, void, unknown>
+>g002 : () => Generator<number, void, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+}
+
+function* g003() { // Generator<any (implicit), void, unknown>
+>g003 : () => Generator<any, void, undefined>
+
+    // NOTE: In strict mode, `[]` produces the type `never[]`.
+    //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
+    yield* [];
+>yield* [] : any
+>[] : undefined[]
+}
+
+function* g004() { // Generator<number, void, undefined>
+>g004 : () => Generator<number, void, undefined>
+
+    yield* iterableIterator;
+>yield* iterableIterator : any
+>iterableIterator : IterableIterator<number>
+}
+
+function* g005() { // Generator<number, void, boolean>
+>g005 : () => Generator<number, void, boolean>
+
+    const x = yield* generator;
+>x : string
+>yield* generator : string
+>generator : Generator<number, string, boolean>
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+>g006 : () => Generator<1 | 2, void, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+
+    yield 2;
+>yield 2 : any
+>2 : 2
+}
+
+function* g007() { // Generator<never, void, unknown>
+>g007 : () => Generator<never, void, unknown>
+
+    yield never;
+>yield never : any
+>never : never
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+>g102 : () => Generator<never, number, unknown>
+
+    return 1;
+>1 : 1
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+>g103 : () => Generator<never, 1 | 2, unknown>
+
+    if (Math.random()) return 1;
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>1 : 1
+
+    return 2;
+>2 : 2
+}
+
+function* g104() { // Generator<never, never, unknown>
+>g104 : () => Generator<never, never, unknown>
+
+    return never;
+>never : never
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+>g201 : () => Generator<number, void, string>
+
+    let a: string = yield 1;
+>a : string
+>yield 1 : any
+>1 : 1
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+>g202 : () => Generator<1 | 2, void, never>
+
+    let a: string = yield 1;
+>a : string
+>yield 1 : any
+>1 : 1
+
+    let b: number = yield 2;
+>b : number
+>yield 2 : any
+>2 : 2
+}
+
+declare function f1(x: string): void;
+>f1 : { (x: string): void; (x: number): void; }
+>x : string
+
+declare function f1(x: number): void;
+>f1 : { (x: string): void; (x: number): void; }
+>x : number
+
+function* g203() { // Generator<number, void, string>
+>g203 : () => Generator<number, void, string>
+
+	const x = f1(yield 1);
+>x : void
+>f1(yield 1) : void
+>f1 : { (x: string): void; (x: number): void; }
+>yield 1 : any
+>1 : 1
+}
+
+declare function f2<T>(x: T): T;
+>f2 : <T>(x: T) => T
+>x : T
+
+function* g204() { // Generator<number, void, any>
+>g204 : () => Generator<number, void, any>
+
+	const x = f2(yield 1);
+>x : any
+>f2(yield 1) : any
+>f2 : <T>(x: T) => T
+>yield 1 : any
+>1 : 1
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<any (implicit), void, unknown>
+>g301 : () => Generator<any, void, unknown>
+
+    yield;
+>yield : any
+
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+>g302 : () => Generator<number, void, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+
+    return;
+}
+
+function* g303() { // Generator<any (implicit), string, unknown>
+>g303 : () => Generator<any, string, unknown>
+
+    yield;
+>yield : any
+
+    return "a";
+>"a" : "a"
+}
+
+function* g304() { // Generator<number, string, unknown>
+>g304 : () => Generator<number, string, unknown>
+
+    yield 1;
+>yield 1 : any
+>1 : 1
+
+    return "a";
+>"a" : "a"
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+>g305 : () => Generator<1 | 2, "a" | "b", unknown>
+
+    if (Math.random()) yield 1;
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>yield 1 : any
+>1 : 1
+
+    yield 2;
+>yield 2 : any
+>2 : 2
+
+    if (Math.random()) return "a";
+>Math.random() : number
+>Math.random : () => number
+>Math : Math
+>random : () => number
+>"a" : "a"
+
+    return "b";
+>"b" : "b"
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+>g306 : () => Generator<number, boolean, "hi">
+
+    const a: "hi" = yield 1;
+>a : "hi"
+>yield 1 : any
+>1 : 1
+
+    return true;
+>true : true
+}
+
+function* g307<T>() { // Generator<number, T, T>
+>g307 : <T>() => Generator<number, T, T>
+
+    const a: T = yield 0;
+>a : T
+>yield 0 : any
+>0 : 0
+
+    return a;
+>a : T
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+>g308 : <T>(x: T) => Generator<T, T, T>
+>x : T
+
+    const a: T = yield x;
+>a : T
+>yield x : any
+>x : T
+
+    return a;
+>a : T
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+>g309 : <T, U, V>(x: T, y: U) => Generator<T, U, V>
+>x : T
+>y : U
+
+    const a: V = yield x;
+>a : V
+>yield x : any
+>x : T
+
+    return y;
+>y : U
+}
+
+function* g310() { // Generator<any (implicit), void, [(1 | undefined)?, (2 | undefined)?]>
+>g310 : () => Generator<any, void, [1?, 2?]>
+
+	const [a = 1, b = 2] = yield;
+>a : any
+>1 : 1
+>b : any
+>2 : 2
+>yield : any
+}
+
+function* g311() { // Generator<any (implicit), void, string>
+>g311 : () => Generator<any, void, string>
+
+	yield* (function*() {
+>yield* (function*() {		const y: string = yield;	})() : void
+>(function*() {		const y: string = yield;	})() : Generator<any, void, string>
+>(function*() {		const y: string = yield;	}) : () => Generator<any, void, string>
+>function*() {		const y: string = yield;	} : () => Generator<any, void, string>
+
+		const y: string = yield;
+>y : string
+>yield : any
+
+	})();
+}
+
diff --git a/tests/baselines/reference/generatorTypeCheck1.types b/tests/baselines/reference/generatorTypeCheck1.types
index 435da37fa698a..72597601a8590 100644
--- a/tests/baselines/reference/generatorTypeCheck1.types
+++ b/tests/baselines/reference/generatorTypeCheck1.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
 function* g1(): Iterator<string> { }
->g1 : () => Iterator<string>
+>g1 : () => Iterator<string, any, undefined>
 
diff --git a/tests/baselines/reference/generatorTypeCheck13.types b/tests/baselines/reference/generatorTypeCheck13.types
index 06e0e5ec380b6..2d5bdd5827e78 100644
--- a/tests/baselines/reference/generatorTypeCheck13.types
+++ b/tests/baselines/reference/generatorTypeCheck13.types
@@ -3,7 +3,7 @@ function* g(): IterableIterator<number> {
 >g : () => IterableIterator<number>
 
     yield 0;
->yield 0 : any
+>yield 0 : undefined
 >0 : 0
 
     return "";
diff --git a/tests/baselines/reference/generatorTypeCheck14.types b/tests/baselines/reference/generatorTypeCheck14.types
index 28401e68567a2..a4113cb8be294 100644
--- a/tests/baselines/reference/generatorTypeCheck14.types
+++ b/tests/baselines/reference/generatorTypeCheck14.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck14.ts ===
 function* g() {
->g : () => IterableIterator<0 | "">
+>g : () => Generator<number, string, unknown>
 
     yield 0;
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck15.types b/tests/baselines/reference/generatorTypeCheck15.types
index 33537836c120f..d8e8ed5880587 100644
--- a/tests/baselines/reference/generatorTypeCheck15.types
+++ b/tests/baselines/reference/generatorTypeCheck15.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck15.ts ===
 function* g() {
->g : () => IterableIterator<string>
+>g : () => Generator<never, string, unknown>
 
     return "";
 >"" : ""
diff --git a/tests/baselines/reference/generatorTypeCheck16.types b/tests/baselines/reference/generatorTypeCheck16.types
index a607ad851c198..b8b43fcefc733 100644
--- a/tests/baselines/reference/generatorTypeCheck16.types
+++ b/tests/baselines/reference/generatorTypeCheck16.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck16.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     return;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck17.types b/tests/baselines/reference/generatorTypeCheck17.types
index 5a1f03055cc35..e6631757d0d03 100644
--- a/tests/baselines/reference/generatorTypeCheck17.types
+++ b/tests/baselines/reference/generatorTypeCheck17.types
@@ -12,10 +12,10 @@ function* g(): IterableIterator<Foo> {
 >g : () => IterableIterator<Foo>
 
     yield;
->yield : any
+>yield : undefined
 
     yield new Bar;
->yield new Bar : any
+>yield new Bar : undefined
 >new Bar : Bar
 >Bar : typeof Bar
 }
diff --git a/tests/baselines/reference/generatorTypeCheck18.types b/tests/baselines/reference/generatorTypeCheck18.types
index b1d1da6661e19..73a9a0d88c753 100644
--- a/tests/baselines/reference/generatorTypeCheck18.types
+++ b/tests/baselines/reference/generatorTypeCheck18.types
@@ -11,10 +11,10 @@ function* g(): IterableIterator<Foo> {
 >g : () => IterableIterator<Foo>
 
     yield;
->yield : any
+>yield : undefined
 
     yield new Baz;
->yield new Baz : any
+>yield new Baz : undefined
 >new Baz : Baz
 >Baz : typeof Baz
 }
diff --git a/tests/baselines/reference/generatorTypeCheck19.types b/tests/baselines/reference/generatorTypeCheck19.types
index 73612246eface..f05cae1fd5532 100644
--- a/tests/baselines/reference/generatorTypeCheck19.types
+++ b/tests/baselines/reference/generatorTypeCheck19.types
@@ -12,7 +12,7 @@ function* g(): IterableIterator<Foo> {
 >g : () => IterableIterator<Foo>
 
     yield;
->yield : any
+>yield : undefined
 
     yield * [new Bar];
 >yield * [new Bar] : any
diff --git a/tests/baselines/reference/generatorTypeCheck20.types b/tests/baselines/reference/generatorTypeCheck20.types
index 77b15497db0e8..a0ab6b1449737 100644
--- a/tests/baselines/reference/generatorTypeCheck20.types
+++ b/tests/baselines/reference/generatorTypeCheck20.types
@@ -11,7 +11,7 @@ function* g(): IterableIterator<Foo> {
 >g : () => IterableIterator<Foo>
 
     yield;
->yield : any
+>yield : undefined
 
     yield * [new Baz];
 >yield * [new Baz] : any
diff --git a/tests/baselines/reference/generatorTypeCheck21.types b/tests/baselines/reference/generatorTypeCheck21.types
index a87d66d5ceea0..96b0f15cf60f0 100644
--- a/tests/baselines/reference/generatorTypeCheck21.types
+++ b/tests/baselines/reference/generatorTypeCheck21.types
@@ -12,7 +12,7 @@ function* g(): IterableIterator<Foo> {
 >g : () => IterableIterator<Foo>
 
     yield;
->yield : any
+>yield : undefined
 
     yield * new Bar;
 >yield * new Bar : any
diff --git a/tests/baselines/reference/generatorTypeCheck22.types b/tests/baselines/reference/generatorTypeCheck22.types
index e46e73874e619..3f8f2d3fd9f68 100644
--- a/tests/baselines/reference/generatorTypeCheck22.types
+++ b/tests/baselines/reference/generatorTypeCheck22.types
@@ -13,7 +13,7 @@ class Baz { z: number }
 >z : number
 
 function* g3() {
->g3 : () => IterableIterator<Bar | Baz>
+>g3 : () => Generator<Bar | Baz, void, undefined>
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck23.types b/tests/baselines/reference/generatorTypeCheck23.types
index 1d5d294503a60..a7fa6c880bb2b 100644
--- a/tests/baselines/reference/generatorTypeCheck23.types
+++ b/tests/baselines/reference/generatorTypeCheck23.types
@@ -13,7 +13,7 @@ class Baz { z: number }
 >z : number
 
 function* g3() {
->g3 : () => IterableIterator<Foo | Baz>
+>g3 : () => Generator<Foo | Baz, void, undefined>
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck24.types b/tests/baselines/reference/generatorTypeCheck24.types
index e3c369bfce199..8f8f4d668f1f3 100644
--- a/tests/baselines/reference/generatorTypeCheck24.types
+++ b/tests/baselines/reference/generatorTypeCheck24.types
@@ -13,7 +13,7 @@ class Baz { z: number }
 >z : number
 
 function* g3() {
->g3 : () => IterableIterator<Foo | Baz>
+>g3 : () => Generator<Foo | Baz, void, undefined>
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck25.errors.txt b/tests/baselines/reference/generatorTypeCheck25.errors.txt
index c3c456e805d7d..365a19dfdd7a0 100644
--- a/tests/baselines/reference/generatorTypeCheck25.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck25.errors.txt
@@ -1,13 +1,15 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts(4,5): error TS2322: Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterable<Foo>'.
-  Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterable<Foo>'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterable<Foo>'.
+  Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterable<Foo>'.
     Types of property '[Symbol.iterator]' are incompatible.
-      Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterator<Foo>'.
-        Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterator<Foo>'.
+      Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterator<Foo, any, undefined>'.
+        Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterator<Foo, any, undefined>'.
           Types of property 'next' are incompatible.
-            Type '(value?: any) => IteratorResult<Bar | Baz>' is not assignable to type '(value?: any) => IteratorResult<Foo>'.
-              Type 'IteratorResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo>'.
-                Type 'Bar | Baz' is not assignable to type 'Foo'.
-                  Property 'x' is missing in type 'Baz' but required in type 'Foo'.
+            Type '(...args: [] | [undefined]) => IteratorResult<Bar | Baz, void>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<Foo, any>'.
+              Type 'IteratorResult<Bar | Baz, void>' is not assignable to type 'IteratorResult<Foo, any>'.
+                Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo, any>'.
+                  Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorYieldResult<Foo>'.
+                    Type 'Bar | Baz' is not assignable to type 'Foo'.
+                      Property 'x' is missing in type 'Baz' but required in type 'Foo'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts (1 errors) ====
@@ -16,16 +18,18 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts(4,5): error
     class Baz { z: number }
     var g3: () => Iterable<Foo> = function* () {
         ~~
-!!! error TS2322: Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterable<Foo>'.
-!!! error TS2322:   Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterable<Foo>'.
+!!! error TS2322: Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterable<Foo>'.
+!!! error TS2322:   Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterable<Foo>'.
 !!! error TS2322:     Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2322:       Type '() => IterableIterator<Bar | Baz>' is not assignable to type '() => Iterator<Foo>'.
-!!! error TS2322:         Type 'IterableIterator<Bar | Baz>' is not assignable to type 'Iterator<Foo>'.
+!!! error TS2322:       Type '() => Generator<Bar | Baz, void, undefined>' is not assignable to type '() => Iterator<Foo, any, undefined>'.
+!!! error TS2322:         Type 'Generator<Bar | Baz, void, undefined>' is not assignable to type 'Iterator<Foo, any, undefined>'.
 !!! error TS2322:           Types of property 'next' are incompatible.
-!!! error TS2322:             Type '(value?: any) => IteratorResult<Bar | Baz>' is not assignable to type '(value?: any) => IteratorResult<Foo>'.
-!!! error TS2322:               Type 'IteratorResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo>'.
-!!! error TS2322:                 Type 'Bar | Baz' is not assignable to type 'Foo'.
-!!! error TS2322:                   Property 'x' is missing in type 'Baz' but required in type 'Foo'.
+!!! error TS2322:             Type '(...args: [] | [undefined]) => IteratorResult<Bar | Baz, void>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<Foo, any>'.
+!!! error TS2322:               Type 'IteratorResult<Bar | Baz, void>' is not assignable to type 'IteratorResult<Foo, any>'.
+!!! error TS2322:                 Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorResult<Foo, any>'.
+!!! error TS2322:                   Type 'IteratorYieldResult<Bar | Baz>' is not assignable to type 'IteratorYieldResult<Foo>'.
+!!! error TS2322:                     Type 'Bar | Baz' is not assignable to type 'Foo'.
+!!! error TS2322:                       Property 'x' is missing in type 'Baz' but required in type 'Foo'.
 !!! related TS2728 tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck25.ts:1:13: 'x' is declared here.
         yield;
         yield new Bar;
diff --git a/tests/baselines/reference/generatorTypeCheck25.types b/tests/baselines/reference/generatorTypeCheck25.types
index 4707bfe7b6b07..d0498c2da16ea 100644
--- a/tests/baselines/reference/generatorTypeCheck25.types
+++ b/tests/baselines/reference/generatorTypeCheck25.types
@@ -14,7 +14,7 @@ class Baz { z: number }
 
 var g3: () => Iterable<Foo> = function* () {
 >g3 : () => Iterable<Foo>
->function* () {    yield;    yield new Bar;    yield new Baz;    yield *[new Bar];    yield *[new Baz];} : () => IterableIterator<Bar | Baz>
+>function* () {    yield;    yield new Bar;    yield new Baz;    yield *[new Bar];    yield *[new Baz];} : () => Generator<Bar | Baz, void, undefined>
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck26.types b/tests/baselines/reference/generatorTypeCheck26.types
index 6ae17c983b8fd..7ade7bdec9198 100644
--- a/tests/baselines/reference/generatorTypeCheck26.types
+++ b/tests/baselines/reference/generatorTypeCheck26.types
@@ -4,7 +4,7 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : string
 
     yield x => x.length;
->yield x => x.length : any
+>yield x => x.length : undefined
 >x => x.length : (x: string) => number
 >x : string
 >x.length : number
diff --git a/tests/baselines/reference/generatorTypeCheck27.types b/tests/baselines/reference/generatorTypeCheck27.types
index 16632d021a401..58306e1fb4aec 100644
--- a/tests/baselines/reference/generatorTypeCheck27.types
+++ b/tests/baselines/reference/generatorTypeCheck27.types
@@ -4,9 +4,9 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : string
 
     yield * function* () {
->yield * function* () {        yield x => x.length;    } () : any
->function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
->function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+>yield * function* () {        yield x => x.length;    } () : void
+>function* () {        yield x => x.length;    } () : Generator<(x: any) => any, void, unknown>
+>function* () {        yield x => x.length;    } : () => Generator<(x: any) => any, void, unknown>
 
         yield x => x.length;
 >yield x => x.length : any
diff --git a/tests/baselines/reference/generatorTypeCheck28.types b/tests/baselines/reference/generatorTypeCheck28.types
index 7d5bafe28c52e..9cd4e5e82cecb 100644
--- a/tests/baselines/reference/generatorTypeCheck28.types
+++ b/tests/baselines/reference/generatorTypeCheck28.types
@@ -4,11 +4,11 @@ function* g(): IterableIterator<(x: string) => number> {
 >x : string
 
     yield * {
->yield * {        *[Symbol.iterator]() {            yield x => x.length;        }    } : any
->{        *[Symbol.iterator]() {            yield x => x.length;        }    } : { [Symbol.iterator](): IterableIterator<(x: string) => number>; }
+>yield * {        *[Symbol.iterator]() {            yield x => x.length;        }    } : void
+>{        *[Symbol.iterator]() {            yield x => x.length;        }    } : { [Symbol.iterator](): Generator<(x: string) => number, void, unknown>; }
 
         *[Symbol.iterator]() {
->[Symbol.iterator] : () => IterableIterator<(x: string) => number>
+>[Symbol.iterator] : () => Generator<(x: string) => number, void, unknown>
 >Symbol.iterator : symbol
 >Symbol : SymbolConstructor
 >iterator : symbol
diff --git a/tests/baselines/reference/generatorTypeCheck29.types b/tests/baselines/reference/generatorTypeCheck29.types
index 48a32f65e37f2..0ce49791a22c6 100644
--- a/tests/baselines/reference/generatorTypeCheck29.types
+++ b/tests/baselines/reference/generatorTypeCheck29.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
->g2 : () => Iterator<Iterable<(x: string) => number>>
+>g2 : () => Iterator<Iterable<(x: string) => number>, any, undefined>
 >x : string
 
     yield function* () {
->yield function* () {        yield x => x.length;    } () : any
->function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
->function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+>yield function* () {        yield x => x.length;    } () : undefined
+>function* () {        yield x => x.length;    } () : Generator<(x: any) => any, void, unknown>
+>function* () {        yield x => x.length;    } : () => Generator<(x: any) => any, void, unknown>
 
         yield x => x.length;
 >yield x => x.length : any
diff --git a/tests/baselines/reference/generatorTypeCheck30.types b/tests/baselines/reference/generatorTypeCheck30.types
index 2e4971770f328..094ed3bf33758 100644
--- a/tests/baselines/reference/generatorTypeCheck30.types
+++ b/tests/baselines/reference/generatorTypeCheck30.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
->g2 : () => Iterator<Iterable<(x: string) => number>>
+>g2 : () => Iterator<Iterable<(x: string) => number>, any, undefined>
 >x : string
 
     yield function* () {
->yield function* () {        yield x => x.length;    } () : any
->function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
->function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+>yield function* () {        yield x => x.length;    } () : undefined
+>function* () {        yield x => x.length;    } () : Generator<(x: any) => any, void, unknown>
+>function* () {        yield x => x.length;    } : () => Generator<(x: any) => any, void, unknown>
 
         yield x => x.length;
 >yield x => x.length : any
diff --git a/tests/baselines/reference/generatorTypeCheck31.errors.txt b/tests/baselines/reference/generatorTypeCheck31.errors.txt
index 437b7470069b1..0ed5dcbe0e08f 100644
--- a/tests/baselines/reference/generatorTypeCheck31.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck31.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts(2,11): error TS2322: Type 'IterableIterator<(x: any) => any>' is not assignable to type '() => Iterable<(x: string) => number>'.
-  Type 'IterableIterator<(x: any) => any>' provides no match for the signature '(): Iterable<(x: string) => number>'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts(2,11): error TS2322: Type 'Generator<(x: any) => any, void, unknown>' is not assignable to type '() => Iterable<(x: string) => number>'.
+  Type 'Generator<(x: any) => any, void, unknown>' provides no match for the signature '(): Iterable<(x: string) => number>'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts (1 errors) ====
@@ -10,6 +10,6 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts(2,11): erro
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
         } ()
     ~~~~~~~~
-!!! error TS2322: Type 'IterableIterator<(x: any) => any>' is not assignable to type '() => Iterable<(x: string) => number>'.
-!!! error TS2322:   Type 'IterableIterator<(x: any) => any>' provides no match for the signature '(): Iterable<(x: string) => number>'.
+!!! error TS2322: Type 'Generator<(x: any) => any, void, unknown>' is not assignable to type '() => Iterable<(x: string) => number>'.
+!!! error TS2322:   Type 'Generator<(x: any) => any, void, unknown>' provides no match for the signature '(): Iterable<(x: string) => number>'.
     }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck31.types b/tests/baselines/reference/generatorTypeCheck31.types
index 2038b2ee1c2a2..c15eab96fe9e0 100644
--- a/tests/baselines/reference/generatorTypeCheck31.types
+++ b/tests/baselines/reference/generatorTypeCheck31.types
@@ -1,12 +1,12 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck31.ts ===
 function* g2(): Iterator<() => Iterable<(x: string) => number>> {
->g2 : () => Iterator<() => Iterable<(x: string) => number>>
+>g2 : () => Iterator<() => Iterable<(x: string) => number>, any, undefined>
 >x : string
 
     yield function* () {
->yield function* () {        yield x => x.length;    } () : any
->function* () {        yield x => x.length;    } () : IterableIterator<(x: any) => any>
->function* () {        yield x => x.length;    } : () => IterableIterator<(x: any) => any>
+>yield function* () {        yield x => x.length;    } () : undefined
+>function* () {        yield x => x.length;    } () : Generator<(x: any) => any, void, unknown>
+>function* () {        yield x => x.length;    } : () => Generator<(x: any) => any, void, unknown>
 
         yield x => x.length;
 >yield x => x.length : any
diff --git a/tests/baselines/reference/generatorTypeCheck33.types b/tests/baselines/reference/generatorTypeCheck33.types
index d6b29936530d6..e894b44a4e388 100644
--- a/tests/baselines/reference/generatorTypeCheck33.types
+++ b/tests/baselines/reference/generatorTypeCheck33.types
@@ -1,13 +1,13 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck33.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     yield 0;
 >yield 0 : any
 >0 : 0
 
     function* g2() {
->g2 : () => IterableIterator<string>
+>g2 : () => Generator<string, void, unknown>
 
         yield "";
 >yield "" : any
diff --git a/tests/baselines/reference/generatorTypeCheck34.types b/tests/baselines/reference/generatorTypeCheck34.types
index f25eefb72f7be..5e2e6af134cad 100644
--- a/tests/baselines/reference/generatorTypeCheck34.types
+++ b/tests/baselines/reference/generatorTypeCheck34.types
@@ -1,13 +1,13 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck34.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     yield 0;
 >yield 0 : any
 >0 : 0
 
     function* g2() {
->g2 : () => IterableIterator<string>
+>g2 : () => Generator<never, string, unknown>
 
         return "";
 >"" : ""
diff --git a/tests/baselines/reference/generatorTypeCheck35.types b/tests/baselines/reference/generatorTypeCheck35.types
index 333b653a50148..b35139b9c16c6 100644
--- a/tests/baselines/reference/generatorTypeCheck35.types
+++ b/tests/baselines/reference/generatorTypeCheck35.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck35.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     yield 0;
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck36.types b/tests/baselines/reference/generatorTypeCheck36.types
index 318a46c25fb59..9cebc9a407f12 100644
--- a/tests/baselines/reference/generatorTypeCheck36.types
+++ b/tests/baselines/reference/generatorTypeCheck36.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck36.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, void, unknown>
 
     yield yield 0;
 >yield yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck37.types b/tests/baselines/reference/generatorTypeCheck37.types
index aaa790c809474..d9c28b941ddbd 100644
--- a/tests/baselines/reference/generatorTypeCheck37.types
+++ b/tests/baselines/reference/generatorTypeCheck37.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck37.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, any, unknown>
 
     return yield yield 0;
 >yield yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck38.types b/tests/baselines/reference/generatorTypeCheck38.types
index 15b8528b345a6..a62587603d4f5 100644
--- a/tests/baselines/reference/generatorTypeCheck38.types
+++ b/tests/baselines/reference/generatorTypeCheck38.types
@@ -3,7 +3,7 @@ var yield;
 >yield : any
 
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     yield 0;
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck39.types b/tests/baselines/reference/generatorTypeCheck39.types
index e24fc173566db..5ca4062b5580d 100644
--- a/tests/baselines/reference/generatorTypeCheck39.types
+++ b/tests/baselines/reference/generatorTypeCheck39.types
@@ -8,7 +8,7 @@ function decorator(x: any) {
 >y : any
 }
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     @decorator(yield 0)
 >decorator(yield 0) : (y: any) => void
diff --git a/tests/baselines/reference/generatorTypeCheck40.types b/tests/baselines/reference/generatorTypeCheck40.types
index cbec14d36d6b9..4e774158175fb 100644
--- a/tests/baselines/reference/generatorTypeCheck40.types
+++ b/tests/baselines/reference/generatorTypeCheck40.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     class C extends (yield 0) { }
 >C : C
diff --git a/tests/baselines/reference/generatorTypeCheck41.types b/tests/baselines/reference/generatorTypeCheck41.types
index 5f20d01765582..d22c875416f8b 100644
--- a/tests/baselines/reference/generatorTypeCheck41.types
+++ b/tests/baselines/reference/generatorTypeCheck41.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck41.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     let x = {
 >x : { [x: number]: number; }
diff --git a/tests/baselines/reference/generatorTypeCheck42.types b/tests/baselines/reference/generatorTypeCheck42.types
index 47d948739f10d..f3e82ad1a98d0 100644
--- a/tests/baselines/reference/generatorTypeCheck42.types
+++ b/tests/baselines/reference/generatorTypeCheck42.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck42.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     let x = {
 >x : { [x: number]: () => void; }
diff --git a/tests/baselines/reference/generatorTypeCheck43.types b/tests/baselines/reference/generatorTypeCheck43.types
index 298c631728ebb..cdf5cdc81bbb8 100644
--- a/tests/baselines/reference/generatorTypeCheck43.types
+++ b/tests/baselines/reference/generatorTypeCheck43.types
@@ -1,13 +1,13 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck43.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     let x = {
->x : { [x: number]: () => IterableIterator<any>; }
->{        *[yield 0]() {        }    } : { [x: number]: () => IterableIterator<any>; }
+>x : { [x: number]: () => Generator<never, void, unknown>; }
+>{        *[yield 0]() {        }    } : { [x: number]: () => Generator<never, void, unknown>; }
 
         *[yield 0]() {
->[yield 0] : () => IterableIterator<any>
+>[yield 0] : () => Generator<never, void, unknown>
 >yield 0 : any
 >0 : 0
 
diff --git a/tests/baselines/reference/generatorTypeCheck44.types b/tests/baselines/reference/generatorTypeCheck44.types
index 38b335f1ab46c..53dfd59266ec8 100644
--- a/tests/baselines/reference/generatorTypeCheck44.types
+++ b/tests/baselines/reference/generatorTypeCheck44.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck44.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     let x = {
 >x : { [x: number]: number; }
diff --git a/tests/baselines/reference/generatorTypeCheck45.types b/tests/baselines/reference/generatorTypeCheck45.types
index 59ee8efa9f373..cf40924194775 100644
--- a/tests/baselines/reference/generatorTypeCheck45.types
+++ b/tests/baselines/reference/generatorTypeCheck45.types
@@ -1,17 +1,17 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck45.ts ===
 declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T): T;
->foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T) => T
+>foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U, any, undefined>, fun2: (y: U) => T) => T
 >x : T
->fun : () => Iterator<(x: T) => U>
+>fun : () => Iterator<(x: T) => U, any, undefined>
 >x : T
 >fun2 : (y: U) => T
 >y : U
 
 foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string
 >foo("", function* () { yield x => x.length }, p => undefined) : string
->foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) => T) => T
+>foo : <T, U>(x: T, fun: () => Iterator<(x: T) => U, any, undefined>, fun2: (y: U) => T) => T
 >"" : ""
->function* () { yield x => x.length } : () => IterableIterator<(x: string) => number>
+>function* () { yield x => x.length } : () => Generator<(x: string) => number, void, unknown>
 >yield x => x.length : any
 >x => x.length : (x: string) => number
 >x : string
diff --git a/tests/baselines/reference/generatorTypeCheck46.types b/tests/baselines/reference/generatorTypeCheck46.types
index 81002c761d93a..cd565d55911ee 100644
--- a/tests/baselines/reference/generatorTypeCheck46.types
+++ b/tests/baselines/reference/generatorTypeCheck46.types
@@ -11,14 +11,14 @@ foo("", function* () {
 >foo("", function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }}, p => undefined) : string
 >foo : <T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) => T) => T
 >"" : ""
->function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }} : () => IterableIterator<(x: string) => number>
+>function* () {    yield* {        *[Symbol.iterator]() {            yield x => x.length        }    }} : () => Generator<(x: string) => number, void, unknown>
 
     yield* {
->yield* {        *[Symbol.iterator]() {            yield x => x.length        }    } : any
->{        *[Symbol.iterator]() {            yield x => x.length        }    } : { [Symbol.iterator](): IterableIterator<(x: string) => number>; }
+>yield* {        *[Symbol.iterator]() {            yield x => x.length        }    } : void
+>{        *[Symbol.iterator]() {            yield x => x.length        }    } : { [Symbol.iterator](): Generator<(x: string) => number, void, unknown>; }
 
         *[Symbol.iterator]() {
->[Symbol.iterator] : () => IterableIterator<(x: string) => number>
+>[Symbol.iterator] : () => Generator<(x: string) => number, void, unknown>
 >Symbol.iterator : symbol
 >Symbol : SymbolConstructor
 >iterator : symbol
diff --git a/tests/baselines/reference/generatorTypeCheck47.errors.txt b/tests/baselines/reference/generatorTypeCheck47.errors.txt
deleted file mode 100644
index 993285179bcaa..0000000000000
--- a/tests/baselines/reference/generatorTypeCheck47.errors.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts (1 errors) ====
-    function* g() { }
-            ~
-!!! error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck47.types b/tests/baselines/reference/generatorTypeCheck47.types
index d37512af0ac89..d5e92f02a873f 100644
--- a/tests/baselines/reference/generatorTypeCheck47.types
+++ b/tests/baselines/reference/generatorTypeCheck47.types
@@ -1,4 +1,4 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck47.ts ===
 function* g() { }
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
diff --git a/tests/baselines/reference/generatorTypeCheck48.errors.txt b/tests/baselines/reference/generatorTypeCheck48.errors.txt
index a3a9706175f26..e1c98d4f27503 100644
--- a/tests/baselines/reference/generatorTypeCheck48.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck48.errors.txt
@@ -1,17 +1,17 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(1,11): error TS7010: 'g', which lacks return-type annotation, implicitly has an 'any' return type.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(5,11): error TS7010: 'h', which lacks return-type annotation, implicitly has an 'any' return type.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(1,11): error TS7055: 'g', which lacks return-type annotation, implicitly has an 'any' yield type.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts(5,11): error TS7055: 'h', which lacks return-type annotation, implicitly has an 'any' yield type.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts (2 errors) ====
     function* g() {
               ~
-!!! error TS7010: 'g', which lacks return-type annotation, implicitly has an 'any' return type.
+!!! error TS7055: 'g', which lacks return-type annotation, implicitly has an 'any' yield type.
         yield;
     }
     
     function* h() {
               ~
-!!! error TS7010: 'h', which lacks return-type annotation, implicitly has an 'any' return type.
+!!! error TS7055: 'h', which lacks return-type annotation, implicitly has an 'any' yield type.
         yield undefined;
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck48.types b/tests/baselines/reference/generatorTypeCheck48.types
index f07131595cdbc..23134d50bee16 100644
--- a/tests/baselines/reference/generatorTypeCheck48.types
+++ b/tests/baselines/reference/generatorTypeCheck48.types
@@ -1,13 +1,13 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck48.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, void, unknown>
 
     yield;
 >yield : any
 }
 
 function* h() {
->h : () => IterableIterator<any>
+>h : () => Generator<any, void, unknown>
 
     yield undefined;
 >yield undefined : any
diff --git a/tests/baselines/reference/generatorTypeCheck49.types b/tests/baselines/reference/generatorTypeCheck49.types
index f73978d1a095a..985194b7392cd 100644
--- a/tests/baselines/reference/generatorTypeCheck49.types
+++ b/tests/baselines/reference/generatorTypeCheck49.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck49.ts ===
 function* g() {
->g : () => IterableIterator<number>
+>g : () => Generator<number, void, unknown>
 
     yield 0;
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck50.types b/tests/baselines/reference/generatorTypeCheck50.types
index 1b25ea004f8fb..fa4561d16a1ec 100644
--- a/tests/baselines/reference/generatorTypeCheck50.types
+++ b/tests/baselines/reference/generatorTypeCheck50.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck50.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, void, unknown>
 
     yield yield;
 >yield yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck51.errors.txt b/tests/baselines/reference/generatorTypeCheck51.errors.txt
deleted file mode 100644
index b717b51803e38..0000000000000
--- a/tests/baselines/reference/generatorTypeCheck51.errors.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts(1,9): error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
-
-
-==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts (1 errors) ====
-    function* g() {
-            ~
-!!! error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
-        function* h() {
-            yield 0;
-        }
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck51.types b/tests/baselines/reference/generatorTypeCheck51.types
index 1563ee5e7d317..0ef7abf19cd3b 100644
--- a/tests/baselines/reference/generatorTypeCheck51.types
+++ b/tests/baselines/reference/generatorTypeCheck51.types
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck51.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     function* h() {
->h : () => IterableIterator<number>
+>h : () => Generator<number, void, unknown>
 
         yield 0;
 >yield 0 : any
diff --git a/tests/baselines/reference/generatorTypeCheck52.types b/tests/baselines/reference/generatorTypeCheck52.types
index 97ac442aa0e30..30ef8611f6949 100644
--- a/tests/baselines/reference/generatorTypeCheck52.types
+++ b/tests/baselines/reference/generatorTypeCheck52.types
@@ -8,7 +8,7 @@ class Baz { z: number }
 >z : number
 
 function* g() {
->g : () => IterableIterator<Foo | Baz>
+>g : () => Generator<Foo | Baz, void, unknown>
 
     yield new Foo;
 >yield new Foo : any
diff --git a/tests/baselines/reference/generatorTypeCheck53.types b/tests/baselines/reference/generatorTypeCheck53.types
index b91974e98073e..47972eec714c4 100644
--- a/tests/baselines/reference/generatorTypeCheck53.types
+++ b/tests/baselines/reference/generatorTypeCheck53.types
@@ -8,7 +8,7 @@ class Baz { z: number }
 >z : number
 
 function* g() {
->g : () => IterableIterator<Foo | Baz>
+>g : () => Generator<Foo | Baz, void, undefined>
 
     yield new Foo;
 >yield new Foo : any
diff --git a/tests/baselines/reference/generatorTypeCheck54.types b/tests/baselines/reference/generatorTypeCheck54.types
index 1cdbde67498f0..6e91f4be51a4a 100644
--- a/tests/baselines/reference/generatorTypeCheck54.types
+++ b/tests/baselines/reference/generatorTypeCheck54.types
@@ -8,7 +8,7 @@ class Baz { z: number }
 >z : number
 
 function* g() {
->g : () => IterableIterator<Foo | Baz>
+>g : () => Generator<Foo | Baz, void, undefined>
 
     yield* [new Foo];
 >yield* [new Foo] : any
diff --git a/tests/baselines/reference/generatorTypeCheck55.types b/tests/baselines/reference/generatorTypeCheck55.types
index c45f169013101..15c3303b4386c 100644
--- a/tests/baselines/reference/generatorTypeCheck55.types
+++ b/tests/baselines/reference/generatorTypeCheck55.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck55.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     var x = class C extends (yield) {};
 >x : typeof C
diff --git a/tests/baselines/reference/generatorTypeCheck56.types b/tests/baselines/reference/generatorTypeCheck56.types
index 718e5d0d79289..6f05396a1f106 100644
--- a/tests/baselines/reference/generatorTypeCheck56.types
+++ b/tests/baselines/reference/generatorTypeCheck56.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck56.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     var x = class C {
 >x : typeof C
@@ -8,7 +8,7 @@ function* g() {
 >C : typeof C
 
         *[yield 0]() {
->[yield 0] : () => IterableIterator<number>
+>[yield 0] : () => Generator<number, void, unknown>
 >yield 0 : any
 >0 : 0
 
diff --git a/tests/baselines/reference/generatorTypeCheck57.types b/tests/baselines/reference/generatorTypeCheck57.types
index b852efe62f442..9e660521dfba4 100644
--- a/tests/baselines/reference/generatorTypeCheck57.types
+++ b/tests/baselines/reference/generatorTypeCheck57.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck57.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     class C {
 >C : C
diff --git a/tests/baselines/reference/generatorTypeCheck58.types b/tests/baselines/reference/generatorTypeCheck58.types
index a04691cb4ba73..69d1723be9661 100644
--- a/tests/baselines/reference/generatorTypeCheck58.types
+++ b/tests/baselines/reference/generatorTypeCheck58.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck58.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     class C {
 >C : C
diff --git a/tests/baselines/reference/generatorTypeCheck59.types b/tests/baselines/reference/generatorTypeCheck59.types
index 35b9b7e66f16c..d04b829fba8e9 100644
--- a/tests/baselines/reference/generatorTypeCheck59.types
+++ b/tests/baselines/reference/generatorTypeCheck59.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck59.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     class C {
 >C : C
diff --git a/tests/baselines/reference/generatorTypeCheck6.errors.txt b/tests/baselines/reference/generatorTypeCheck6.errors.txt
index 35f2cc2016dbc..a9eca26ca4f65 100644
--- a/tests/baselines/reference/generatorTypeCheck6.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck6.errors.txt
@@ -1,7 +1,7 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts(1,17): error TS2322: Type 'IterableIterator<any>' is not assignable to type 'number'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts(1,17): error TS2322: Type 'Generator<any, any, any>' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck6.ts (1 errors) ====
     function* g1(): number { }
                     ~~~~~~
-!!! error TS2322: Type 'IterableIterator<any>' is not assignable to type 'number'.
\ No newline at end of file
+!!! error TS2322: Type 'Generator<any, any, any>' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck60.types b/tests/baselines/reference/generatorTypeCheck60.types
index 9073f604be6fb..b10101b6f41d6 100644
--- a/tests/baselines/reference/generatorTypeCheck60.types
+++ b/tests/baselines/reference/generatorTypeCheck60.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts ===
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     class C extends (yield) {};
 >C : C
diff --git a/tests/baselines/reference/generatorTypeCheck61.types b/tests/baselines/reference/generatorTypeCheck61.types
index a8093e1bbe116..91874ffa58dfb 100644
--- a/tests/baselines/reference/generatorTypeCheck61.types
+++ b/tests/baselines/reference/generatorTypeCheck61.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck61.ts ===
 function * g() {
->g : () => IterableIterator<any>
+>g : () => Generator<never, void, unknown>
 
     @(yield 0)
 >(yield 0) : any
diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types
index 90d34fa8513f7..be5635a07fc66 100644
--- a/tests/baselines/reference/generatorTypeCheck62.types
+++ b/tests/baselines/reference/generatorTypeCheck62.types
@@ -12,7 +12,7 @@ export function strategy<T extends StrategicState>(stratName: string, gen: (a: T
 >a : T
 
     return function*(state) {
->function*(state) {        for (const next of gen(state)) {            if (next) {                next.lastStrategyApplied = stratName;            }            yield next;        }    } : (state: T) => IterableIterator<T>
+>function*(state) {        for (const next of gen(state)) {            if (next) {                next.lastStrategyApplied = stratName;            }            yield next;        }    } : (state: T) => Generator<T, void, unknown>
 >state : T
 
         for (const next of gen(state)) {
@@ -53,7 +53,7 @@ export const Nothing1: Strategy<State> = strategy("Nothing", function*(state: St
 >strategy("Nothing", function*(state: State) {    return state;}) : (a: State) => IterableIterator<State>
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function*(state: State) {    return state;} : (state: State) => IterableIterator<State>
+>function*(state: State) {    return state;} : (state: State) => Generator<never, State, unknown>
 >state : State
 
     return state;
@@ -66,7 +66,7 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: St
 >strategy("Nothing", function*(state: State) {    yield state;}) : (a: State) => IterableIterator<State>
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function*(state: State) {    yield state;} : (state: State) => IterableIterator<State>
+>function*(state: State) {    yield state;} : (state: State) => Generator<State, void, unknown>
 >state : State
 
     yield state;
@@ -77,10 +77,10 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function*(state: St
 
 export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing3 : Strategy<State>
->strategy("Nothing", function* (state: State) {    yield ;    return state;}) : (a: State) => IterableIterator<State>
+>strategy("Nothing", function* (state: State) {    yield ;    return state;}) : (a: any) => IterableIterator<any>
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function* (state: State) {    yield ;    return state;} : (state: State) => IterableIterator<State>
+>function* (state: State) {    yield ;    return state;} : (state: State) => Generator<any, State, unknown>
 >state : State
 
     yield ;
diff --git a/tests/baselines/reference/generatorTypeCheck63.errors.txt b/tests/baselines/reference/generatorTypeCheck63.errors.txt
index 2a1935fd90633..f77488edc4d2d 100644
--- a/tests/baselines/reference/generatorTypeCheck63.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck63.errors.txt
@@ -1,16 +1,14 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) => IterableIterator<State | 1>' is not assignable to parameter of type '(a: StrategicState) => IterableIterator<StrategicState>'.
-  Type 'IterableIterator<State | 1>' is not assignable to type 'IterableIterator<StrategicState>'.
-    Type 'State | 1' is not assignable to type 'StrategicState'.
-      Type '1' has no properties in common with type 'StrategicState'.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(29,70): error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(32,62): error TS2345: Argument of type '(state: State) => IterableIterator<number>' is not assignable to parameter of type '(a: State) => IterableIterator<State>'.
-  Type 'IterableIterator<number>' is not assignable to type 'IterableIterator<State>'.
-    Type 'number' is not assignable to type 'State'.
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(36,62): error TS2345: Argument of type '(state: State) => IterableIterator<State | 1>' is not assignable to parameter of type '(a: StrategicState) => IterableIterator<StrategicState>'.
-  Type 'IterableIterator<State | 1>' is not assignable to type 'IterableIterator<StrategicState>'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(24,61): error TS2345: Argument of type '(state: State) => Generator<number, State, unknown>' is not assignable to parameter of type '(a: State) => IterableIterator<State>'.
+  Type 'Generator<number, State, unknown>' is not assignable to type 'IterableIterator<State>'.
+    Types of property 'next' are incompatible.
+      Type '(...args: [] | [unknown]) => IteratorResult<number, State>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<State, any>'.
+        Type 'IteratorResult<number, State>' is not assignable to type 'IteratorResult<State, any>'.
+          Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<State, any>'.
+            Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<State>'.
+              Type 'number' is not assignable to type 'State'.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts (4 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts (1 errors) ====
     export interface StrategicState {
         lastStrategyApplied?: string;
     }
@@ -36,31 +34,26 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck63.ts(36,62): err
     
     export const Nothing: Strategy<State> = strategy("Nothing", function* (state: State) {
                                                                 ~~~~~~~~
-!!! error TS2345: Argument of type '(state: State) => IterableIterator<State | 1>' is not assignable to parameter of type '(a: StrategicState) => IterableIterator<StrategicState>'.
-!!! error TS2345:   Type 'IterableIterator<State | 1>' is not assignable to type 'IterableIterator<StrategicState>'.
-!!! error TS2345:     Type 'State | 1' is not assignable to type 'StrategicState'.
-!!! error TS2345:       Type '1' has no properties in common with type 'StrategicState'.
+!!! error TS2345: Argument of type '(state: State) => Generator<number, State, unknown>' is not assignable to parameter of type '(a: State) => IterableIterator<State>'.
+!!! error TS2345:   Type 'Generator<number, State, unknown>' is not assignable to type 'IterableIterator<State>'.
+!!! error TS2345:     Types of property 'next' are incompatible.
+!!! error TS2345:       Type '(...args: [] | [unknown]) => IteratorResult<number, State>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<State, any>'.
+!!! error TS2345:         Type 'IteratorResult<number, State>' is not assignable to type 'IteratorResult<State, any>'.
+!!! error TS2345:           Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorResult<State, any>'.
+!!! error TS2345:             Type 'IteratorYieldResult<number>' is not assignable to type 'IteratorYieldResult<State>'.
+!!! error TS2345:               Type 'number' is not assignable to type 'State'.
         yield 1;
         return state;
     });
     
     export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: State) {
-                                                                         ~
-!!! error TS7025: Generator implicitly has type 'IterableIterator<any>' because it does not yield any values. Consider supplying a return type.
     });
     
     export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: State) {
-                                                                 ~~~~~~~~
-!!! error TS2345: Argument of type '(state: State) => IterableIterator<number>' is not assignable to parameter of type '(a: State) => IterableIterator<State>'.
-!!! error TS2345:   Type 'IterableIterator<number>' is not assignable to type 'IterableIterator<State>'.
-!!! error TS2345:     Type 'number' is not assignable to type 'State'.
         return 1;
     });
     
     export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
-                                                                 ~~~~~~~~
-!!! error TS2345: Argument of type '(state: State) => IterableIterator<State | 1>' is not assignable to parameter of type '(a: StrategicState) => IterableIterator<StrategicState>'.
-!!! error TS2345:   Type 'IterableIterator<State | 1>' is not assignable to type 'IterableIterator<StrategicState>'.
         yield state;
         return 1;
     });
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck63.types b/tests/baselines/reference/generatorTypeCheck63.types
index 67f9717162df8..8a1d03dcb164c 100644
--- a/tests/baselines/reference/generatorTypeCheck63.types
+++ b/tests/baselines/reference/generatorTypeCheck63.types
@@ -12,7 +12,7 @@ export function strategy<T extends StrategicState>(stratName: string, gen: (a: T
 >a : T
 
     return function*(state) {
->function*(state) {        for (const next of gen(state)) {            if (next) {                next.lastStrategyApplied = stratName;            }            yield next;        }    } : (state: T) => IterableIterator<T>
+>function*(state) {        for (const next of gen(state)) {            if (next) {                next.lastStrategyApplied = stratName;            }            yield next;        }    } : (state: T) => Generator<T, void, unknown>
 >state : T
 
         for (const next of gen(state)) {
@@ -53,7 +53,7 @@ export const Nothing: Strategy<State> = strategy("Nothing", function* (state: St
 >strategy("Nothing", function* (state: State) {    yield 1;    return state;}) : any
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function* (state: State) {    yield 1;    return state;} : (state: State) => IterableIterator<State | 1>
+>function* (state: State) {    yield 1;    return state;} : (state: State) => Generator<number, State, unknown>
 >state : State
 
     yield 1;
@@ -67,20 +67,20 @@ export const Nothing: Strategy<State> = strategy("Nothing", function* (state: St
 
 export const Nothing1: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing1 : Strategy<State>
->strategy("Nothing", function* (state: State) {}) : (a: any) => IterableIterator<any>
+>strategy("Nothing", function* (state: State) {}) : (a: State) => IterableIterator<State>
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function* (state: State) {} : (state: State) => IterableIterator<any>
+>function* (state: State) {} : (state: State) => Generator<never, void, unknown>
 >state : State
 
 });
 
 export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing2 : Strategy<State>
->strategy("Nothing", function* (state: State) {    return 1;}) : any
+>strategy("Nothing", function* (state: State) {    return 1;}) : (a: State) => IterableIterator<State>
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function* (state: State) {    return 1;} : (state: State) => IterableIterator<number>
+>function* (state: State) {    return 1;} : (state: State) => Generator<never, number, unknown>
 >state : State
 
     return 1;
@@ -90,10 +90,10 @@ export const Nothing2: Strategy<State> = strategy("Nothing", function* (state: S
 
 export const Nothing3: Strategy<State> = strategy("Nothing", function* (state: State) {
 >Nothing3 : Strategy<State>
->strategy("Nothing", function* (state: State) {    yield state;    return 1;}) : any
+>strategy("Nothing", function* (state: State) {    yield state;    return 1;}) : (a: State) => IterableIterator<State>
 >strategy : <T extends StrategicState>(stratName: string, gen: (a: T) => IterableIterator<T>) => (a: T) => IterableIterator<T>
 >"Nothing" : "Nothing"
->function* (state: State) {    yield state;    return 1;} : (state: State) => IterableIterator<State | 1>
+>function* (state: State) {    yield state;    return 1;} : (state: State) => Generator<State, number, unknown>
 >state : State
 
     yield state;
diff --git a/tests/baselines/reference/generatorTypeCheck7.errors.txt b/tests/baselines/reference/generatorTypeCheck7.errors.txt
index 96e226fe827be..fb17027bf3b14 100644
--- a/tests/baselines/reference/generatorTypeCheck7.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck7.errors.txt
@@ -1,4 +1,4 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts(4,17): error TS2741: Property 'hello' is missing in type 'IterableIterator<number>' but required in type 'WeirdIter'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts(4,17): error TS2741: Property 'hello' is missing in type 'Generator<number, any, undefined>' but required in type 'WeirdIter'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts (1 errors) ====
@@ -7,5 +7,5 @@ tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts(4,17): error
     }
     function* g1(): WeirdIter { }
                     ~~~~~~~~~
-!!! error TS2741: Property 'hello' is missing in type 'IterableIterator<number>' but required in type 'WeirdIter'.
+!!! error TS2741: Property 'hello' is missing in type 'Generator<number, any, undefined>' but required in type 'WeirdIter'.
 !!! related TS2728 tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck7.ts:2:5: 'hello' is declared here.
\ No newline at end of file
diff --git a/tests/baselines/reference/generatorTypeCheck8.errors.txt b/tests/baselines/reference/generatorTypeCheck8.errors.txt
index cedfecda60b94..6261d419dddd8 100644
--- a/tests/baselines/reference/generatorTypeCheck8.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck8.errors.txt
@@ -1,16 +1,20 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts(2,17): error TS2322: Type 'IterableIterator<string>' is not assignable to type 'BadGenerator'.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts(2,17): error TS2322: Type 'Generator<string, any, undefined>' is not assignable to type 'BadGenerator'.
   Types of property 'next' are incompatible.
-    Type '(value?: any) => IteratorResult<string>' is not assignable to type '(value?: any) => IteratorResult<number>'.
-      Type 'IteratorResult<string>' is not assignable to type 'IteratorResult<number>'.
-        Type 'string' is not assignable to type 'number'.
+    Type '(...args: [] | [undefined]) => IteratorResult<string, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
+      Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
+        Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+          Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+            Type 'string' is not assignable to type 'number'.
 
 
 ==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck8.ts (1 errors) ====
     interface BadGenerator extends Iterator<number>, Iterable<string> { }
     function* g3(): BadGenerator { }
                     ~~~~~~~~~~~~
-!!! error TS2322: Type 'IterableIterator<string>' is not assignable to type 'BadGenerator'.
+!!! error TS2322: Type 'Generator<string, any, undefined>' is not assignable to type 'BadGenerator'.
 !!! error TS2322:   Types of property 'next' are incompatible.
-!!! error TS2322:     Type '(value?: any) => IteratorResult<string>' is not assignable to type '(value?: any) => IteratorResult<number>'.
-!!! error TS2322:       Type 'IteratorResult<string>' is not assignable to type 'IteratorResult<number>'.
-!!! error TS2322:         Type 'string' is not assignable to type 'number'.
\ No newline at end of file
+!!! error TS2322:     Type '(...args: [] | [undefined]) => IteratorResult<string, any>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
+!!! error TS2322:       Type 'IteratorResult<string, any>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:         Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:           Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+!!! error TS2322:             Type 'string' is not assignable to type 'number'.
\ No newline at end of file
diff --git a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
index f932f2c339da8..b5f526adc8e89 100644
--- a/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
+++ b/tests/baselines/reference/importCallExpressionReturnPromiseOfAny.types
@@ -93,7 +93,7 @@ var p3: Promise<typeof defaultModule> = import(j=getSpecifier());
 >getSpecifier : () => string
 
 function * loadModule(directories: string[]) {
->loadModule : (directories: string[]) => IterableIterator<string>
+>loadModule : (directories: string[]) => Generator<string, void, string>
 >directories : string[]
 
     for (const directory of directories) {
diff --git a/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types b/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types
index cb646e5a15e17..da4e9fb704dde 100644
--- a/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types
+++ b/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/main.ts ===
 export async function * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, undefined>
 
     await 1;
 >await 1 : 1
diff --git a/tests/baselines/reference/iteratorSpreadInArray9.errors.txt b/tests/baselines/reference/iteratorSpreadInArray9.errors.txt
deleted file mode 100644
index b1278354ba2d8..0000000000000
--- a/tests/baselines/reference/iteratorSpreadInArray9.errors.txt
+++ /dev/null
@@ -1,32 +0,0 @@
-tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts(13,17): error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterable<symbol>'.
-  Types of property '[Symbol.iterator]' are incompatible.
-    Type '() => SymbolIterator' is not assignable to type '() => Iterator<symbol>'.
-      Type 'SymbolIterator' is not assignable to type 'Iterator<symbol>'.
-        Types of property 'next' are incompatible.
-          Type '() => { value: symbol; }' is not assignable to type '(value?: any) => IteratorResult<symbol>'.
-            Property 'done' is missing in type '{ value: symbol; }' but required in type 'IteratorResult<symbol>'.
-
-
-==== tests/cases/conformance/es6/spread/iteratorSpreadInArray9.ts (1 errors) ====
-    class SymbolIterator {
-        next() {
-            return {
-                value: Symbol()
-            };
-        }
-    
-        [Symbol.iterator]() {
-            return this;
-        }
-    }
-    
-    var array = [...new SymbolIterator];
-                    ~~~~~~~~~~~~~~~~~~
-!!! error TS2322: Type 'SymbolIterator' is not assignable to type 'Iterable<symbol>'.
-!!! error TS2322:   Types of property '[Symbol.iterator]' are incompatible.
-!!! error TS2322:     Type '() => SymbolIterator' is not assignable to type '() => Iterator<symbol>'.
-!!! error TS2322:       Type 'SymbolIterator' is not assignable to type 'Iterator<symbol>'.
-!!! error TS2322:         Types of property 'next' are incompatible.
-!!! error TS2322:           Type '() => { value: symbol; }' is not assignable to type '(value?: any) => IteratorResult<symbol>'.
-!!! error TS2322:             Property 'done' is missing in type '{ value: symbol; }' but required in type 'IteratorResult<symbol>'.
-!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:32:5: 'done' is declared here.
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.js b/tests/baselines/reference/iteratorSpreadInCall12.js
index ba8149e29d60c..10f1a7cf0c7cc 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.js
+++ b/tests/baselines/reference/iteratorSpreadInCall12.js
@@ -16,7 +16,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -29,7 +29,7 @@ class StringIterator {
     }
 }
 
-new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+new Foo(...[...new SymbolIterator, ...[...new _StringIterator]]);
 
 //// [iteratorSpreadInCall12.js]
 class Foo {
@@ -46,7 +46,7 @@ class SymbolIterator {
         return this;
     }
 }
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -57,4 +57,4 @@ class StringIterator {
         return this;
     }
 }
-new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+new Foo(...[...new SymbolIterator, ...[...new _StringIterator]]);
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols
index 935f37bef2af0..99b4c3a1f3271 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols
@@ -36,11 +36,11 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
+class _StringIterator {
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
 
     next() {
->next : Symbol(StringIterator.next, Decl(iteratorSpreadInCall12.ts, 17, 22))
+>next : Symbol(_StringIterator.next, Decl(iteratorSpreadInCall12.ts, 17, 23))
 
         return {
             value: "",
@@ -53,18 +53,18 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall12.ts, 23, 5))
+>[Symbol.iterator] : Symbol(_StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall12.ts, 23, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 
         return this;
->this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
+>this : Symbol(_StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
     }
 }
 
-new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
+new Foo(...[...new SymbolIterator, ...[...new _StringIterator]]);
 >Foo : Symbol(Foo, Decl(iteratorSpreadInCall12.ts, 0, 0))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 2, 1))
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall12.ts, 15, 1))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.types b/tests/baselines/reference/iteratorSpreadInCall12.types
index 5e3d2f722369e..5f0f0a34ccec6 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.types
+++ b/tests/baselines/reference/iteratorSpreadInCall12.types
@@ -38,8 +38,8 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : StringIterator
+class _StringIterator {
+>_StringIterator : _StringIterator
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -69,17 +69,17 @@ class StringIterator {
     }
 }
 
-new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
->new Foo(...[...new SymbolIterator, ...[...new StringIterator]]) : Foo<string | symbol>
+new Foo(...[...new SymbolIterator, ...[...new _StringIterator]]);
+>new Foo(...[...new SymbolIterator, ...[...new _StringIterator]]) : Foo<string | symbol>
 >Foo : typeof Foo
->...[...new SymbolIterator, ...[...new StringIterator]] : string | symbol
->[...new SymbolIterator, ...[...new StringIterator]] : (string | symbol)[]
+>...[...new SymbolIterator, ...[...new _StringIterator]] : string | symbol
+>[...new SymbolIterator, ...[...new _StringIterator]] : (string | symbol)[]
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
 >SymbolIterator : typeof SymbolIterator
->...[...new StringIterator] : string
->[...new StringIterator] : string[]
->...new StringIterator : string
->new StringIterator : StringIterator
->StringIterator : typeof StringIterator
+>...[...new _StringIterator] : string
+>[...new _StringIterator] : string[]
+>...new _StringIterator : string
+>new _StringIterator : _StringIterator
+>_StringIterator : typeof _StringIterator
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.js b/tests/baselines/reference/iteratorSpreadInCall5.js
index b17054363ed33..b6c3a5c2cfd8b 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.js
+++ b/tests/baselines/reference/iteratorSpreadInCall5.js
@@ -13,7 +13,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -26,7 +26,7 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
 
 //// [iteratorSpreadInCall5.js]
 function foo(...s) { }
@@ -41,7 +41,7 @@ class SymbolIterator {
         return this;
     }
 }
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -52,4 +52,4 @@ class StringIterator {
         return this;
     }
 }
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols
index f3be9a2855736..a4d55eaf8cea7 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols
@@ -31,11 +31,11 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
+class _StringIterator {
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
 
     next() {
->next : Symbol(StringIterator.next, Decl(iteratorSpreadInCall5.ts, 14, 22))
+>next : Symbol(_StringIterator.next, Decl(iteratorSpreadInCall5.ts, 14, 23))
 
         return {
             value: "",
@@ -48,18 +48,18 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall5.ts, 20, 5))
+>[Symbol.iterator] : Symbol(_StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall5.ts, 20, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 
         return this;
->this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
+>this : Symbol(_StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
 >foo : Symbol(foo, Decl(iteratorSpreadInCall5.ts, 0, 0))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 0, 43))
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall5.ts, 12, 1))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.types b/tests/baselines/reference/iteratorSpreadInCall5.types
index 5d70581cacb8c..6120f036645f9 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.types
+++ b/tests/baselines/reference/iteratorSpreadInCall5.types
@@ -35,8 +35,8 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : StringIterator
+class _StringIterator {
+>_StringIterator : _StringIterator
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -66,13 +66,13 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
->foo(...new SymbolIterator, ...new StringIterator) : void
+foo(...new SymbolIterator, ...new _StringIterator);
+>foo(...new SymbolIterator, ...new _StringIterator) : void
 >foo : (...s: (string | symbol)[]) => void
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
 >SymbolIterator : typeof SymbolIterator
->...new StringIterator : string
->new StringIterator : StringIterator
->StringIterator : typeof StringIterator
+>...new _StringIterator : string
+>new _StringIterator : _StringIterator
+>_StringIterator : typeof _StringIterator
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.errors.txt b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt
index 2c89c7bb493cc..9a25e387be8e3 100644
--- a/tests/baselines/reference/iteratorSpreadInCall6.errors.txt
+++ b/tests/baselines/reference/iteratorSpreadInCall6.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts(28,28): error TS2345
         }
     }
     
-    class StringIterator {
+    class _StringIterator {
         next() {
             return {
                 value: "",
@@ -29,6 +29,6 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts(28,28): error TS2345
         }
     }
     
-    foo(...new SymbolIterator, ...new StringIterator);
-                               ~~~~~~~~~~~~~~~~~~~~~
+    foo(...new SymbolIterator, ...new _StringIterator);
+                               ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'number | symbol'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.js b/tests/baselines/reference/iteratorSpreadInCall6.js
index 161f420ce0ec3..cf24c0cddfe6b 100644
--- a/tests/baselines/reference/iteratorSpreadInCall6.js
+++ b/tests/baselines/reference/iteratorSpreadInCall6.js
@@ -13,7 +13,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -26,7 +26,7 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
 
 //// [iteratorSpreadInCall6.js]
 function foo(...s) { }
@@ -41,7 +41,7 @@ class SymbolIterator {
         return this;
     }
 }
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -52,4 +52,4 @@ class StringIterator {
         return this;
     }
 }
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.symbols b/tests/baselines/reference/iteratorSpreadInCall6.symbols
index 7eff762853480..b6c02dc570eb5 100644
--- a/tests/baselines/reference/iteratorSpreadInCall6.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall6.symbols
@@ -31,11 +31,11 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
+class _StringIterator {
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
 
     next() {
->next : Symbol(StringIterator.next, Decl(iteratorSpreadInCall6.ts, 14, 22))
+>next : Symbol(_StringIterator.next, Decl(iteratorSpreadInCall6.ts, 14, 23))
 
         return {
             value: "",
@@ -48,18 +48,18 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall6.ts, 20, 5))
+>[Symbol.iterator] : Symbol(_StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall6.ts, 20, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 
         return this;
->this : Symbol(StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
+>this : Symbol(_StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
 >foo : Symbol(foo, Decl(iteratorSpreadInCall6.ts, 0, 0))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInCall6.ts, 0, 43))
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall6.ts, 12, 1))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall6.types b/tests/baselines/reference/iteratorSpreadInCall6.types
index 6a040d25e6d15..619946030574c 100644
--- a/tests/baselines/reference/iteratorSpreadInCall6.types
+++ b/tests/baselines/reference/iteratorSpreadInCall6.types
@@ -35,8 +35,8 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : StringIterator
+class _StringIterator {
+>_StringIterator : _StringIterator
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -66,13 +66,13 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
->foo(...new SymbolIterator, ...new StringIterator) : void
+foo(...new SymbolIterator, ...new _StringIterator);
+>foo(...new SymbolIterator, ...new _StringIterator) : void
 >foo : (...s: (number | symbol)[]) => void
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
 >SymbolIterator : typeof SymbolIterator
->...new StringIterator : string
->new StringIterator : StringIterator
->StringIterator : typeof StringIterator
+>...new _StringIterator : string
+>new _StringIterator : _StringIterator
+>_StringIterator : typeof _StringIterator
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.errors.txt b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt
index 5494d1e7070c6..2cb302849ccd6 100644
--- a/tests/baselines/reference/iteratorSpreadInCall7.errors.txt
+++ b/tests/baselines/reference/iteratorSpreadInCall7.errors.txt
@@ -16,7 +16,7 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts(28,28): error TS2345
         }
     }
     
-    class StringIterator {
+    class _StringIterator {
         next() {
             return {
                 value: "",
@@ -29,6 +29,6 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts(28,28): error TS2345
         }
     }
     
-    foo(...new SymbolIterator, ...new StringIterator);
-                               ~~~~~~~~~~~~~~~~~~~~~
+    foo(...new SymbolIterator, ...new _StringIterator);
+                               ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'symbol'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.js b/tests/baselines/reference/iteratorSpreadInCall7.js
index e7c354413dfcc..81fceda02a593 100644
--- a/tests/baselines/reference/iteratorSpreadInCall7.js
+++ b/tests/baselines/reference/iteratorSpreadInCall7.js
@@ -13,7 +13,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -26,7 +26,7 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
 
 //// [iteratorSpreadInCall7.js]
 function foo(...s) { return s[0]; }
@@ -41,7 +41,7 @@ class SymbolIterator {
         return this;
     }
 }
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -52,4 +52,4 @@ class StringIterator {
         return this;
     }
 }
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.symbols b/tests/baselines/reference/iteratorSpreadInCall7.symbols
index 98c93f98b6485..2c8e523dc4aea 100644
--- a/tests/baselines/reference/iteratorSpreadInCall7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall7.symbols
@@ -34,11 +34,11 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
+class _StringIterator {
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
 
     next() {
->next : Symbol(StringIterator.next, Decl(iteratorSpreadInCall7.ts, 14, 22))
+>next : Symbol(_StringIterator.next, Decl(iteratorSpreadInCall7.ts, 14, 23))
 
         return {
             value: "",
@@ -51,18 +51,18 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall7.ts, 20, 5))
+>[Symbol.iterator] : Symbol(_StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall7.ts, 20, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 
         return this;
->this : Symbol(StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
+>this : Symbol(_StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
+foo(...new SymbolIterator, ...new _StringIterator);
 >foo : Symbol(foo, Decl(iteratorSpreadInCall7.ts, 0, 0))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInCall7.ts, 0, 43))
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall7.ts, 12, 1))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall7.types b/tests/baselines/reference/iteratorSpreadInCall7.types
index 2f6f0ff06dbc8..d8f820ca804ad 100644
--- a/tests/baselines/reference/iteratorSpreadInCall7.types
+++ b/tests/baselines/reference/iteratorSpreadInCall7.types
@@ -38,8 +38,8 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : StringIterator
+class _StringIterator {
+>_StringIterator : _StringIterator
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -69,13 +69,13 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
->foo(...new SymbolIterator, ...new StringIterator) : any
+foo(...new SymbolIterator, ...new _StringIterator);
+>foo(...new SymbolIterator, ...new _StringIterator) : any
 >foo : <T>(...s: T[]) => T
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
 >SymbolIterator : typeof SymbolIterator
->...new StringIterator : string
->new StringIterator : StringIterator
->StringIterator : typeof StringIterator
+>...new _StringIterator : string
+>new _StringIterator : _StringIterator
+>_StringIterator : typeof _StringIterator
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.errors.txt b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt
index 73dc6d5185ebc..03a67c4e0e158 100644
--- a/tests/baselines/reference/iteratorSpreadInCall8.errors.txt
+++ b/tests/baselines/reference/iteratorSpreadInCall8.errors.txt
@@ -19,7 +19,7 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts(31,32): error TS2345
         }
     }
     
-    class StringIterator {
+    class _StringIterator {
         next() {
             return {
                 value: "",
@@ -32,6 +32,6 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts(31,32): error TS2345
         }
     }
     
-    new Foo(...new SymbolIterator, ...new StringIterator);
-                                   ~~~~~~~~~~~~~~~~~~~~~
+    new Foo(...new SymbolIterator, ...new _StringIterator);
+                                   ~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'symbol'.
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.js b/tests/baselines/reference/iteratorSpreadInCall8.js
index a591fd363ab0d..7eb5cca25d21d 100644
--- a/tests/baselines/reference/iteratorSpreadInCall8.js
+++ b/tests/baselines/reference/iteratorSpreadInCall8.js
@@ -16,7 +16,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -29,7 +29,7 @@ class StringIterator {
     }
 }
 
-new Foo(...new SymbolIterator, ...new StringIterator);
+new Foo(...new SymbolIterator, ...new _StringIterator);
 
 //// [iteratorSpreadInCall8.js]
 class Foo {
@@ -46,7 +46,7 @@ class SymbolIterator {
         return this;
     }
 }
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -57,4 +57,4 @@ class StringIterator {
         return this;
     }
 }
-new Foo(...new SymbolIterator, ...new StringIterator);
+new Foo(...new SymbolIterator, ...new _StringIterator);
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.symbols b/tests/baselines/reference/iteratorSpreadInCall8.symbols
index 7c547419d1730..51b7542c22baf 100644
--- a/tests/baselines/reference/iteratorSpreadInCall8.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall8.symbols
@@ -36,11 +36,11 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
+class _StringIterator {
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
 
     next() {
->next : Symbol(StringIterator.next, Decl(iteratorSpreadInCall8.ts, 17, 22))
+>next : Symbol(_StringIterator.next, Decl(iteratorSpreadInCall8.ts, 17, 23))
 
         return {
             value: "",
@@ -53,18 +53,18 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall8.ts, 23, 5))
+>[Symbol.iterator] : Symbol(_StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall8.ts, 23, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 
         return this;
->this : Symbol(StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
+>this : Symbol(_StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
     }
 }
 
-new Foo(...new SymbolIterator, ...new StringIterator);
+new Foo(...new SymbolIterator, ...new _StringIterator);
 >Foo : Symbol(Foo, Decl(iteratorSpreadInCall8.ts, 0, 0))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInCall8.ts, 2, 1))
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall8.ts, 15, 1))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall8.types b/tests/baselines/reference/iteratorSpreadInCall8.types
index 58f3ea70809ee..c124a5e8dd7d8 100644
--- a/tests/baselines/reference/iteratorSpreadInCall8.types
+++ b/tests/baselines/reference/iteratorSpreadInCall8.types
@@ -38,8 +38,8 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : StringIterator
+class _StringIterator {
+>_StringIterator : _StringIterator
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -69,13 +69,13 @@ class StringIterator {
     }
 }
 
-new Foo(...new SymbolIterator, ...new StringIterator);
->new Foo(...new SymbolIterator, ...new StringIterator) : any
+new Foo(...new SymbolIterator, ...new _StringIterator);
+>new Foo(...new SymbolIterator, ...new _StringIterator) : any
 >Foo : typeof Foo
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
 >SymbolIterator : typeof SymbolIterator
->...new StringIterator : string
->new StringIterator : StringIterator
->StringIterator : typeof StringIterator
+>...new _StringIterator : string
+>new _StringIterator : _StringIterator
+>_StringIterator : typeof _StringIterator
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.errors.txt b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt
index 773eb2a9fc84f..42fd65c1ce795 100644
--- a/tests/baselines/reference/iteratorSpreadInCall9.errors.txt
+++ b/tests/baselines/reference/iteratorSpreadInCall9.errors.txt
@@ -19,7 +19,7 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts(31,32): error TS2345
         }
     }
     
-    class StringIterator {
+    class _StringIterator {
         next() {
             return {
                 value: "",
@@ -32,7 +32,7 @@ tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts(31,32): error TS2345
         }
     }
     
-    new Foo(...new SymbolIterator, ...[...new StringIterator]);
-                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    new Foo(...new SymbolIterator, ...[...new _StringIterator]);
+                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2345: Argument of type 'string' is not assignable to parameter of type 'symbol'.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.js b/tests/baselines/reference/iteratorSpreadInCall9.js
index 3f54728fd8898..a29f1ec76d243 100644
--- a/tests/baselines/reference/iteratorSpreadInCall9.js
+++ b/tests/baselines/reference/iteratorSpreadInCall9.js
@@ -16,7 +16,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -29,7 +29,7 @@ class StringIterator {
     }
 }
 
-new Foo(...new SymbolIterator, ...[...new StringIterator]);
+new Foo(...new SymbolIterator, ...[...new _StringIterator]);
 
 
 //// [iteratorSpreadInCall9.js]
@@ -47,7 +47,7 @@ class SymbolIterator {
         return this;
     }
 }
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -58,4 +58,4 @@ class StringIterator {
         return this;
     }
 }
-new Foo(...new SymbolIterator, ...[...new StringIterator]);
+new Foo(...new SymbolIterator, ...[...new _StringIterator]);
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.symbols b/tests/baselines/reference/iteratorSpreadInCall9.symbols
index 5db65829f1380..79e6515e09578 100644
--- a/tests/baselines/reference/iteratorSpreadInCall9.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall9.symbols
@@ -36,11 +36,11 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
+class _StringIterator {
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
 
     next() {
->next : Symbol(StringIterator.next, Decl(iteratorSpreadInCall9.ts, 17, 22))
+>next : Symbol(_StringIterator.next, Decl(iteratorSpreadInCall9.ts, 17, 23))
 
         return {
             value: "",
@@ -53,18 +53,18 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall9.ts, 23, 5))
+>[Symbol.iterator] : Symbol(_StringIterator[Symbol.iterator], Decl(iteratorSpreadInCall9.ts, 23, 5))
 >Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
 
         return this;
->this : Symbol(StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
+>this : Symbol(_StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
     }
 }
 
-new Foo(...new SymbolIterator, ...[...new StringIterator]);
+new Foo(...new SymbolIterator, ...[...new _StringIterator]);
 >Foo : Symbol(Foo, Decl(iteratorSpreadInCall9.ts, 0, 0))
 >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInCall9.ts, 2, 1))
->StringIterator : Symbol(StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
+>_StringIterator : Symbol(_StringIterator, Decl(iteratorSpreadInCall9.ts, 15, 1))
 
diff --git a/tests/baselines/reference/iteratorSpreadInCall9.types b/tests/baselines/reference/iteratorSpreadInCall9.types
index 1118a394bc4e8..2cc33ea3fddb5 100644
--- a/tests/baselines/reference/iteratorSpreadInCall9.types
+++ b/tests/baselines/reference/iteratorSpreadInCall9.types
@@ -38,8 +38,8 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
->StringIterator : StringIterator
+class _StringIterator {
+>_StringIterator : _StringIterator
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -69,15 +69,15 @@ class StringIterator {
     }
 }
 
-new Foo(...new SymbolIterator, ...[...new StringIterator]);
->new Foo(...new SymbolIterator, ...[...new StringIterator]) : any
+new Foo(...new SymbolIterator, ...[...new _StringIterator]);
+>new Foo(...new SymbolIterator, ...[...new _StringIterator]) : any
 >Foo : typeof Foo
 >...new SymbolIterator : symbol
 >new SymbolIterator : SymbolIterator
 >SymbolIterator : typeof SymbolIterator
->...[...new StringIterator] : string
->[...new StringIterator] : string[]
->...new StringIterator : string
->new StringIterator : StringIterator
->StringIterator : typeof StringIterator
+>...[...new _StringIterator] : string
+>[...new _StringIterator] : string[]
+>...new _StringIterator : string
+>new _StringIterator : _StringIterator
+>_StringIterator : typeof _StringIterator
 
diff --git a/tests/baselines/reference/labeledStatementWithLabel.types b/tests/baselines/reference/labeledStatementWithLabel.types
index 52ca74ddf1973..e5633ab12f356 100644
--- a/tests/baselines/reference/labeledStatementWithLabel.types
+++ b/tests/baselines/reference/labeledStatementWithLabel.types
@@ -5,7 +5,7 @@ label: function fn() { }
 
 label: function* gen() { }
 >label : any
->gen : () => IterableIterator<any>
+>gen : () => Generator<never, void, unknown>
 
 label: async function gen1() { }
 >label : any
diff --git a/tests/baselines/reference/labeledStatementWithLabel_es2015.types b/tests/baselines/reference/labeledStatementWithLabel_es2015.types
index 570c3c4ad6d03..016ab09107cfb 100644
--- a/tests/baselines/reference/labeledStatementWithLabel_es2015.types
+++ b/tests/baselines/reference/labeledStatementWithLabel_es2015.types
@@ -5,7 +5,7 @@ label: function fn() { }
 
 label: function* gen() { }
 >label : any
->gen : () => IterableIterator<any>
+>gen : () => Generator<never, void, unknown>
 
 label: async function gen1() { }
 >label : any
diff --git a/tests/baselines/reference/labeledStatementWithLabel_strict.types b/tests/baselines/reference/labeledStatementWithLabel_strict.types
index 9a8a4ef205cee..052a8fbe022c6 100644
--- a/tests/baselines/reference/labeledStatementWithLabel_strict.types
+++ b/tests/baselines/reference/labeledStatementWithLabel_strict.types
@@ -8,7 +8,7 @@ label: function fn() { }
 
 label: function* gen() { }
 >label : any
->gen : () => IterableIterator<any>
+>gen : () => Generator<never, void, unknown>
 
 label: async function gen1() { }
 >label : any
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index c32e65901568e..c9a0476c2adcf 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -51,7 +51,7 @@ Baz.name;
 
 // Using ES6 generator
 function* gen() {
->gen : () => IterableIterator<number>
+>gen : () => Generator<number, void, unknown>
 
     let i = 0;
 >i : number
@@ -73,7 +73,7 @@ function* gen() {
 }
 
 function* gen2() {
->gen2 : () => IterableIterator<number>
+>gen2 : () => Generator<number, void, unknown>
 
     let i = 0;
 >i : number
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index a8dd60b1f8c51..a695213a42ccd 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -51,7 +51,7 @@ Baz.name;
 
 // Using ES6 generator
 function* gen() {
->gen : () => IterableIterator<number>
+>gen : () => Generator<number, void, unknown>
 
     let i = 0;
 >i : number
@@ -73,7 +73,7 @@ function* gen() {
 }
 
 function* gen2() {
->gen2 : () => IterableIterator<number>
+>gen2 : () => Generator<number, void, unknown>
 
     let i = 0;
 >i : number
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 222c5ab0c11af..3e7c23fde87ac 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -51,7 +51,7 @@ Baz.name;
 
 // Using ES6 generator
 function* gen() {
->gen : () => IterableIterator<number>
+>gen : () => Generator<number, void, unknown>
 
     let i = 0;
 >i : number
@@ -73,7 +73,7 @@ function* gen() {
 }
 
 function* gen2() {
->gen2 : () => IterableIterator<number>
+>gen2 : () => Generator<number, void, unknown>
 
     let i = 0;
 >i : number
diff --git a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types
index e921320363739..f18184101cff9 100644
--- a/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types
+++ b/tests/baselines/reference/modularizeLibrary_UsingES5LibAndES6FeatureLibs.types
@@ -23,7 +23,7 @@ Reflect.ownKeys({});
 >{} : {}
 
 function* idGen() {
->idGen : () => IterableIterator<number>
+>idGen : () => Generator<number, void, unknown>
 
     let i = 10;
 >i : number
diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types
index 9252c2a22c19f..68375a7d6796e 100644
--- a/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types
@@ -3,7 +3,7 @@ class C1 {
 >C1 : C1
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts ===
@@ -11,7 +11,7 @@ class C2 {
 >C2 : C2
 
     async * await() {
->await : () => AsyncIterableIterator<any>
+>await : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts ===
@@ -19,7 +19,7 @@ class C3 {
 >C3 : C3
 
     async * yield() {
->yield : () => AsyncIterableIterator<any>
+>yield : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts ===
@@ -45,7 +45,7 @@ class C6 {
 >C6 : C6
 
     async * f(a = await 1) {
->f : (a?: number) => AsyncIterableIterator<any>
+>f : (a?: number) => AsyncGenerator<never, void, unknown>
 >a : number
 >await 1 : 1
 >1 : 1
@@ -56,7 +56,7 @@ class C7 {
 >C7 : C7
 
     async * f(a = yield) {
->f : (a?: any) => AsyncIterableIterator<any>
+>f : (a?: any) => AsyncGenerator<never, void, unknown>
 >a : any
 >yield : any
     }
@@ -66,10 +66,10 @@ class C8 {
 >C8 : C8
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         async function * g() {
->g : () => AsyncIterableIterator<any>
+>g : () => AsyncGenerator<never, void, unknown>
         }
     }
 }
@@ -78,7 +78,7 @@ class C9 {
 >C9 : C9
 
     async * f() {
->f : () => AsyncIterableIterator<() => void>
+>f : () => AsyncGenerator<() => void, void, unknown>
 
         function yield() {
 > : () => any
@@ -92,7 +92,7 @@ class C10 {
 >C10 : C10
 
     async * f() {
->f : () => AsyncIterableIterator<() => void>
+>f : () => AsyncGenerator<() => void, void, unknown>
 
         const x = function yield() {
 >x : () => any
@@ -108,7 +108,7 @@ class C11 {
 >C11 : C11
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         function await() {
 > : () => any
@@ -123,7 +123,7 @@ class C12 {
 >C12 : C12
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = function await() {
 >x : () => any
@@ -140,7 +140,7 @@ class C13 {
 >C13 : C13
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         yield;
 >yield : any
@@ -151,7 +151,7 @@ class C14 {
 >C14 : C14
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         yield 1;
 >yield 1 : any
@@ -163,7 +163,7 @@ class C15 {
 >C15 : C15
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, any>
 
         yield *;
 >yield * : any
@@ -175,7 +175,7 @@ class C16 {
 >C16 : C16
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, undefined>
 
         yield * [];
 >yield * [] : any
@@ -187,7 +187,7 @@ class C17 {
 >C17 : C17
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         await 1;
 >await 1 : 1
@@ -199,7 +199,7 @@ class C18 {
 >C18 : C18
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         await;
 >await : any
@@ -212,7 +212,7 @@ class C19 {
 >C19 : C19
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         let x: await;
 >x : await
@@ -224,7 +224,7 @@ class C20 {
 >C20 : C20
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         let x: yield;
 >x : yield
@@ -235,7 +235,7 @@ class C21 {
 >C21 : C21
 
     async * [yield]() {
->[yield] : () => AsyncIterableIterator<any>
+>[yield] : () => AsyncGenerator<never, void, unknown>
 >yield : any
     }
 }
@@ -244,7 +244,7 @@ class C22 {
 >C22 : C22
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = { [yield]: 1 };
 >x : { [x: number]: number; }
diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types
index 8804529efd287..08190b40112f5 100644
--- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types
@@ -1,49 +1,49 @@
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionDeclarationIsOk.ts ===
 async function * f1() {
->f1 : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsOk.ts ===
 async function * await() {
->await : () => AsyncIterableIterator<any>
+>await : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldNameIsOk.ts ===
 async function * yield() {
->yield : () => AsyncIterableIterator<any>
+>yield : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts ===
 async function * f4(await) {
 >f4 : () => any
->await : () => AsyncIterableIterator<any>
+>await : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldParameterIsError.ts ===
 async function * f5(yield) {
 >f5 : () => any
->yield : () => AsyncIterableIterator<any>
+>yield : () => AsyncGenerator<never, void, unknown>
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts ===
 async function * f6(a = await 1) {
->f6 : (a?: number) => AsyncIterableIterator<any>
+>f6 : (a?: number) => AsyncGenerator<never, void, unknown>
 >a : number
 >await 1 : 1
 >1 : 1
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts ===
 async function * f7(a = yield) {
->f7 : (a?: any) => AsyncIterableIterator<any>
+>f7 : (a?: any) => AsyncGenerator<never, void, unknown>
 >a : any
 >yield : any
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts ===
 async function * f8() {
->f8 : () => AsyncIterableIterator<any>
+>f8 : () => AsyncGenerator<never, void, unknown>
 
     async function * g() {
->g : () => AsyncIterableIterator<any>
+>g : () => AsyncGenerator<never, void, unknown>
     }
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts ===
 async function * f9() {
->f9 : () => AsyncIterableIterator<() => void>
+>f9 : () => AsyncGenerator<() => void, void, unknown>
 
     function yield() {
 > : () => any
@@ -53,7 +53,7 @@ async function * f9() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts ===
 async function * f10() {
->f10 : () => AsyncIterableIterator<() => void>
+>f10 : () => AsyncGenerator<() => void, void, unknown>
 
     const x = function yield() {
 >x : () => any
@@ -65,7 +65,7 @@ async function * f10() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts ===
 async function * f11() {
->f11 : () => AsyncIterableIterator<any>
+>f11 : () => AsyncGenerator<never, void, unknown>
 
     function await() {
 > : () => any
@@ -76,7 +76,7 @@ async function * f11() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts ===
 async function * f12() {
->f12 : () => AsyncIterableIterator<() => void>
+>f12 : () => AsyncGenerator<() => void, void, unknown>
 
     const x = function yield() {
 >x : () => any
@@ -88,14 +88,14 @@ async function * f12() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts ===
 async function * f13() {
->f13 : () => AsyncIterableIterator<any>
+>f13 : () => AsyncGenerator<any, void, unknown>
 
     yield;
 >yield : any
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts ===
 async function * f14() {
->f14 : () => AsyncIterableIterator<number>
+>f14 : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
@@ -103,7 +103,7 @@ async function * f14() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts ===
 async function * f15() {
->f15 : () => AsyncIterableIterator<any>
+>f15 : () => AsyncGenerator<any, void, any>
 
     yield *;
 >yield * : any
@@ -111,7 +111,7 @@ async function * f15() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts ===
 async function * f16() {
->f16 : () => AsyncIterableIterator<any>
+>f16 : () => AsyncGenerator<any, void, undefined>
 
     yield * [];
 >yield * [] : any
@@ -119,7 +119,7 @@ async function * f16() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts ===
 async function * f17() {
->f17 : () => AsyncIterableIterator<any>
+>f17 : () => AsyncGenerator<never, void, unknown>
 
     await 1;
 >await 1 : 1
@@ -127,7 +127,7 @@ async function * f17() {
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts ===
 async function * f18() {
->f18 : () => AsyncIterableIterator<any>
+>f18 : () => AsyncGenerator<never, void, unknown>
 
     await;
 >await : any
@@ -136,7 +136,7 @@ async function * f18() {
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts ===
 interface await {}
 async function * f19() {
->f19 : () => AsyncIterableIterator<any>
+>f19 : () => AsyncGenerator<never, void, unknown>
 
     let x: await;
 >x : await
@@ -144,14 +144,14 @@ async function * f19() {
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts ===
 interface yield {}
 async function * f20() {
->f20 : () => AsyncIterableIterator<any>
+>f20 : () => AsyncGenerator<never, void, unknown>
 
     let x: yield;
 >x : yield
 }
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts ===
 async function * f21() {
->f21 : () => AsyncIterableIterator<any>
+>f21 : () => AsyncGenerator<any, void, unknown>
 
     const x = { [yield]: 1 };
 >x : { [x: number]: number; }
diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types
index 277b79a3a3916..0af07dc220f33 100644
--- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types
@@ -1,8 +1,8 @@
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/functionExpressionIsOk.ts ===
 const f1 = async function * f() {
->f1 : () => AsyncIterableIterator<any>
->async function * f() {} : () => AsyncIterableIterator<any>
->f : () => AsyncIterableIterator<any>
+>f1 : () => AsyncGenerator<never, void, unknown>
+>async function * f() {} : () => AsyncGenerator<never, void, unknown>
+>f : () => AsyncGenerator<never, void, unknown>
 
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitNameIsError.ts ===
@@ -37,8 +37,8 @@ const f5 = async function * (yield) {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts ===
 const f6 = async function * (a = await 1) {
->f6 : (a?: number) => AsyncIterableIterator<any>
->async function * (a = await 1) {} : (a?: number) => AsyncIterableIterator<any>
+>f6 : (a?: number) => AsyncGenerator<never, void, unknown>
+>async function * (a = await 1) {} : (a?: number) => AsyncGenerator<never, void, unknown>
 >a : number
 >await 1 : 1
 >1 : 1
@@ -46,25 +46,25 @@ const f6 = async function * (a = await 1) {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts ===
 const f7 = async function * (a = yield) {
->f7 : (a?: any) => AsyncIterableIterator<any>
->async function * (a = yield) {} : (a?: any) => AsyncIterableIterator<any>
+>f7 : (a?: any) => AsyncGenerator<never, void, unknown>
+>async function * (a = yield) {} : (a?: any) => AsyncGenerator<never, void, unknown>
 >a : any
 >yield : any
 
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts ===
 const f8 = async function * () {
->f8 : () => AsyncIterableIterator<any>
->async function * () {    async function * g() {    }} : () => AsyncIterableIterator<any>
+>f8 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    async function * g() {    }} : () => AsyncGenerator<never, void, unknown>
 
     async function * g() {
->g : () => AsyncIterableIterator<any>
+>g : () => AsyncGenerator<never, void, unknown>
     }
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts ===
 const f9 = async function * () {
->f9 : () => AsyncIterableIterator<() => void>
->async function * () {    function yield() {    }} : () => AsyncIterableIterator<() => void>
+>f9 : () => AsyncGenerator<() => void, void, unknown>
+>async function * () {    function yield() {    }} : () => AsyncGenerator<() => void, void, unknown>
 
     function yield() {
 > : () => any
@@ -74,8 +74,8 @@ const f9 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts ===
 const f10 = async function * () {
->f10 : () => AsyncIterableIterator<() => void>
->async function * () {    const x = function yield() {    };} : () => AsyncIterableIterator<() => void>
+>f10 : () => AsyncGenerator<() => void, void, unknown>
+>async function * () {    const x = function yield() {    };} : () => AsyncGenerator<() => void, void, unknown>
 
     const x = function yield() {
 >x : () => any
@@ -87,8 +87,8 @@ const f10 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts ===
 const f11 = async function * () {
->f11 : () => AsyncIterableIterator<any>
->async function * () {    function await() {    }} : () => AsyncIterableIterator<any>
+>f11 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    function await() {    }} : () => AsyncGenerator<never, void, unknown>
 
     function await() {
 > : () => any
@@ -99,8 +99,8 @@ const f11 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts ===
 const f12 = async function * () {
->f12 : () => AsyncIterableIterator<any>
->async function * () {    const x = function await() {    };} : () => AsyncIterableIterator<any>
+>f12 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    const x = function await() {    };} : () => AsyncGenerator<never, void, unknown>
 
     const x = function await() {
 >x : () => any
@@ -113,8 +113,8 @@ const f12 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts ===
 const f13 = async function * () {
->f13 : () => AsyncIterableIterator<any>
->async function * () {    yield;} : () => AsyncIterableIterator<any>
+>f13 : () => AsyncGenerator<any, void, unknown>
+>async function * () {    yield;} : () => AsyncGenerator<any, void, unknown>
 
     yield;
 >yield : any
@@ -122,8 +122,8 @@ const f13 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts ===
 const f14 = async function * () {
->f14 : () => AsyncIterableIterator<number>
->async function * () {    yield 1;} : () => AsyncIterableIterator<number>
+>f14 : () => AsyncGenerator<number, void, unknown>
+>async function * () {    yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
@@ -132,8 +132,8 @@ const f14 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts ===
 const f15 = async function * () {
->f15 : () => AsyncIterableIterator<any>
->async function * () {    yield *;} : () => AsyncIterableIterator<any>
+>f15 : () => AsyncGenerator<any, void, any>
+>async function * () {    yield *;} : () => AsyncGenerator<any, void, any>
 
     yield *;
 >yield * : any
@@ -142,8 +142,8 @@ const f15 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts ===
 const f16 = async function * () {
->f16 : () => AsyncIterableIterator<any>
->async function * () {    yield * [];} : () => AsyncIterableIterator<any>
+>f16 : () => AsyncGenerator<any, void, undefined>
+>async function * () {    yield * [];} : () => AsyncGenerator<any, void, undefined>
 
     yield * [];
 >yield * [] : any
@@ -152,8 +152,8 @@ const f16 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts ===
 const f17 = async function * () {
->f17 : () => AsyncIterableIterator<any>
->async function * () {    await 1;} : () => AsyncIterableIterator<any>
+>f17 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    await 1;} : () => AsyncGenerator<never, void, unknown>
 
     await 1;
 >await 1 : 1
@@ -162,8 +162,8 @@ const f17 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts ===
 const f18 = async function * () {
->f18 : () => AsyncIterableIterator<any>
->async function * () {    await;} : () => AsyncIterableIterator<any>
+>f18 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    await;} : () => AsyncGenerator<never, void, unknown>
 
     await;
 >await : any
@@ -173,8 +173,8 @@ const f18 = async function * () {
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts ===
 interface await {}
 const f19 = async function * () {
->f19 : () => AsyncIterableIterator<any>
->async function * () {    let x: await;} : () => AsyncIterableIterator<any>
+>f19 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    let x: await;} : () => AsyncGenerator<never, void, unknown>
 
     let x: await;
 >x : await
@@ -183,8 +183,8 @@ const f19 = async function * () {
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts ===
 interface yield {}
 const f20 = async function * () {
->f20 : () => AsyncIterableIterator<any>
->async function * () {    let x: yield;} : () => AsyncIterableIterator<any>
+>f20 : () => AsyncGenerator<never, void, unknown>
+>async function * () {    let x: yield;} : () => AsyncGenerator<never, void, unknown>
 
     let x: yield;
 >x : yield
@@ -192,8 +192,8 @@ const f20 = async function * () {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts ===
 const f21 = async function *() {
->f21 : () => AsyncIterableIterator<any>
->async function *() {    const x = { [yield]: 1 };} : () => AsyncIterableIterator<any>
+>f21 : () => AsyncGenerator<any, void, unknown>
+>async function *() {    const x = { [yield]: 1 };} : () => AsyncGenerator<any, void, unknown>
 
     const x = { [yield]: 1 };
 >x : { [x: number]: number; }
diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types
index 655ecb3e6a0d7..5a6ea2a19fb81 100644
--- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types
@@ -1,28 +1,28 @@
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/methodIsOk.ts ===
 const o1 = {
->o1 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {    }} : { f(): AsyncIterableIterator<any>; }
+>o1 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
     }
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMethodNameIsOk.ts ===
 const o2 = {
->o2 : { await(): AsyncIterableIterator<any>; }
->{    async * await() {    }} : { await(): AsyncIterableIterator<any>; }
+>o2 : { await(): AsyncGenerator<never, void, unknown>; }
+>{    async * await() {    }} : { await(): AsyncGenerator<never, void, unknown>; }
 
     async * await() {
->await : () => AsyncIterableIterator<any>
+>await : () => AsyncGenerator<never, void, unknown>
     }
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldMethodNameIsOk.ts ===
 const o3 = {
->o3 : { yield(): AsyncIterableIterator<any>; }
->{    async * yield() {    }} : { yield(): AsyncIterableIterator<any>; }
+>o3 : { yield(): AsyncGenerator<never, void, unknown>; }
+>{    async * yield() {    }} : { yield(): AsyncGenerator<never, void, unknown>; }
 
     async * yield() {
->yield : () => AsyncIterableIterator<any>
+>yield : () => AsyncGenerator<never, void, unknown>
     }
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitParameterIsError.ts ===
@@ -47,11 +47,11 @@ const o5 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitInParameterInitializerIsError.ts ===
 const o6 = {
->o6 : { f(a?: number): AsyncIterableIterator<any>; }
->{    async * f(a = await 1) {    }} : { f(a?: number): AsyncIterableIterator<any>; }
+>o6 : { f(a?: number): AsyncGenerator<never, void, unknown>; }
+>{    async * f(a = await 1) {    }} : { f(a?: number): AsyncGenerator<never, void, unknown>; }
 
     async * f(a = await 1) {
->f : (a?: number) => AsyncIterableIterator<any>
+>f : (a?: number) => AsyncGenerator<never, void, unknown>
 >a : number
 >await 1 : 1
 >1 : 1
@@ -59,35 +59,35 @@ const o6 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInParameterInitializerIsError.ts ===
 const o7 = {
->o7 : { f(a?: any): AsyncIterableIterator<any>; }
->{    async * f(a = yield) {    }} : { f(a?: any): AsyncIterableIterator<any>; }
+>o7 : { f(a?: any): AsyncGenerator<never, void, unknown>; }
+>{    async * f(a = yield) {    }} : { f(a?: any): AsyncGenerator<never, void, unknown>; }
 
     async * f(a = yield) {
->f : (a?: any) => AsyncIterableIterator<any>
+>f : (a?: any) => AsyncGenerator<never, void, unknown>
 >a : any
 >yield : any
     }
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedAsyncGeneratorIsOk.ts ===
 const o8 = {
->o8 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        async function * g() {        }    }} : { f(): AsyncIterableIterator<any>; }
+>o8 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        async function * g() {        }    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         async function * g() {
->g : () => AsyncIterableIterator<any>
+>g : () => AsyncGenerator<never, void, unknown>
         }
     }
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedYieldIsError.ts ===
 const o9 = {
->o9 : { f(): AsyncIterableIterator<() => void>; }
->{    async * f() {        function yield() {        }    }} : { f(): AsyncIterableIterator<() => void>; }
+>o9 : { f(): AsyncGenerator<() => void, void, unknown>; }
+>{    async * f() {        function yield() {        }    }} : { f(): AsyncGenerator<() => void, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<() => void>
+>f : () => AsyncGenerator<() => void, void, unknown>
 
         function yield() {
 > : () => any
@@ -98,11 +98,11 @@ const o9 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedYieldIsError.ts ===
 const o10 = {
->o10 : { f(): AsyncIterableIterator<() => void>; }
->{    async * f() {        const x = function yield() {        };    }} : { f(): AsyncIterableIterator<() => void>; }
+>o10 : { f(): AsyncGenerator<() => void, void, unknown>; }
+>{    async * f() {        const x = function yield() {        };    }} : { f(): AsyncGenerator<() => void, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<() => void>
+>f : () => AsyncGenerator<() => void, void, unknown>
 
         const x = function yield() {
 >x : () => any
@@ -115,11 +115,11 @@ const o10 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionDeclarationNamedAwaitIsError.ts ===
 const o11 = {
->o11 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        function await() {        }    }} : { f(): AsyncIterableIterator<any>; }
+>o11 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        function await() {        }    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         function await() {
 > : () => any
@@ -131,11 +131,11 @@ const o11 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/nestedFunctionExpressionNamedAwaitIsError.ts ===
 const o12 = {
->o12 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = function await() {        };    }} : { f(): AsyncIterableIterator<any>; }
+>o12 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        const x = function await() {        };    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         const x = function await() {
 >x : () => any
@@ -149,11 +149,11 @@ const o12 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldIsOk.ts ===
 const o13 = {
->o13 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        yield;    }} : { f(): AsyncIterableIterator<any>; }
+>o13 : { f(): AsyncGenerator<any, void, unknown>; }
+>{    async * f() {        yield;    }} : { f(): AsyncGenerator<any, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         yield;
 >yield : any
@@ -161,11 +161,11 @@ const o13 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldWithValueIsOk.ts ===
 const o14 = {
->o14 : { f(): AsyncIterableIterator<number>; }
->{    async * f() {        yield 1;    }} : { f(): AsyncIterableIterator<number>; }
+>o14 : { f(): AsyncGenerator<number, void, unknown>; }
+>{    async * f() {        yield 1;    }} : { f(): AsyncGenerator<number, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<number>
+>f : () => AsyncGenerator<number, void, unknown>
 
         yield 1;
 >yield 1 : any
@@ -174,11 +174,11 @@ const o14 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarMissingValueIsError.ts ===
 const o15 = {
->o15 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        yield *;    }} : { f(): AsyncIterableIterator<any>; }
+>o15 : { f(): AsyncGenerator<any, void, any>; }
+>{    async * f() {        yield *;    }} : { f(): AsyncGenerator<any, void, any>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, any>
 
         yield *;
 >yield * : any
@@ -187,11 +187,11 @@ const o15 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldStarWithValueIsOk.ts ===
 const o16 = {
->o16 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        yield * [];    }} : { f(): AsyncIterableIterator<any>; }
+>o16 : { f(): AsyncGenerator<any, void, undefined>; }
+>{    async * f() {        yield * [];    }} : { f(): AsyncGenerator<any, void, undefined>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, undefined>
 
         yield * [];
 >yield * [] : any
@@ -200,11 +200,11 @@ const o16 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitWithValueIsOk.ts ===
 const o17 = {
->o17 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        await 1;    }} : { f(): AsyncIterableIterator<any>; }
+>o17 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        await 1;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         await 1;
 >await 1 : 1
@@ -213,11 +213,11 @@ const o17 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitMissingValueIsError.ts ===
 const o18 = {
->o18 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        await;    }} : { f(): AsyncIterableIterator<any>; }
+>o18 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        await;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         await;
 >await : any
@@ -227,11 +227,11 @@ const o18 = {
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/awaitAsTypeIsOk.ts ===
 interface await {}
 const o19 = {
->o19 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        let x: await;    }} : { f(): AsyncIterableIterator<any>; }
+>o19 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        let x: await;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         let x: await;
 >x : await
@@ -240,11 +240,11 @@ const o19 = {
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldAsTypeIsOk.ts ===
 interface yield {}
 const o20 = {
->o20 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        let x: yield;    }} : { f(): AsyncIterableIterator<any>; }
+>o20 : { f(): AsyncGenerator<never, void, unknown>; }
+>{    async * f() {        let x: yield;    }} : { f(): AsyncGenerator<never, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<never, void, unknown>
 
         let x: yield;
 >x : yield
@@ -252,11 +252,11 @@ const o20 = {
 };
 === tests/cases/conformance/parser/ecmascript2018/asyncGenerators/yieldInNestedComputedPropertyIsOk.ts ===
 const o21 = {
->o21 : { f(): AsyncIterableIterator<any>; }
->{    async * f() {        const x = { [yield]: 1 };    }} : { f(): AsyncIterableIterator<any>; }
+>o21 : { f(): AsyncGenerator<any, void, unknown>; }
+>{    async * f() {        const x = { [yield]: 1 };    }} : { f(): AsyncGenerator<any, void, unknown>; }
 
     async * f() {
->f : () => AsyncIterableIterator<any>
+>f : () => AsyncGenerator<any, void, unknown>
 
         const x = { [yield]: 1 };
 >x : { [x: number]: number; }
diff --git a/tests/baselines/reference/parser.forAwait.es2018.types b/tests/baselines/reference/parser.forAwait.es2018.types
index 672d063883d2b..ea677dd97390f 100644
--- a/tests/baselines/reference/parser.forAwait.es2018.types
+++ b/tests/baselines/reference/parser.forAwait.es2018.types
@@ -70,7 +70,7 @@ async function f8() {
 }
 === tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithDeclIsOk.ts ===
 async function* f9() {
->f9 : () => AsyncIterableIterator<any>
+>f9 : () => AsyncGenerator<never, void, unknown>
 
     let y: any;
 >y : any
@@ -82,7 +82,7 @@ async function* f9() {
 }
 === tests/cases/conformance/parser/ecmascript2018/forAwait/inAsyncGeneratorWithExpressionIsOk.ts ===
 async function* f10() {
->f10 : () => AsyncIterableIterator<any>
+>f10 : () => AsyncGenerator<never, void, unknown>
 
     let x: any, y: any;
 >x : any
@@ -95,7 +95,7 @@ async function* f10() {
 }
 === tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithDeclIsError.ts ===
 function* f11() {
->f11 : () => IterableIterator<any>
+>f11 : () => Generator<never, void, unknown>
 
     let y: any;
 >y : any
@@ -107,7 +107,7 @@ function* f11() {
 }
 === tests/cases/conformance/parser/ecmascript2018/forAwait/inGeneratorWithExprIsError.ts ===
 function* f12() {
->f12 : () => IterableIterator<any>
+>f12 : () => Generator<never, void, unknown>
 
     let x: any, y: any;
 >x : any
diff --git a/tests/baselines/reference/restParameterInDownlevelGenerator.types b/tests/baselines/reference/restParameterInDownlevelGenerator.types
index e0b85e1a0ff87..0345af14c239d 100644
--- a/tests/baselines/reference/restParameterInDownlevelGenerator.types
+++ b/tests/baselines/reference/restParameterInDownlevelGenerator.types
@@ -1,7 +1,7 @@
 === tests/cases/conformance/generators/restParameterInDownlevelGenerator.ts ===
 // https://github.com/Microsoft/TypeScript/issues/30653
 function * mergeStringLists(...strings: string[]) {
->mergeStringLists : (...strings: string[]) => IterableIterator<any>
+>mergeStringLists : (...strings: string[]) => Generator<never, void, unknown>
 >strings : string[]
 
     for (var str of strings);
diff --git a/tests/baselines/reference/showConfig/Shows tsconfig for single option/strictGeneratorTypes/tsconfig.json b/tests/baselines/reference/showConfig/Shows tsconfig for single option/strictGeneratorTypes/tsconfig.json
new file mode 100644
index 0000000000000..91f667ef73951
--- /dev/null
+++ b/tests/baselines/reference/showConfig/Shows tsconfig for single option/strictGeneratorTypes/tsconfig.json	
@@ -0,0 +1,5 @@
+{
+    "compilerOptions": {
+        "strictGeneratorTypes": true
+    }
+}
diff --git a/tests/baselines/reference/sourceMapValidationVarInDownLevelGenerator.types b/tests/baselines/reference/sourceMapValidationVarInDownLevelGenerator.types
index cac2f03d8e437..0323d78394d45 100644
--- a/tests/baselines/reference/sourceMapValidationVarInDownLevelGenerator.types
+++ b/tests/baselines/reference/sourceMapValidationVarInDownLevelGenerator.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/sourceMapValidationVarInDownLevelGenerator.ts ===
 function * f() {
->f : () => IterableIterator<any>
+>f : () => Generator<never, void, unknown>
 
     var x = 1, y;
 >x : number
diff --git a/tests/baselines/reference/spreadOfParamsFromGeneratorMakesRequiredParams.errors.txt b/tests/baselines/reference/spreadOfParamsFromGeneratorMakesRequiredParams.errors.txt
index 393e21edb6c53..1b1f93ffc3f5f 100644
--- a/tests/baselines/reference/spreadOfParamsFromGeneratorMakesRequiredParams.errors.txt
+++ b/tests/baselines/reference/spreadOfParamsFromGeneratorMakesRequiredParams.errors.txt
@@ -1,8 +1,8 @@
-error TS2318: Cannot find global type 'IterableIterator'.
+error TS2318: Cannot find global type 'Generator'.
 tests/cases/compiler/spreadOfParamsFromGeneratorMakesRequiredParams.ts(6,1): error TS2554: Expected 2 arguments, but got 1.
 
 
-!!! error TS2318: Cannot find global type 'IterableIterator'.
+!!! error TS2318: Cannot find global type 'Generator'.
 ==== tests/cases/compiler/spreadOfParamsFromGeneratorMakesRequiredParams.ts (1 errors) ====
     declare function call<Fn extends (...args: any[]) => any>(
         fn: Fn,
diff --git a/tests/baselines/reference/templateStringInYieldKeyword.types b/tests/baselines/reference/templateStringInYieldKeyword.types
index 3eff79cf79632..71cce7b74eb1b 100644
--- a/tests/baselines/reference/templateStringInYieldKeyword.types
+++ b/tests/baselines/reference/templateStringInYieldKeyword.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringInYieldKeyword.ts ===
 function* gen() {
->gen : () => IterableIterator<string>
+>gen : () => Generator<string, void, unknown>
 
     // Once this is supported, the inner expression does not need to be parenthesized.
     var x = yield `abc${ x }def`;
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt
index ce0d781d8246c..a96993063732a 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeyword.errors.txt
@@ -1,8 +1,8 @@
-error TS2318: Cannot find global type 'IterableIterator'.
+error TS2318: Cannot find global type 'Generator'.
 tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts(1,15): error TS1005: '(' expected.
 
 
-!!! error TS2318: Cannot find global type 'IterableIterator'.
+!!! error TS2318: Cannot find global type 'Generator'.
 ==== tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeyword.ts (1 errors) ====
     function* gen {
                   ~
diff --git a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types
index dfd4e522def17..a4226bc3f4400 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types
+++ b/tests/baselines/reference/templateStringWithEmbeddedYieldKeywordES6.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedYieldKeywordES6.ts ===
 function* gen() {
->gen : () => IterableIterator<number>
+>gen : () => Generator<number, void, unknown>
 
     // Once this is supported, yield *must* be parenthesized.
     var x = `abc${ yield 10 }def`;
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
index 0f3b775331345..ad35f2a796f5c 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.1.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
@@ -1,22 +1,22 @@
 === tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.1.ts ===
 async function * inferReturnType1() {
->inferReturnType1 : () => AsyncIterableIterator<any>
+>inferReturnType1 : () => AsyncGenerator<never, void, unknown>
 }
 async function * inferReturnType2() {
->inferReturnType2 : () => AsyncIterableIterator<any>
+>inferReturnType2 : () => AsyncGenerator<any, void, unknown>
 
     yield;
 >yield : any
 }
 async function * inferReturnType3() {
->inferReturnType3 : () => AsyncIterableIterator<number>
+>inferReturnType3 : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
 >1 : 1
 }
 async function * inferReturnType4() {
->inferReturnType4 : () => AsyncIterableIterator<number>
+>inferReturnType4 : () => AsyncGenerator<number, void, unknown>
 
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
@@ -27,7 +27,7 @@ async function * inferReturnType4() {
 >1 : 1
 }
 async function * inferReturnType5() {
->inferReturnType5 : () => AsyncIterableIterator<number>
+>inferReturnType5 : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
@@ -42,7 +42,7 @@ async function * inferReturnType5() {
 >2 : 2
 }
 async function * inferReturnType6() {
->inferReturnType6 : () => AsyncIterableIterator<number>
+>inferReturnType6 : () => AsyncGenerator<number, void, undefined>
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -51,7 +51,7 @@ async function * inferReturnType6() {
 >2 : 2
 }
 async function * inferReturnType7() {
->inferReturnType7 : () => AsyncIterableIterator<number>
+>inferReturnType7 : () => AsyncGenerator<number, void, undefined>
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -63,19 +63,19 @@ async function * inferReturnType7() {
 >1 : 1
 }
 async function * inferReturnType8() {
->inferReturnType8 : () => AsyncIterableIterator<number>
+>inferReturnType8 : () => AsyncGenerator<number, void, unknown>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 const assignability1: () => AsyncIterableIterator<number> = async function * () {
 >assignability1 : () => AsyncIterableIterator<number>
->async function * () {    yield 1;} : () => AsyncIterableIterator<number>
+>async function * () {    yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
@@ -84,7 +84,7 @@ const assignability1: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability2: () => AsyncIterableIterator<number> = async function * () {
 >assignability2 : () => AsyncIterableIterator<number>
->async function * () {    yield Promise.resolve(1);} : () => AsyncIterableIterator<number>
+>async function * () {    yield Promise.resolve(1);} : () => AsyncGenerator<number, void, unknown>
 
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
@@ -97,7 +97,7 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability3: () => AsyncIterableIterator<number> = async function * () {
 >assignability3 : () => AsyncIterableIterator<number>
->async function * () {    yield* [1, 2];} : () => AsyncIterableIterator<number>
+>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, undefined>
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -108,7 +108,7 @@ const assignability3: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability4: () => AsyncIterableIterator<number> = async function * () {
 >assignability4 : () => AsyncIterableIterator<number>
->async function * () {    yield* [Promise.resolve(1)];} : () => AsyncIterableIterator<number>
+>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, undefined>
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -122,20 +122,20 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability5: () => AsyncIterableIterator<number> = async function * () {
 >assignability5 : () => AsyncIterableIterator<number>
->async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncIterableIterator<number>
+>async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncGenerator<number, void, unknown>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 
 };
 const assignability6: () => AsyncIterable<number> = async function * () {
 >assignability6 : () => AsyncIterable<number>
->async function * () {    yield 1;} : () => AsyncIterableIterator<number>
+>async function * () {    yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
@@ -144,7 +144,7 @@ const assignability6: () => AsyncIterable<number> = async function * () {
 };
 const assignability7: () => AsyncIterable<number> = async function * () {
 >assignability7 : () => AsyncIterable<number>
->async function * () {    yield Promise.resolve(1);} : () => AsyncIterableIterator<number>
+>async function * () {    yield Promise.resolve(1);} : () => AsyncGenerator<number, void, unknown>
 
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
@@ -157,7 +157,7 @@ const assignability7: () => AsyncIterable<number> = async function * () {
 };
 const assignability8: () => AsyncIterable<number> = async function * () {
 >assignability8 : () => AsyncIterable<number>
->async function * () {    yield* [1, 2];} : () => AsyncIterableIterator<number>
+>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, undefined>
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -168,7 +168,7 @@ const assignability8: () => AsyncIterable<number> = async function * () {
 };
 const assignability9: () => AsyncIterable<number> = async function * () {
 >assignability9 : () => AsyncIterable<number>
->async function * () {    yield* [Promise.resolve(1)];} : () => AsyncIterableIterator<number>
+>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, undefined>
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -182,20 +182,20 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 };
 const assignability10: () => AsyncIterable<number> = async function * () {
 >assignability10 : () => AsyncIterable<number>
->async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncIterableIterator<number>
+>async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncGenerator<number, void, unknown>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 
 };
 const assignability11: () => AsyncIterator<number> = async function * () {
->assignability11 : () => AsyncIterator<number>
->async function * () {    yield 1;} : () => AsyncIterableIterator<number>
+>assignability11 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield 1;} : () => AsyncGenerator<number, void, unknown>
 
     yield 1;
 >yield 1 : any
@@ -203,8 +203,8 @@ const assignability11: () => AsyncIterator<number> = async function * () {
 
 };
 const assignability12: () => AsyncIterator<number> = async function * () {
->assignability12 : () => AsyncIterator<number>
->async function * () {    yield Promise.resolve(1);} : () => AsyncIterableIterator<number>
+>assignability12 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield Promise.resolve(1);} : () => AsyncGenerator<number, void, unknown>
 
     yield Promise.resolve(1);
 >yield Promise.resolve(1) : any
@@ -216,8 +216,8 @@ const assignability12: () => AsyncIterator<number> = async function * () {
 
 };
 const assignability13: () => AsyncIterator<number> = async function * () {
->assignability13 : () => AsyncIterator<number>
->async function * () {    yield* [1, 2];} : () => AsyncIterableIterator<number>
+>assignability13 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, undefined>
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -227,8 +227,8 @@ const assignability13: () => AsyncIterator<number> = async function * () {
 
 };
 const assignability14: () => AsyncIterator<number> = async function * () {
->assignability14 : () => AsyncIterator<number>
->async function * () {    yield* [Promise.resolve(1)];} : () => AsyncIterableIterator<number>
+>assignability14 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, undefined>
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -241,14 +241,14 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 
 };
 const assignability15: () => AsyncIterator<number> = async function * () {
->assignability15 : () => AsyncIterator<number>
->async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncIterableIterator<number>
+>assignability15 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield* (async function * () { yield 1; })();} : () => AsyncGenerator<number, void, unknown>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 
@@ -257,14 +257,14 @@ async function * explicitReturnType1(): AsyncIterableIterator<number> {
 >explicitReturnType1 : () => AsyncIterableIterator<number>
 
     yield 1;
->yield 1 : any
+>yield 1 : undefined
 >1 : 1
 }
 async function * explicitReturnType2(): AsyncIterableIterator<number> {
 >explicitReturnType2 : () => AsyncIterableIterator<number>
 
     yield Promise.resolve(1);
->yield Promise.resolve(1) : any
+>yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
 >Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
@@ -296,10 +296,10 @@ async function * explicitReturnType5(): AsyncIterableIterator<number> {
 >explicitReturnType5 : () => AsyncIterableIterator<number>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
@@ -307,14 +307,14 @@ async function * explicitReturnType6(): AsyncIterable<number> {
 >explicitReturnType6 : () => AsyncIterable<number>
 
     yield 1;
->yield 1 : any
+>yield 1 : undefined
 >1 : 1
 }
 async function * explicitReturnType7(): AsyncIterable<number> {
 >explicitReturnType7 : () => AsyncIterable<number>
 
     yield Promise.resolve(1);
->yield Promise.resolve(1) : any
+>yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
 >Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
@@ -346,25 +346,25 @@ async function * explicitReturnType10(): AsyncIterable<number> {
 >explicitReturnType10 : () => AsyncIterable<number>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
 async function * explicitReturnType11(): AsyncIterator<number> {
->explicitReturnType11 : () => AsyncIterator<number>
+>explicitReturnType11 : () => AsyncIterator<number, any, undefined>
 
     yield 1;
->yield 1 : any
+>yield 1 : undefined
 >1 : 1
 }
 async function * explicitReturnType12(): AsyncIterator<number> {
->explicitReturnType12 : () => AsyncIterator<number>
+>explicitReturnType12 : () => AsyncIterator<number, any, undefined>
 
     yield Promise.resolve(1);
->yield Promise.resolve(1) : any
+>yield Promise.resolve(1) : undefined
 >Promise.resolve(1) : Promise<number>
 >Promise.resolve : { <T>(value: T | PromiseLike<T>): Promise<T>; (): Promise<void>; }
 >Promise : PromiseConstructor
@@ -372,7 +372,7 @@ async function * explicitReturnType12(): AsyncIterator<number> {
 >1 : 1
 }
 async function * explicitReturnType13(): AsyncIterator<number> {
->explicitReturnType13 : () => AsyncIterator<number>
+>explicitReturnType13 : () => AsyncIterator<number, any, undefined>
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -381,7 +381,7 @@ async function * explicitReturnType13(): AsyncIterator<number> {
 >2 : 2
 }
 async function * explicitReturnType14(): AsyncIterator<number> {
->explicitReturnType14 : () => AsyncIterator<number>
+>explicitReturnType14 : () => AsyncIterator<number, any, undefined>
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -393,13 +393,13 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 >1 : 1
 }
 async function * explicitReturnType15(): AsyncIterator<number> {
->explicitReturnType15 : () => AsyncIterator<number>
+>explicitReturnType15 : () => AsyncIterator<number, any, undefined>
 
     yield* (async function * () { yield 1; })();
->yield* (async function * () { yield 1; })() : any
->(async function * () { yield 1; })() : AsyncIterableIterator<number>
->(async function * () { yield 1; }) : () => AsyncIterableIterator<number>
->async function * () { yield 1; } : () => AsyncIterableIterator<number>
+>yield* (async function * () { yield 1; })() : void
+>(async function * () { yield 1; })() : AsyncGenerator<number, void, unknown>
+>(async function * () { yield 1; }) : () => AsyncGenerator<number, void, unknown>
+>async function * () { yield 1; } : () => AsyncGenerator<number, void, unknown>
 >yield 1 : any
 >1 : 1
 }
@@ -411,7 +411,7 @@ async function * explicitReturnType16(): {} {
 >1 : 1
 }
 async function * awaitedType1() {
->awaitedType1 : () => AsyncIterableIterator<any>
+>awaitedType1 : () => AsyncGenerator<never, void, unknown>
 
     const x = await 1;
 >x : 1
@@ -419,7 +419,7 @@ async function * awaitedType1() {
 >1 : 1
 }
 async function * awaitedType2() {
->awaitedType2 : () => AsyncIterableIterator<any>
+>awaitedType2 : () => AsyncGenerator<never, void, unknown>
 
     const x = await Promise.resolve(1);
 >x : number
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
index 471cf39bed29c..c8c4ed39ed7e1 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
@@ -1,32 +1,45 @@
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(2,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(8,12): error TS2504: Type 'Promise<number[]>' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterableIterator<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterableIterator<number>'.
-    Type 'string' is not assignable to type 'number'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterableIterator<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterableIterator<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterableIterator<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterableIterator<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterable<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterable<number>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
+  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterableIterator<number>'.
+    Types of property 'next' are incompatible.
+      Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+        Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+          Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
+            Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+              Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+                Type 'string' is not assignable to type 'number'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
+  Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterableIterator<number>'.
+    Types of property 'next' are incompatible.
+      Type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+        Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(16,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
+  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterableIterator<number>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
+  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterable<number>'.
     Types of property '[Symbol.asyncIterator]' are incompatible.
-      Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-        Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
+      Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+        Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
           Types of property 'next' are incompatible.
-            Type '(value?: any) => Promise<IteratorResult<string>>' is not assignable to type '(value?: any) => Promise<IteratorResult<number>>'.
-              Type 'Promise<IteratorResult<string>>' is not assignable to type 'Promise<IteratorResult<number>>'.
-                Type 'IteratorResult<string>' is not assignable to type 'IteratorResult<number>'.
-                  Type 'string' is not assignable to type 'number'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterable<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterable<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterable<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterable<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(34,7): error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-  Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
+            Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+              Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterable<number>'.
+  Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterable<number>'.
+    Types of property '[Symbol.asyncIterator]' are incompatible.
+      Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+        Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
+          Types of property 'next' are incompatible.
+            Type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+              Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(25,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
+  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterable<number>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+  Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(34,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+  Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(38,11): error TS2322: Type '"a"' is not assignable to type 'number'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(41,12): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(44,12): error TS2322: Type 'string' is not assignable to type 'number'.
@@ -36,12 +49,13 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(56,11): error TS2322: Type '"a"' is not assignable to type 'number'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(59,12): error TS2322: Type 'string' is not assignable to type 'number'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(62,12): error TS2322: Type 'string' is not assignable to type 'number'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator<any>' but required in type 'IterableIterator<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator<any>' but required in type 'Iterable<number>'.
-tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncIterableIterator<any>' is not assignable to type 'Iterator<number>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(64,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator<number, any, undefined>' but required in type 'IterableIterator<number>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(67,42): error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator<any, any, any>' but required in type 'Iterable<number>'.
+tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(70,42): error TS2322: Type 'AsyncGenerator<number, any, undefined>' is not assignable to type 'Iterator<number, any, undefined>'.
   Types of property 'next' are incompatible.
-    Type '(value?: any) => Promise<IteratorResult<any>>' is not assignable to type '(value?: any) => IteratorResult<number>'.
-      Type 'Promise<IteratorResult<any>>' is missing the following properties from type 'IteratorResult<number>': done, value
+    Type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
+      Type 'Promise<IteratorResult<number, any>>' is not assignable to type 'IteratorResult<number, any>'.
+        Property 'value' is missing in type 'Promise<IteratorResult<number, any>>' but required in type 'IteratorYieldResult<number>'.
 tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 
 
@@ -61,65 +75,78 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
     }
     const assignability1: () => AsyncIterableIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterableIterator<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterableIterator<number>'.
-!!! error TS2322:     Type 'string' is not assignable to type 'number'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterableIterator<number>'.
+!!! error TS2322:     Types of property 'next' are incompatible.
+!!! error TS2322:       Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+!!! error TS2322:         Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
+!!! error TS2322:           Type 'IteratorResult<string, void>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:             Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:               Type 'IteratorYieldResult<string>' is not assignable to type 'IteratorYieldResult<number>'.
+!!! error TS2322:                 Type 'string' is not assignable to type 'number'.
         yield "a";
     };
     const assignability2: () => AsyncIterableIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterableIterator<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterableIterator<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterableIterator<number>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterableIterator<number>'.
+!!! error TS2322:     Types of property 'next' are incompatible.
+!!! error TS2322:       Type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+!!! error TS2322:         Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
         yield* ["a", "b"];
     };
     const assignability3: () => AsyncIterableIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterableIterator<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterableIterator<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterableIterator<number>'.
         yield* (async function * () { yield "a"; })();
     };
     const assignability4: () => AsyncIterable<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterable<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterable<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterable<number>'.
 !!! error TS2322:     Types of property '[Symbol.asyncIterator]' are incompatible.
-!!! error TS2322:       Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-!!! error TS2322:         Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
+!!! error TS2322:       Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+!!! error TS2322:         Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
 !!! error TS2322:           Types of property 'next' are incompatible.
-!!! error TS2322:             Type '(value?: any) => Promise<IteratorResult<string>>' is not assignable to type '(value?: any) => Promise<IteratorResult<number>>'.
-!!! error TS2322:               Type 'Promise<IteratorResult<string>>' is not assignable to type 'Promise<IteratorResult<number>>'.
-!!! error TS2322:                 Type 'IteratorResult<string>' is not assignable to type 'IteratorResult<number>'.
-!!! error TS2322:                   Type 'string' is not assignable to type 'number'.
+!!! error TS2322:             Type '(...args: [] | [unknown]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+!!! error TS2322:               Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
         yield "a";
     };
     const assignability5: () => AsyncIterable<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterable<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterable<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterable<number>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterable<number>'.
+!!! error TS2322:     Types of property '[Symbol.asyncIterator]' are incompatible.
+!!! error TS2322:       Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+!!! error TS2322:         Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
+!!! error TS2322:           Types of property 'next' are incompatible.
+!!! error TS2322:             Type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<string, void>>' is not assignable to type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>'.
+!!! error TS2322:               Type 'Promise<IteratorResult<string, void>>' is not assignable to type 'Promise<IteratorResult<number, any>>'.
         yield* ["a", "b"];
     };
     const assignability6: () => AsyncIterable<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterable<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterable<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterable<number>'.
         yield* (async function * () { yield "a"; })();
     };
     const assignability7: () => AsyncIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
         yield "a";
     };
     const assignability8: () => AsyncIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, undefined>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, undefined>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
         yield* ["a", "b"];
     };
     const assignability9: () => AsyncIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncIterableIterator<string>' is not assignable to type '() => AsyncIterator<number>'.
-!!! error TS2322:   Type 'AsyncIterableIterator<string>' is not assignable to type 'AsyncIterator<number>'.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, undefined>'.
+!!! error TS2322:   Type 'AsyncGenerator<string, void, unknown>' is not assignable to type 'AsyncIterator<number, any, undefined>'.
         yield* (async function * () { yield "a"; })();
     };
     async function * explicitReturnType1(): AsyncIterableIterator<number> {
@@ -169,22 +196,24 @@ tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts(
     }
     async function * explicitReturnType10(): IterableIterator<number> {
                                              ~~~~~~~~~~~~~~~~~~~~~~~~
-!!! error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator<any>' but required in type 'IterableIterator<number>'.
-!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:47:5: '[Symbol.iterator]' is declared here.
+!!! error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator<number, any, undefined>' but required in type 'IterableIterator<number>'.
+!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:55:5: '[Symbol.iterator]' is declared here.
         yield 1;
     }
     async function * explicitReturnType11(): Iterable<number> {
                                              ~~~~~~~~~~~~~~~~
-!!! error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncIterableIterator<any>' but required in type 'Iterable<number>'.
-!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:43:5: '[Symbol.iterator]' is declared here.
+!!! error TS2741: Property '[Symbol.iterator]' is missing in type 'AsyncGenerator<any, any, any>' but required in type 'Iterable<number>'.
+!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:51:5: '[Symbol.iterator]' is declared here.
         yield 1;
     }
     async function * explicitReturnType12(): Iterator<number> {
                                              ~~~~~~~~~~~~~~~~
-!!! error TS2322: Type 'AsyncIterableIterator<any>' is not assignable to type 'Iterator<number>'.
+!!! error TS2322: Type 'AsyncGenerator<number, any, undefined>' is not assignable to type 'Iterator<number, any, undefined>'.
 !!! error TS2322:   Types of property 'next' are incompatible.
-!!! error TS2322:     Type '(value?: any) => Promise<IteratorResult<any>>' is not assignable to type '(value?: any) => IteratorResult<number>'.
-!!! error TS2322:       Type 'Promise<IteratorResult<any>>' is missing the following properties from type 'IteratorResult<number>': done, value
+!!! error TS2322:     Type '(...args: [] | [PromiseLike<undefined>]) => Promise<IteratorResult<number, any>>' is not assignable to type '(...args: [] | [undefined]) => IteratorResult<number, any>'.
+!!! error TS2322:       Type 'Promise<IteratorResult<number, any>>' is not assignable to type 'IteratorResult<number, any>'.
+!!! error TS2322:         Property 'value' is missing in type 'Promise<IteratorResult<number, any>>' but required in type 'IteratorYieldResult<number>'.
+!!! related TS2728 /.ts/lib.es2015.iterable.d.ts:33:5: 'value' is declared here.
         yield 1;
     }
     async function * yieldStar() {
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
index 6bcc95297a986..23bf7225eb938 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/types/asyncGenerators/types.asyncGenerators.es2018.2.ts ===
 async function * inferReturnType1() {
->inferReturnType1 : () => AsyncIterableIterator<any>
+>inferReturnType1 : () => AsyncGenerator<any, void, unknown>
 
     yield* {};
 >yield* {} : any
@@ -15,7 +15,7 @@ async function * inferReturnType2() {
 >inferReturnType2 : () => any
 }
 async function * inferReturnType3() {
->inferReturnType3 : () => AsyncIterableIterator<any>
+>inferReturnType3 : () => AsyncGenerator<any, void, unknown>
 
     yield* Promise.resolve([1, 2]);
 >yield* Promise.resolve([1, 2]) : any
@@ -29,7 +29,7 @@ async function * inferReturnType3() {
 }
 const assignability1: () => AsyncIterableIterator<number> = async function * () {
 >assignability1 : () => AsyncIterableIterator<number>
->async function * () {    yield "a";} : () => AsyncIterableIterator<string>
+>async function * () {    yield "a";} : () => AsyncGenerator<string, void, unknown>
 
     yield "a";
 >yield "a" : any
@@ -38,7 +38,7 @@ const assignability1: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability2: () => AsyncIterableIterator<number> = async function * () {
 >assignability2 : () => AsyncIterableIterator<number>
->async function * () {    yield* ["a", "b"];} : () => AsyncIterableIterator<string>
+>async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, undefined>
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
@@ -49,20 +49,20 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability3: () => AsyncIterableIterator<number> = async function * () {
 >assignability3 : () => AsyncIterableIterator<number>
->async function * () {    yield* (async function * () { yield "a"; })();} : () => AsyncIterableIterator<string>
+>async function * () {    yield* (async function * () { yield "a"; })();} : () => AsyncGenerator<string, void, unknown>
 
     yield* (async function * () { yield "a"; })();
->yield* (async function * () { yield "a"; })() : any
->(async function * () { yield "a"; })() : AsyncIterableIterator<string>
->(async function * () { yield "a"; }) : () => AsyncIterableIterator<string>
->async function * () { yield "a"; } : () => AsyncIterableIterator<string>
+>yield* (async function * () { yield "a"; })() : void
+>(async function * () { yield "a"; })() : AsyncGenerator<string, void, unknown>
+>(async function * () { yield "a"; }) : () => AsyncGenerator<string, void, unknown>
+>async function * () { yield "a"; } : () => AsyncGenerator<string, void, unknown>
 >yield "a" : any
 >"a" : "a"
 
 };
 const assignability4: () => AsyncIterable<number> = async function * () {
 >assignability4 : () => AsyncIterable<number>
->async function * () {    yield "a";} : () => AsyncIterableIterator<string>
+>async function * () {    yield "a";} : () => AsyncGenerator<string, void, unknown>
 
     yield "a";
 >yield "a" : any
@@ -71,7 +71,7 @@ const assignability4: () => AsyncIterable<number> = async function * () {
 };
 const assignability5: () => AsyncIterable<number> = async function * () {
 >assignability5 : () => AsyncIterable<number>
->async function * () {    yield* ["a", "b"];} : () => AsyncIterableIterator<string>
+>async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, undefined>
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
@@ -82,20 +82,20 @@ const assignability5: () => AsyncIterable<number> = async function * () {
 };
 const assignability6: () => AsyncIterable<number> = async function * () {
 >assignability6 : () => AsyncIterable<number>
->async function * () {    yield* (async function * () { yield "a"; })();} : () => AsyncIterableIterator<string>
+>async function * () {    yield* (async function * () { yield "a"; })();} : () => AsyncGenerator<string, void, unknown>
 
     yield* (async function * () { yield "a"; })();
->yield* (async function * () { yield "a"; })() : any
->(async function * () { yield "a"; })() : AsyncIterableIterator<string>
->(async function * () { yield "a"; }) : () => AsyncIterableIterator<string>
->async function * () { yield "a"; } : () => AsyncIterableIterator<string>
+>yield* (async function * () { yield "a"; })() : void
+>(async function * () { yield "a"; })() : AsyncGenerator<string, void, unknown>
+>(async function * () { yield "a"; }) : () => AsyncGenerator<string, void, unknown>
+>async function * () { yield "a"; } : () => AsyncGenerator<string, void, unknown>
 >yield "a" : any
 >"a" : "a"
 
 };
 const assignability7: () => AsyncIterator<number> = async function * () {
->assignability7 : () => AsyncIterator<number>
->async function * () {    yield "a";} : () => AsyncIterableIterator<string>
+>assignability7 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield "a";} : () => AsyncGenerator<string, void, unknown>
 
     yield "a";
 >yield "a" : any
@@ -103,8 +103,8 @@ const assignability7: () => AsyncIterator<number> = async function * () {
 
 };
 const assignability8: () => AsyncIterator<number> = async function * () {
->assignability8 : () => AsyncIterator<number>
->async function * () {    yield* ["a", "b"];} : () => AsyncIterableIterator<string>
+>assignability8 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, undefined>
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
@@ -114,14 +114,14 @@ const assignability8: () => AsyncIterator<number> = async function * () {
 
 };
 const assignability9: () => AsyncIterator<number> = async function * () {
->assignability9 : () => AsyncIterator<number>
->async function * () {    yield* (async function * () { yield "a"; })();} : () => AsyncIterableIterator<string>
+>assignability9 : () => AsyncIterator<number, any, undefined>
+>async function * () {    yield* (async function * () { yield "a"; })();} : () => AsyncGenerator<string, void, unknown>
 
     yield* (async function * () { yield "a"; })();
->yield* (async function * () { yield "a"; })() : any
->(async function * () { yield "a"; })() : AsyncIterableIterator<string>
->(async function * () { yield "a"; }) : () => AsyncIterableIterator<string>
->async function * () { yield "a"; } : () => AsyncIterableIterator<string>
+>yield* (async function * () { yield "a"; })() : void
+>(async function * () { yield "a"; })() : AsyncGenerator<string, void, unknown>
+>(async function * () { yield "a"; }) : () => AsyncGenerator<string, void, unknown>
+>async function * () { yield "a"; } : () => AsyncGenerator<string, void, unknown>
 >yield "a" : any
 >"a" : "a"
 
@@ -130,7 +130,7 @@ async function * explicitReturnType1(): AsyncIterableIterator<number> {
 >explicitReturnType1 : () => AsyncIterableIterator<number>
 
     yield "a";
->yield "a" : any
+>yield "a" : undefined
 >"a" : "a"
 }
 async function * explicitReturnType2(): AsyncIterableIterator<number> {
@@ -146,10 +146,10 @@ async function * explicitReturnType3(): AsyncIterableIterator<number> {
 >explicitReturnType3 : () => AsyncIterableIterator<number>
 
     yield* (async function * () { yield "a"; })();
->yield* (async function * () { yield "a"; })() : any
->(async function * () { yield "a"; })() : AsyncIterableIterator<string>
->(async function * () { yield "a"; }) : () => AsyncIterableIterator<string>
->async function * () { yield "a"; } : () => AsyncIterableIterator<string>
+>yield* (async function * () { yield "a"; })() : void
+>(async function * () { yield "a"; })() : AsyncGenerator<string, void, unknown>
+>(async function * () { yield "a"; }) : () => AsyncGenerator<string, void, unknown>
+>async function * () { yield "a"; } : () => AsyncGenerator<string, void, unknown>
 >yield "a" : any
 >"a" : "a"
 }
@@ -157,7 +157,7 @@ async function * explicitReturnType4(): AsyncIterable<number> {
 >explicitReturnType4 : () => AsyncIterable<number>
 
     yield "a";
->yield "a" : any
+>yield "a" : undefined
 >"a" : "a"
 }
 async function * explicitReturnType5(): AsyncIterable<number> {
@@ -173,22 +173,22 @@ async function * explicitReturnType6(): AsyncIterable<number> {
 >explicitReturnType6 : () => AsyncIterable<number>
 
     yield* (async function * () { yield "a"; })();
->yield* (async function * () { yield "a"; })() : any
->(async function * () { yield "a"; })() : AsyncIterableIterator<string>
->(async function * () { yield "a"; }) : () => AsyncIterableIterator<string>
->async function * () { yield "a"; } : () => AsyncIterableIterator<string>
+>yield* (async function * () { yield "a"; })() : void
+>(async function * () { yield "a"; })() : AsyncGenerator<string, void, unknown>
+>(async function * () { yield "a"; }) : () => AsyncGenerator<string, void, unknown>
+>async function * () { yield "a"; } : () => AsyncGenerator<string, void, unknown>
 >yield "a" : any
 >"a" : "a"
 }
 async function * explicitReturnType7(): AsyncIterator<number> {
->explicitReturnType7 : () => AsyncIterator<number>
+>explicitReturnType7 : () => AsyncIterator<number, any, undefined>
 
     yield "a";
->yield "a" : any
+>yield "a" : undefined
 >"a" : "a"
 }
 async function * explicitReturnType8(): AsyncIterator<number> {
->explicitReturnType8 : () => AsyncIterator<number>
+>explicitReturnType8 : () => AsyncIterator<number, any, undefined>
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
@@ -197,13 +197,13 @@ async function * explicitReturnType8(): AsyncIterator<number> {
 >"b" : "b"
 }
 async function * explicitReturnType9(): AsyncIterator<number> {
->explicitReturnType9 : () => AsyncIterator<number>
+>explicitReturnType9 : () => AsyncIterator<number, any, undefined>
 
     yield* (async function * () { yield "a"; })();
->yield* (async function * () { yield "a"; })() : any
->(async function * () { yield "a"; })() : AsyncIterableIterator<string>
->(async function * () { yield "a"; }) : () => AsyncIterableIterator<string>
->async function * () { yield "a"; } : () => AsyncIterableIterator<string>
+>yield* (async function * () { yield "a"; })() : void
+>(async function * () { yield "a"; })() : AsyncGenerator<string, void, unknown>
+>(async function * () { yield "a"; }) : () => AsyncGenerator<string, void, unknown>
+>async function * () { yield "a"; } : () => AsyncGenerator<string, void, unknown>
 >yield "a" : any
 >"a" : "a"
 }
@@ -211,7 +211,7 @@ async function * explicitReturnType10(): IterableIterator<number> {
 >explicitReturnType10 : () => IterableIterator<number>
 
     yield 1;
->yield 1 : any
+>yield 1 : undefined
 >1 : 1
 }
 async function * explicitReturnType11(): Iterable<number> {
@@ -222,14 +222,14 @@ async function * explicitReturnType11(): Iterable<number> {
 >1 : 1
 }
 async function * explicitReturnType12(): Iterator<number> {
->explicitReturnType12 : () => Iterator<number>
+>explicitReturnType12 : () => Iterator<number, any, undefined>
 
     yield 1;
->yield 1 : any
+>yield 1 : undefined
 >1 : 1
 }
 async function * yieldStar() {
->yieldStar : () => AsyncIterableIterator<any>
+>yieldStar : () => AsyncGenerator<any, void, unknown>
 
     yield* {};
 >yield* {} : any
diff --git a/tests/baselines/reference/types.forAwait.es2018.1.types b/tests/baselines/reference/types.forAwait.es2018.1.types
index aa1035b87cb67..a606238658c14 100644
--- a/tests/baselines/reference/types.forAwait.es2018.1.types
+++ b/tests/baselines/reference/types.forAwait.es2018.1.types
@@ -40,7 +40,7 @@ async function f1() {
     }
 }
 async function * f2() {
->f2 : () => AsyncIterableIterator<any>
+>f2 : () => AsyncGenerator<never, void, unknown>
 
     let y: number;
 >y : number
diff --git a/tests/baselines/reference/types.forAwait.es2018.3.errors.txt b/tests/baselines/reference/types.forAwait.es2018.3.errors.txt
index 296ac0d066bc1..1aca869fb0c68 100644
--- a/tests/baselines/reference/types.forAwait.es2018.3.errors.txt
+++ b/tests/baselines/reference/types.forAwait.es2018.3.errors.txt
@@ -1,11 +1,11 @@
-error TS2318: Cannot find global type 'AsyncIterableIterator'.
+error TS2318: Cannot find global type 'AsyncGenerator'.
 tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(3,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(5,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(10,27): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts(12,21): error TS2504: Type '{}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator.
 
 
-!!! error TS2318: Cannot find global type 'AsyncIterableIterator'.
+!!! error TS2318: Cannot find global type 'AsyncGenerator'.
 ==== tests/cases/conformance/types/forAwait/types.forAwait.es2018.3.ts (4 errors) ====
     async function f1() {
         let y: number;
diff --git a/tests/baselines/reference/uniqueSymbols.types b/tests/baselines/reference/uniqueSymbols.types
index 9ee3be1cb285d..da2f989521805 100644
--- a/tests/baselines/reference/uniqueSymbols.types
+++ b/tests/baselines/reference/uniqueSymbols.types
@@ -113,17 +113,17 @@ function funcReturnConstCallWithTypeQuery(): typeof constCall { return constCall
 
 // generator function yield inference
 function* genFuncYieldConstCall() { yield constCall; }
->genFuncYieldConstCall : () => IterableIterator<symbol>
+>genFuncYieldConstCall : () => Generator<symbol, void, unknown>
 >yield constCall : any
 >constCall : unique symbol
 
 function* genFuncYieldLetCall() { yield letCall; }
->genFuncYieldLetCall : () => IterableIterator<symbol>
+>genFuncYieldLetCall : () => Generator<symbol, void, unknown>
 >yield letCall : any
 >letCall : symbol
 
 function* genFuncYieldVarCall() { yield varCall; }
->genFuncYieldVarCall : () => IterableIterator<symbol>
+>genFuncYieldVarCall : () => Generator<symbol, void, unknown>
 >yield varCall : any
 >varCall : symbol
 
@@ -131,7 +131,7 @@ function* genFuncYieldVarCall() { yield varCall; }
 function* genFuncYieldConstCallWithTypeQuery(): IterableIterator<typeof constCall> { yield constCall; }
 >genFuncYieldConstCallWithTypeQuery : () => IterableIterator<unique symbol>
 >constCall : unique symbol
->yield constCall : any
+>yield constCall : undefined
 >constCall : unique symbol
 
 // async function return inference
@@ -149,17 +149,17 @@ async function asyncFuncReturnVarCall() { return varCall; }
 
 // async generator function yield inference
 async function* asyncGenFuncYieldConstCall() { yield constCall; }
->asyncGenFuncYieldConstCall : () => AsyncIterableIterator<symbol>
+>asyncGenFuncYieldConstCall : () => AsyncGenerator<symbol, void, unknown>
 >yield constCall : any
 >constCall : unique symbol
 
 async function* asyncGenFuncYieldLetCall() { yield letCall; }
->asyncGenFuncYieldLetCall : () => AsyncIterableIterator<symbol>
+>asyncGenFuncYieldLetCall : () => AsyncGenerator<symbol, void, unknown>
 >yield letCall : any
 >letCall : symbol
 
 async function* asyncGenFuncYieldVarCall() { yield varCall; }
->asyncGenFuncYieldVarCall : () => AsyncIterableIterator<symbol>
+>asyncGenFuncYieldVarCall : () => AsyncGenerator<symbol, void, unknown>
 >yield varCall : any
 >varCall : symbol
 
@@ -484,8 +484,8 @@ f(N["s"]);
 
 // property assignments/methods
 const o2 = {
->o2 : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncIterableIterator<symbol>; method4(): IterableIterator<symbol>; method5(p?: symbol): symbol; }
->{    a: s,    b: N.s,    c: N["s"],    method1() { return s; },    async method2() { return s; },    async * method3() { yield s; },    * method4() { yield s; },    method5(p = s) { return p; },} : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncIterableIterator<symbol>; method4(): IterableIterator<symbol>; method5(p?: symbol): symbol; }
+>o2 : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncGenerator<symbol, void, unknown>; method4(): Generator<symbol, void, unknown>; method5(p?: symbol): symbol; }
+>{    a: s,    b: N.s,    c: N["s"],    method1() { return s; },    async method2() { return s; },    async * method3() { yield s; },    * method4() { yield s; },    method5(p = s) { return p; },} : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncGenerator<symbol, void, unknown>; method4(): Generator<symbol, void, unknown>; method5(p?: symbol): symbol; }
 
     a: s,
 >a : symbol
@@ -512,12 +512,12 @@ const o2 = {
 >s : unique symbol
 
     async * method3() { yield s; },
->method3 : () => AsyncIterableIterator<symbol>
+>method3 : () => AsyncGenerator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
     * method4() { yield s; },
->method4 : () => IterableIterator<symbol>
+>method4 : () => Generator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
@@ -606,12 +606,12 @@ class C0 {
 >s : unique symbol
 
     async * method3() { yield s; }
->method3 : () => AsyncIterableIterator<symbol>
+>method3 : () => AsyncGenerator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
     * method4() { yield s; }
->method4 : () => IterableIterator<symbol>
+>method4 : () => Generator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
@@ -819,7 +819,7 @@ interface Context {
 
 const o3: Context = {
 >o3 : Context
->{    method1() {        return s; // return type should not widen due to contextual type    },    async method2() {        return s; // return type should not widen due to contextual type    },    async * method3() {        yield s; // yield type should not widen due to contextual type    },    * method4() {        yield s; // yield type should not widen due to contextual type    },    method5(p = s) { // parameter should not widen due to contextual type        return p;    },} : { method1(): unique symbol; method2(): Promise<unique symbol>; method3(): AsyncIterableIterator<unique symbol>; method4(): IterableIterator<unique symbol>; method5(p?: unique symbol): unique symbol; }
+>{    method1() {        return s; // return type should not widen due to contextual type    },    async method2() {        return s; // return type should not widen due to contextual type    },    async * method3() {        yield s; // yield type should not widen due to contextual type    },    * method4() {        yield s; // yield type should not widen due to contextual type    },    method5(p = s) { // parameter should not widen due to contextual type        return p;    },} : { method1(): unique symbol; method2(): Promise<unique symbol>; method3(): AsyncGenerator<unique symbol, void, unknown>; method4(): Generator<unique symbol, void, unknown>; method5(p?: unique symbol): unique symbol; }
 
     method1() {
 >method1 : () => unique symbol
@@ -836,7 +836,7 @@ const o3: Context = {
 
     },
     async * method3() {
->method3 : () => AsyncIterableIterator<unique symbol>
+>method3 : () => AsyncGenerator<unique symbol, void, unknown>
 
         yield s; // yield type should not widen due to contextual type
 >yield s : any
@@ -844,7 +844,7 @@ const o3: Context = {
 
     },
     * method4() {
->method4 : () => IterableIterator<unique symbol>
+>method4 : () => Generator<unique symbol, void, unknown>
 
         yield s; // yield type should not widen due to contextual type
 >yield s : any
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.js b/tests/baselines/reference/uniqueSymbolsDeclarations.js
index 02a692aa9ff63..15342a0bd97fc 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.js
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.js
@@ -430,16 +430,16 @@ declare function funcReturnConstCall(): symbol;
 declare function funcReturnLetCall(): symbol;
 declare function funcReturnVarCall(): symbol;
 declare function funcReturnConstCallWithTypeQuery(): typeof constCall;
-declare function genFuncYieldConstCall(): IterableIterator<symbol>;
-declare function genFuncYieldLetCall(): IterableIterator<symbol>;
-declare function genFuncYieldVarCall(): IterableIterator<symbol>;
+declare function genFuncYieldConstCall(): Generator<symbol, void, unknown>;
+declare function genFuncYieldLetCall(): Generator<symbol, void, unknown>;
+declare function genFuncYieldVarCall(): Generator<symbol, void, unknown>;
 declare function genFuncYieldConstCallWithTypeQuery(): IterableIterator<typeof constCall>;
 declare function asyncFuncReturnConstCall(): Promise<symbol>;
 declare function asyncFuncReturnLetCall(): Promise<symbol>;
 declare function asyncFuncReturnVarCall(): Promise<symbol>;
-declare function asyncGenFuncYieldConstCall(): AsyncIterableIterator<symbol>;
-declare function asyncGenFuncYieldLetCall(): AsyncIterableIterator<symbol>;
-declare function asyncGenFuncYieldVarCall(): AsyncIterableIterator<symbol>;
+declare function asyncGenFuncYieldConstCall(): AsyncGenerator<symbol, void, unknown>;
+declare function asyncGenFuncYieldLetCall(): AsyncGenerator<symbol, void, unknown>;
+declare function asyncGenFuncYieldVarCall(): AsyncGenerator<symbol, void, unknown>;
 declare class C {
     static readonly readonlyStaticCall: unique symbol;
     static readonly readonlyStaticType: unique symbol;
@@ -502,8 +502,8 @@ declare const o2: {
     c: symbol;
     method1(): symbol;
     method2(): Promise<symbol>;
-    method3(): AsyncIterableIterator<symbol>;
-    method4(): IterableIterator<symbol>;
+    method3(): AsyncGenerator<symbol, void, unknown>;
+    method4(): Generator<symbol, void, unknown>;
     method5(p?: symbol): symbol;
 };
 declare class C0 {
@@ -521,8 +521,8 @@ declare class C0 {
     f: symbol;
     method1(): symbol;
     method2(): Promise<symbol>;
-    method3(): AsyncIterableIterator<symbol>;
-    method4(): IterableIterator<symbol>;
+    method3(): AsyncGenerator<symbol, void, unknown>;
+    method4(): Generator<symbol, void, unknown>;
     method5(p?: symbol): symbol;
 }
 declare class C1 {
diff --git a/tests/baselines/reference/uniqueSymbolsDeclarations.types b/tests/baselines/reference/uniqueSymbolsDeclarations.types
index a741802e83f78..b8c32385f4bc0 100644
--- a/tests/baselines/reference/uniqueSymbolsDeclarations.types
+++ b/tests/baselines/reference/uniqueSymbolsDeclarations.types
@@ -106,17 +106,17 @@ function funcReturnConstCallWithTypeQuery(): typeof constCall { return constCall
 
 // generator function yield inference
 function* genFuncYieldConstCall() { yield constCall; }
->genFuncYieldConstCall : () => IterableIterator<symbol>
+>genFuncYieldConstCall : () => Generator<symbol, void, unknown>
 >yield constCall : any
 >constCall : unique symbol
 
 function* genFuncYieldLetCall() { yield letCall; }
->genFuncYieldLetCall : () => IterableIterator<symbol>
+>genFuncYieldLetCall : () => Generator<symbol, void, unknown>
 >yield letCall : any
 >letCall : symbol
 
 function* genFuncYieldVarCall() { yield varCall; }
->genFuncYieldVarCall : () => IterableIterator<symbol>
+>genFuncYieldVarCall : () => Generator<symbol, void, unknown>
 >yield varCall : any
 >varCall : symbol
 
@@ -124,7 +124,7 @@ function* genFuncYieldVarCall() { yield varCall; }
 function* genFuncYieldConstCallWithTypeQuery(): IterableIterator<typeof constCall> { yield constCall; }
 >genFuncYieldConstCallWithTypeQuery : () => IterableIterator<unique symbol>
 >constCall : unique symbol
->yield constCall : any
+>yield constCall : undefined
 >constCall : unique symbol
 
 // async function return inference
@@ -142,17 +142,17 @@ async function asyncFuncReturnVarCall() { return varCall; }
 
 // async generator function yield inference
 async function* asyncGenFuncYieldConstCall() { yield constCall; }
->asyncGenFuncYieldConstCall : () => AsyncIterableIterator<symbol>
+>asyncGenFuncYieldConstCall : () => AsyncGenerator<symbol, void, unknown>
 >yield constCall : any
 >constCall : unique symbol
 
 async function* asyncGenFuncYieldLetCall() { yield letCall; }
->asyncGenFuncYieldLetCall : () => AsyncIterableIterator<symbol>
+>asyncGenFuncYieldLetCall : () => AsyncGenerator<symbol, void, unknown>
 >yield letCall : any
 >letCall : symbol
 
 async function* asyncGenFuncYieldVarCall() { yield varCall; }
->asyncGenFuncYieldVarCall : () => AsyncIterableIterator<symbol>
+>asyncGenFuncYieldVarCall : () => AsyncGenerator<symbol, void, unknown>
 >yield varCall : any
 >varCall : symbol
 
@@ -477,8 +477,8 @@ f(N["s"]);
 
 // property assignments/methods
 const o2 = {
->o2 : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncIterableIterator<symbol>; method4(): IterableIterator<symbol>; method5(p?: symbol): symbol; }
->{    a: s,    b: N.s,    c: N["s"],    method1() { return s; },    async method2() { return s; },    async * method3() { yield s; },    * method4() { yield s; },    method5(p = s) { return p; }} : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncIterableIterator<symbol>; method4(): IterableIterator<symbol>; method5(p?: symbol): symbol; }
+>o2 : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncGenerator<symbol, void, unknown>; method4(): Generator<symbol, void, unknown>; method5(p?: symbol): symbol; }
+>{    a: s,    b: N.s,    c: N["s"],    method1() { return s; },    async method2() { return s; },    async * method3() { yield s; },    * method4() { yield s; },    method5(p = s) { return p; }} : { a: symbol; b: symbol; c: symbol; method1(): symbol; method2(): Promise<symbol>; method3(): AsyncGenerator<symbol, void, unknown>; method4(): Generator<symbol, void, unknown>; method5(p?: symbol): symbol; }
 
     a: s,
 >a : symbol
@@ -505,12 +505,12 @@ const o2 = {
 >s : unique symbol
 
     async * method3() { yield s; },
->method3 : () => AsyncIterableIterator<symbol>
+>method3 : () => AsyncGenerator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
     * method4() { yield s; },
->method4 : () => IterableIterator<symbol>
+>method4 : () => Generator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
@@ -599,12 +599,12 @@ class C0 {
 >s : unique symbol
 
     async * method3() { yield s; }
->method3 : () => AsyncIterableIterator<symbol>
+>method3 : () => AsyncGenerator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
     * method4() { yield s; }
->method4 : () => IterableIterator<symbol>
+>method4 : () => Generator<symbol, void, unknown>
 >yield s : any
 >s : unique symbol
 
@@ -812,7 +812,7 @@ interface Context {
 
 const o4: Context = {
 >o4 : Context
->{    method1() {        return s; // return type should not widen due to contextual type    },    async method2() {        return s; // return type should not widen due to contextual type    },    async * method3() {        yield s; // yield type should not widen due to contextual type    },    * method4() {        yield s; // yield type should not widen due to contextual type    },    method5(p = s) { // parameter should not widen due to contextual type        return p;    }} : { method1(): unique symbol; method2(): Promise<unique symbol>; method3(): AsyncIterableIterator<unique symbol>; method4(): IterableIterator<unique symbol>; method5(p?: unique symbol): unique symbol; }
+>{    method1() {        return s; // return type should not widen due to contextual type    },    async method2() {        return s; // return type should not widen due to contextual type    },    async * method3() {        yield s; // yield type should not widen due to contextual type    },    * method4() {        yield s; // yield type should not widen due to contextual type    },    method5(p = s) { // parameter should not widen due to contextual type        return p;    }} : { method1(): unique symbol; method2(): Promise<unique symbol>; method3(): AsyncGenerator<unique symbol, void, unknown>; method4(): Generator<unique symbol, void, unknown>; method5(p?: unique symbol): unique symbol; }
 
     method1() {
 >method1 : () => unique symbol
@@ -829,7 +829,7 @@ const o4: Context = {
 
     },
     async * method3() {
->method3 : () => AsyncIterableIterator<unique symbol>
+>method3 : () => AsyncGenerator<unique symbol, void, unknown>
 
         yield s; // yield type should not widen due to contextual type
 >yield s : any
@@ -837,7 +837,7 @@ const o4: Context = {
 
     },
     * method4() {
->method4 : () => IterableIterator<unique symbol>
+>method4 : () => Generator<unique symbol, void, unknown>
 
         yield s; // yield type should not widen due to contextual type
 >yield s : any
diff --git a/tests/baselines/reference/yieldExpression1.types b/tests/baselines/reference/yieldExpression1.types
index 5f7a1c2f69bdb..3e2510229e05c 100644
--- a/tests/baselines/reference/yieldExpression1.types
+++ b/tests/baselines/reference/yieldExpression1.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/yieldExpression1.ts ===
 function* a() {
->a : () => IterableIterator<0 | undefined>
+>a : () => Generator<0 | undefined, void, unknown>
 
     yield;
 >yield : any
@@ -14,10 +14,10 @@ function* b(): IterableIterator<number> {
 >b : () => IterableIterator<number>
 
     yield;
->yield : any
+>yield : undefined
 
     yield 0;
->yield 0 : any
+>yield 0 : undefined
 >0 : 0
 }
 
diff --git a/tests/baselines/reference/yieldExpressionInControlFlow.types b/tests/baselines/reference/yieldExpressionInControlFlow.types
index 14650ef05829c..8e2a3dc76f578 100644
--- a/tests/baselines/reference/yieldExpressionInControlFlow.types
+++ b/tests/baselines/reference/yieldExpressionInControlFlow.types
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/yieldExpressions/bug25149.js ===
 function* f() {
->f : () => IterableIterator<any>
+>f : () => Generator<any, void, any>
 
     var o
 >o : any
@@ -19,7 +19,7 @@ function* f() {
 === tests/cases/conformance/es6/yieldExpressions/alsoFails.ts ===
 // fails in Typescript too
 function* g() {
->g : () => IterableIterator<any>
+>g : () => Generator<any, void, any>
 
     var o = []
 >o : any[]
diff --git a/tests/baselines/reference/yieldExpressionInFlowLoop.types b/tests/baselines/reference/yieldExpressionInFlowLoop.types
index a178d4b5ce762..9af0ffd590111 100644
--- a/tests/baselines/reference/yieldExpressionInFlowLoop.types
+++ b/tests/baselines/reference/yieldExpressionInFlowLoop.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/yieldExpressionInFlowLoop.ts ===
 function* f() {
->f : () => IterableIterator<any>
+>f : () => Generator<any, void, any>
 
     let result;
 >result : any
diff --git a/tests/baselines/reference/yieldExpressionInnerCommentEmit.types b/tests/baselines/reference/yieldExpressionInnerCommentEmit.types
index d6d384712f799..3c0aec3fdd59d 100644
--- a/tests/baselines/reference/yieldExpressionInnerCommentEmit.types
+++ b/tests/baselines/reference/yieldExpressionInnerCommentEmit.types
@@ -1,6 +1,6 @@
 === tests/cases/compiler/yieldExpressionInnerCommentEmit.ts ===
 function * foo2() {
->foo2 : () => IterableIterator<number>
+>foo2 : () => Generator<number, void, undefined>
 
     /*comment1*/ yield 1;
 >yield 1 : any
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of30.ts b/tests/cases/conformance/es6/for-ofStatements/for-of30.ts
index 67e1e3da70a28..3d8ac3a93af51 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of30.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of30.ts
@@ -6,9 +6,9 @@ class StringIterator {
             value: ""
         }
     }
-    
+
     return = 0;
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of31.ts b/tests/cases/conformance/es6/for-ofStatements/for-of31.ts
index 701fcb50ed0a5..1e8d7e106301b 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of31.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of31.ts
@@ -6,7 +6,7 @@ class StringIterator {
             value: ""
         }
     }
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of34.ts b/tests/cases/conformance/es6/for-ofStatements/for-of34.ts
index 63b88223996bf..b38a6a68bf663 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of34.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of34.ts
@@ -4,7 +4,7 @@ class StringIterator {
     next() {
         return v;
     }
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of35.ts b/tests/cases/conformance/es6/for-ofStatements/for-of35.ts
index ab6e26d6d60a5..041f611699e2f 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of35.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of35.ts
@@ -7,7 +7,7 @@ class StringIterator {
             value: v
         }
     }
-    
+
     [Symbol.iterator]() {
         return this;
     }
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts
index 06bceec84f565..d34f3b3b1645d 100644
--- a/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall12.ts
@@ -16,7 +16,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -29,4 +29,4 @@ class StringIterator {
     }
 }
 
-new Foo(...[...new SymbolIterator, ...[...new StringIterator]]);
\ No newline at end of file
+new Foo(...[...new SymbolIterator, ...[...new _StringIterator]]);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts
index 53b0e660379fc..0bc67491e94e1 100644
--- a/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall5.ts
@@ -13,7 +13,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -26,4 +26,4 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
\ No newline at end of file
+foo(...new SymbolIterator, ...new _StringIterator);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts
index c48260e97eacc..d5a49882e4566 100644
--- a/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall6.ts
@@ -13,7 +13,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -26,4 +26,4 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
\ No newline at end of file
+foo(...new SymbolIterator, ...new _StringIterator);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts
index 6893cd9d8a48d..be057412abd57 100644
--- a/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall7.ts
@@ -13,7 +13,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -26,4 +26,4 @@ class StringIterator {
     }
 }
 
-foo(...new SymbolIterator, ...new StringIterator);
\ No newline at end of file
+foo(...new SymbolIterator, ...new _StringIterator);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts
index c81a475d7de1d..9f84a5b2bdeab 100644
--- a/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall8.ts
@@ -16,7 +16,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -29,4 +29,4 @@ class StringIterator {
     }
 }
 
-new Foo(...new SymbolIterator, ...new StringIterator);
\ No newline at end of file
+new Foo(...new SymbolIterator, ...new _StringIterator);
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts
index 41ee21a564557..7f3f02eafb338 100644
--- a/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts
+++ b/tests/cases/conformance/es6/spread/iteratorSpreadInCall9.ts
@@ -16,7 +16,7 @@ class SymbolIterator {
     }
 }
 
-class StringIterator {
+class _StringIterator {
     next() {
         return {
             value: "",
@@ -29,4 +29,4 @@ class StringIterator {
     }
 }
 
-new Foo(...new SymbolIterator, ...[...new StringIterator]);
+new Foo(...new SymbolIterator, ...[...new _StringIterator]);
diff --git a/tests/cases/conformance/generators/generatorAssignability.ts b/tests/cases/conformance/generators/generatorAssignability.ts
new file mode 100644
index 0000000000000..8dfa7f7d8cf63
--- /dev/null
+++ b/tests/cases/conformance/generators/generatorAssignability.ts
@@ -0,0 +1,73 @@
+// @target: esnext
+// @strict: true
+// @noEmit: true
+
+declare let _: any;
+declare const g1: Generator<number, void, string>;
+declare const g2: Generator<number, void, undefined>;
+declare const g3: Generator<number, void, boolean>;
+declare const g4: AsyncGenerator<number, void, string>;
+declare const g5: AsyncGenerator<number, void, undefined>;
+declare const g6: AsyncGenerator<number, void, boolean>;
+
+// spread iterable
+[...g1]; // error
+[...g2]; // ok
+
+// binding pattern over iterable
+let [x1] = g1; // error
+let [x2] = g2; // ok
+
+// binding rest pattern over iterable
+let [...y1] = g1; // error
+let [...y2] = g2; // ok
+
+// assignment pattern over iterable
+[_] = g1; // error
+[_] = g2; // ok
+
+// assignment rest pattern over iterable
+[..._] = g1; // error
+[..._] = g2; // ok
+
+// for-of over iterable
+for (_ of g1); // error
+for (_ of g2); // ok
+
+async function asyncfn() {
+    // for-await-of over iterable
+    for await (_ of g1); // error
+    for await (_ of g2); // ok
+
+    // for-await-of over asynciterable
+    for await (_ of g4); // error
+    for await (_ of g5); // ok
+}
+
+function* f1(): Generator<number, void, boolean> {
+    // yield* over iterable
+    yield* g1; // error
+    yield* g3; // ok
+}
+
+async function* f2(): AsyncGenerator<number, void, boolean> {
+    // yield* over iterable
+    yield* g1; // error
+    yield* g3; // ok
+
+    // yield* over asynciterable
+    yield* g4; // error
+    yield* g6; // ok
+}
+
+async function f3() {
+    const syncGenerator = function*() {
+        yield 1;
+        yield 2;
+    };
+
+    const o = {[Symbol.asyncIterator]: syncGenerator};
+
+    for await (const x of o) {
+    }
+}
diff --git a/tests/cases/conformance/generators/generatorExplicitReturnType.ts b/tests/cases/conformance/generators/generatorExplicitReturnType.ts
new file mode 100644
index 0000000000000..affcc01146796
--- /dev/null
+++ b/tests/cases/conformance/generators/generatorExplicitReturnType.ts
@@ -0,0 +1,28 @@
+// @target: esnext
+// @strictNullChecks: true
+// @noImplicitReturns: true
+// @noImplicitAny: true
+
+function* g1(): Generator<number, boolean, string> {
+    yield; // error
+    yield "a"; // error
+    const x: number = yield 1; // error
+    return 10; // error
+}
+
+function* g2(): Generator<number, boolean, string> {
+    const x = yield 1;
+    return true;
+}
+
+declare const generator: Generator<number, symbol, string>;
+
+function* g3(): Generator<number, boolean, string> {
+    const x: number = yield* generator; // error
+    return true;
+}
+
+function* g4(): Generator<number, boolean, string> {
+    const x = yield* generator;
+    return true;
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/generators/generatorImplicitAny.ts b/tests/cases/conformance/generators/generatorImplicitAny.ts
new file mode 100644
index 0000000000000..441107defe55c
--- /dev/null
+++ b/tests/cases/conformance/generators/generatorImplicitAny.ts
@@ -0,0 +1,6 @@
+// @target: esnext
+// @strictNullChecks: true
+// @noImplicitReturns: true
+// @noImplicitAny: true
+
+function* g() {}
\ No newline at end of file
diff --git a/tests/cases/conformance/generators/generatorReturnTypeInference.ts b/tests/cases/conformance/generators/generatorReturnTypeInference.ts
new file mode 100644
index 0000000000000..30d35cebd7778
--- /dev/null
+++ b/tests/cases/conformance/generators/generatorReturnTypeInference.ts
@@ -0,0 +1,137 @@
+// @target: esnext
+// @strictNullChecks: true
+// @noImplicitReturns: true
+// @noImplicitAny: true
+
+declare const iterableIterator: IterableIterator<number>;
+declare const generator: Generator<number, string, boolean>;
+declare const never: never;
+
+function* g000() { // Generator<never, void, unknown>
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<undefined, void, unknown>
+    yield;
+}
+
+function* g002() { // Generator<number, void, unknown>
+    yield 1;
+}
+
+function* g003() { // Generator<never, void, undefined>
+    yield* [];
+}
+
+function* g004() { // Generator<number, void, undefined>
+    yield* iterableIterator;
+}
+
+function* g005() { // Generator<number, void, boolean>
+    const x = yield* generator;
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+    yield 1;
+    yield 2;
+}
+
+function* g007() { // Generator<never, void, unknown>
+    yield never;
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+    return 1;
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+    if (Math.random()) return 1;
+    return 2;
+}
+
+function* g104() { // Generator<never, never, unknown>
+    return never;
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+    let a: string = yield 1;
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+    let a: string = yield 1;
+    let b: number = yield 2;
+}
+
+declare function f1(x: string): void;
+declare function f1(x: number): void;
+
+function* g203() { // Generator<number, void, string>
+	const x = f1(yield 1);
+}
+
+declare function f2<T>(x: T): T;
+
+function* g204() { // Generator<number, void, any>
+	const x = f2(yield 1);
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<undefined, void, unknown>
+    yield;
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+    yield 1;
+    return;
+}
+
+function* g303() { // Generator<undefined, string, unknown>
+    yield;
+    return "a";
+}
+
+function* g304() { // Generator<number, string, unknown>
+    yield 1;
+    return "a";
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+    if (Math.random()) yield 1;
+    yield 2;
+    if (Math.random()) return "a";
+    return "b";
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+    const a: "hi" = yield 1;
+    return true;
+}
+
+function* g307<T>() { // Generator<number, T, T>
+    const a: T = yield 0;
+    return a;
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+    const a: T = yield x;
+    return a;
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+    const a: V = yield x;
+    return y;
+}
+
+function* g310() { // Generator<undefined, void, [(1 | undefined)?, (2 | undefined)?]>
+	const [a = 1, b = 2] = yield;
+}
+
+function* g311() { // Generator<undefined, void, string>
+	yield* (function*() {
+		const y: string = yield;
+	})();
+}
diff --git a/tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts b/tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts
new file mode 100644
index 0000000000000..98519e2066372
--- /dev/null
+++ b/tests/cases/conformance/generators/generatorReturnTypeInferenceNonStrict.ts
@@ -0,0 +1,139 @@
+// @target: esnext
+// @strictNullChecks: false
+// @noImplicitReturns: true
+// @noImplicitAny: true
+
+declare const iterableIterator: IterableIterator<number>;
+declare const generator: Generator<number, string, boolean>;
+declare const never: never;
+
+function* g000() { // Generator<never, void, unknown>
+}
+
+// 'yield' iteration type inference
+function* g001() { // Generator<any (implicit), void, unknown>
+    yield;
+}
+
+function* g002() { // Generator<number, void, unknown>
+    yield 1;
+}
+
+function* g003() { // Generator<any (implicit), void, unknown>
+    // NOTE: In strict mode, `[]` produces the type `never[]`.
+    //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
+    yield* [];
+}
+
+function* g004() { // Generator<number, void, undefined>
+    yield* iterableIterator;
+}
+
+function* g005() { // Generator<number, void, boolean>
+    const x = yield* generator;
+}
+
+function* g006() { // Generator<1 | 2, void, unknown>
+    yield 1;
+    yield 2;
+}
+
+function* g007() { // Generator<never, void, unknown>
+    yield never;
+}
+
+// 'return' iteration type inference
+function* g102() { // Generator<never, number, unknown>
+    return 1;
+}
+
+function* g103() { // Generator<never, 1 | 2, unknown>
+    if (Math.random()) return 1;
+    return 2;
+}
+
+function* g104() { // Generator<never, never, unknown>
+    return never;
+}
+
+// 'next' iteration type inference
+function* g201() { // Generator<number, void, string>
+    let a: string = yield 1;
+}
+
+function* g202() { // Generator<1 | 2, void, never>
+    let a: string = yield 1;
+    let b: number = yield 2;
+}
+
+declare function f1(x: string): void;
+declare function f1(x: number): void;
+
+function* g203() { // Generator<number, void, string>
+	const x = f1(yield 1);
+}
+
+declare function f2<T>(x: T): T;
+
+function* g204() { // Generator<number, void, any>
+	const x = f2(yield 1);
+}
+
+// mixed iteration types inference
+
+function* g301() { // Generator<any (implicit), void, unknown>
+    yield;
+    return;
+}
+
+function* g302() { // Generator<number, void, unknown>
+    yield 1;
+    return;
+}
+
+function* g303() { // Generator<any (implicit), string, unknown>
+    yield;
+    return "a";
+}
+
+function* g304() { // Generator<number, string, unknown>
+    yield 1;
+    return "a";
+}
+
+function* g305() { // Generator<1 | 2, "a" | "b", unknown>
+    if (Math.random()) yield 1;
+    yield 2;
+    if (Math.random()) return "a";
+    return "b";
+}
+
+function* g306() { // Generator<number, boolean, "hi">
+    const a: "hi" = yield 1;
+    return true;
+}
+
+function* g307<T>() { // Generator<number, T, T>
+    const a: T = yield 0;
+    return a;
+}
+
+function* g308<T>(x: T) { // Generator<T, T, T>
+    const a: T = yield x;
+    return a;
+}
+
+function* g309<T, U, V>(x: T, y: U) { // Generator<T, U, V>
+    const a: V = yield x;
+    return y;
+}
+
+function* g310() { // Generator<any (implicit), void, [(1 | undefined)?, (2 | undefined)?]>
+	const [a = 1, b = 2] = yield;
+}
+
+function* g311() { // Generator<any (implicit), void, string>
+	yield* (function*() {
+		const y: string = yield;
+	})();
+}