diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 4680ae60a031d..1d9cad8146b47 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1181,8 +1181,9 @@ interface IterationTypesResolver {
     getGlobalIteratorType: (reportErrors: boolean) => GenericType;
     getGlobalIterableType: (reportErrors: boolean) => GenericType;
     getGlobalIterableIteratorType: (reportErrors: boolean) => GenericType;
-    getGlobalBuiltinIteratorType: (reportErrors: boolean) => GenericType;
+    getGlobalIteratorObjectType: (reportErrors: boolean) => GenericType;
     getGlobalGeneratorType: (reportErrors: boolean) => GenericType;
+    getGlobalBuiltinIteratorTypes: () => readonly GenericType[];
     resolveIterationType: (type: Type, errorNode: Node | undefined) => Type | undefined;
     mustHaveANextMethodDiagnostic: DiagnosticMessage;
     mustBeAMethodDiagnostic: DiagnosticMessage;
@@ -2167,8 +2168,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         getGlobalIteratorType: getGlobalAsyncIteratorType,
         getGlobalIterableType: getGlobalAsyncIterableType,
         getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
-        getGlobalBuiltinIteratorType: getGlobalBuiltinAsyncIteratorType,
+        getGlobalIteratorObjectType: getGlobalAsyncIteratorObjectType,
         getGlobalGeneratorType: getGlobalAsyncGeneratorType,
+        getGlobalBuiltinIteratorTypes: getGlobalBuiltinAsyncIteratorTypes,
         resolveIterationType: (type, errorNode) => getAwaitedType(type, errorNode, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member),
         mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
         mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
@@ -2182,8 +2184,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         getGlobalIteratorType,
         getGlobalIterableType,
         getGlobalIterableIteratorType,
-        getGlobalBuiltinIteratorType,
+        getGlobalIteratorObjectType,
         getGlobalGeneratorType,
+        getGlobalBuiltinIteratorTypes,
         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,
@@ -2244,14 +2247,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
     var deferredGlobalIterableType: GenericType | undefined;
     var deferredGlobalIteratorType: GenericType | undefined;
     var deferredGlobalIterableIteratorType: GenericType | undefined;
-    var deferredGlobalBuiltinIteratorType: GenericType | undefined;
+    var deferredGlobalIteratorObjectType: GenericType | undefined;
     var deferredGlobalGeneratorType: GenericType | undefined;
     var deferredGlobalIteratorYieldResultType: GenericType | undefined;
     var deferredGlobalIteratorReturnResultType: GenericType | undefined;
     var deferredGlobalAsyncIterableType: GenericType | undefined;
     var deferredGlobalAsyncIteratorType: GenericType | undefined;
     var deferredGlobalAsyncIterableIteratorType: GenericType | undefined;
-    var deferredGlobalBuiltinAsyncIteratorType: GenericType | undefined;
+    var deferredGlobalBuiltinIteratorTypes: readonly GenericType[] | undefined;
+    var deferredGlobalBuiltinAsyncIteratorTypes: readonly GenericType[] | undefined;
+    var deferredGlobalAsyncIteratorObjectType: GenericType | undefined;
     var deferredGlobalAsyncGeneratorType: GenericType | undefined;
     var deferredGlobalTemplateStringsArrayType: ObjectType | undefined;
     var deferredGlobalImportMetaType: ObjectType;
@@ -12488,6 +12493,18 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & SymbolFlags.Optional));
     }
 
+    function isReferenceToSomeType(type: Type, targets: readonly Type[]) {
+        if (type === undefined || (getObjectFlags(type) & ObjectFlags.Reference) === 0) {
+            return false;
+        }
+        for (const target of targets) {
+            if ((type as TypeReference).target === target) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     function isReferenceToType(type: Type, target: Type) {
         return type !== undefined
             && target !== undefined
@@ -13001,7 +13018,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     links.instantiations.set(getTypeListId(typeParameters), type);
                 }
                 if (type === intrinsicMarkerType && symbol.escapedName === "BuiltinIteratorReturn") {
-                    type = strictBuiltinIteratorReturn ? undefinedType : anyType;
+                    type = getBuiltinIteratorReturnType();
                 }
             }
             else {
@@ -16868,6 +16885,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined;
     }
 
+    function getGlobalBuiltinTypes(typeNames: readonly string[], arity: 0): ObjectType[];
+    function getGlobalBuiltinTypes(typeNames: readonly string[], arity: number): GenericType[];
+    function getGlobalBuiltinTypes(typeNames: readonly string[], arity: number) {
+        let types: Type[] | undefined;
+        for (const typeName of typeNames) {
+            types = append(types, getGlobalType(typeName as __String, arity, /*reportErrors*/ false));
+        }
+        return types ?? emptyArray;
+    }
+
     function getGlobalTypedPropertyDescriptorType() {
         // We always report an error, so store a result in the event we could not resolve the symbol to prevent reporting it multiple times
         return deferredGlobalTypedPropertyDescriptorType ||= getGlobalType("TypedPropertyDescriptor" as __String, /*arity*/ 1, /*reportErrors*/ true) || emptyGenericType;
@@ -16949,8 +16976,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return (deferredGlobalAsyncIterableIteratorType ||= getGlobalType("AsyncIterableIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
     }
 
-    function getGlobalBuiltinAsyncIteratorType(reportErrors: boolean) {
-        return (deferredGlobalBuiltinAsyncIteratorType ||= getGlobalType("BuiltinAsyncIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
+    function getGlobalBuiltinAsyncIteratorTypes() {
+        // NOTE: This list does not include all built-in async iterator types, only those that are likely to be encountered frequently.
+        return deferredGlobalBuiltinAsyncIteratorTypes ??= getGlobalBuiltinTypes(["ReadableStreamAsyncIterator"], 1);
+    }
+
+    function getGlobalAsyncIteratorObjectType(reportErrors: boolean) {
+        return (deferredGlobalAsyncIteratorObjectType ||= getGlobalType("AsyncIteratorObject" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
     }
 
     function getGlobalAsyncGeneratorType(reportErrors: boolean) {
@@ -16969,8 +17001,17 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return (deferredGlobalIterableIteratorType ||= getGlobalType("IterableIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
     }
 
-    function getGlobalBuiltinIteratorType(reportErrors: boolean) {
-        return (deferredGlobalBuiltinIteratorType ||= getGlobalType("BuiltinIterator" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
+    function getBuiltinIteratorReturnType() {
+        return strictBuiltinIteratorReturn ? undefinedType : anyType;
+    }
+
+    function getGlobalBuiltinIteratorTypes() {
+        // NOTE: This list does not include all built-in iterator types, only those that are likely to be encountered frequently.
+        return deferredGlobalBuiltinIteratorTypes ??= getGlobalBuiltinTypes(["ArrayIterator", "MapIterator", "SetIterator", "StringIterator"], 1);
+    }
+
+    function getGlobalIteratorObjectType(reportErrors: boolean) {
+        return (deferredGlobalIteratorObjectType ||= getGlobalType("IteratorObject" as __String, /*arity*/ 3, reportErrors)) || emptyGenericType;
     }
 
     function getGlobalGeneratorType(reportErrors: boolean) {
@@ -44939,18 +44980,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // As an optimization, if the type is an instantiation of the following global type, then
         // just grab its related type arguments:
         // - `Iterable<T, TReturn, TNext>` or `AsyncIterable<T, TReturn, TNext>`
-        // - `BuiltinIterator<T, TReturn, TNext>` or `BuiltinAsyncIterator<T, TReturn, TNext>`
+        // - `IteratorObject<T, TReturn, TNext>` or `AsyncIteratorObject<T, TReturn, TNext>`
         // - `IterableIterator<T, TReturn, TNext>` or `AsyncIterableIterator<T, TReturn, TNext>`
         // - `Generator<T, TReturn, TNext>` or `AsyncGenerator<T, TReturn, TNext>`
         if (
             isReferenceToType(type, resolver.getGlobalIterableType(/*reportErrors*/ false)) ||
-            isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(/*reportErrors*/ false)) ||
+            isReferenceToType(type, resolver.getGlobalIteratorObjectType(/*reportErrors*/ false)) ||
             isReferenceToType(type, resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) ||
             isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))
         ) {
             const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType);
             return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType));
         }
+
+        // As an optimization, if the type is an instantiation of one of the following global types, then
+        // just grab the related type argument:
+        // - `ArrayIterator<T>`
+        // - `MapIterator<T>`
+        // - `SetIterator<T>`
+        // - `StringIterator<T>`
+        // - `ReadableStreamAsyncIterator<T>`
+        if (isReferenceToSomeType(type, resolver.getGlobalBuiltinIteratorTypes())) {
+            const [yieldType] = getTypeArguments(type as GenericType);
+            const returnType = getBuiltinIteratorReturnType();
+            const nextType = unknownType;
+            return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType));
+        }
     }
 
     function getPropertyNameForKnownSymbolName(symbolName: string): __String {
@@ -45067,18 +45122,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         // As an optimization, if the type is an instantiation of one of the following global types,
         // then just grab its related type arguments:
         // - `IterableIterator<T, TReturn, TNext>` or `AsyncIterableIterator<T, TReturn, TNext>`
-        // - `BuiltinIterator<T, TReturn, TNext>` or `BuiltinAsyncIterator<T, TReturn, TNext>`
+        // - `IteratorObject<T, TReturn, TNext>` or `AsyncIteratorObject<T, TReturn, TNext>`
         // - `Iterator<T, TReturn, TNext>` or `AsyncIterator<T, TReturn, TNext>`
         // - `Generator<T, TReturn, TNext>` or `AsyncGenerator<T, TReturn, TNext>`
         if (
-            isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(/*reportErrors*/ false)) ||
             isReferenceToType(type, resolver.getGlobalIterableIteratorType(/*reportErrors*/ false)) ||
             isReferenceToType(type, resolver.getGlobalIteratorType(/*reportErrors*/ false)) ||
+            isReferenceToType(type, resolver.getGlobalIteratorObjectType(/*reportErrors*/ false)) ||
             isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))
         ) {
             const [yieldType, returnType, nextType] = getTypeArguments(type as GenericType);
             return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
         }
+
+        // As an optimization, if the type is an instantiation of one of the following global types, then
+        // just grab the related type argument:
+        // - `ArrayIterator<T>`
+        // - `MapIterator<T>`
+        // - `SetIterator<T>`
+        // - `StringIterator<T>`
+        // - `ReadableStreamAsyncIterator<T>`
+        if (isReferenceToSomeType(type, resolver.getGlobalBuiltinIteratorTypes())) {
+            const [yieldType] = getTypeArguments(type as GenericType);
+            const returnType = getBuiltinIteratorReturnType();
+            const nextType = unknownType;
+            return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
+        }
     }
 
     function isIteratorResult(type: Type, kind: IterationTypeKind.Yield | IterationTypeKind.Return) {
diff --git a/src/lib/dom.asynciterable.generated.d.ts b/src/lib/dom.asynciterable.generated.d.ts
index f9b5ee37473ac..9668532471f0e 100644
--- a/src/lib/dom.asynciterable.generated.d.ts
+++ b/src/lib/dom.asynciterable.generated.d.ts
@@ -2,14 +2,22 @@
 /// Window Async Iterable APIs
 /////////////////////////////
 
+interface FileSystemDirectoryHandleAsyncIterator<T> extends AsyncIteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<T>;
+}
+
 interface FileSystemDirectoryHandle {
-    [Symbol.asyncIterator](): BuiltinAsyncIterator<[string, FileSystemHandle], BuiltinIteratorReturn>;
-    entries(): BuiltinAsyncIterator<[string, FileSystemHandle], BuiltinIteratorReturn>;
-    keys(): BuiltinAsyncIterator<string, BuiltinIteratorReturn>;
-    values(): BuiltinAsyncIterator<FileSystemHandle, BuiltinIteratorReturn>;
+    [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<[string, FileSystemHandle]>;
+    entries(): FileSystemDirectoryHandleAsyncIterator<[string, FileSystemHandle]>;
+    keys(): FileSystemDirectoryHandleAsyncIterator<string>;
+    values(): FileSystemDirectoryHandleAsyncIterator<FileSystemHandle>;
+}
+
+interface ReadableStreamAsyncIterator<T> extends AsyncIteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
 }
 
 interface ReadableStream<R = any> {
-    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): BuiltinAsyncIterator<R, BuiltinIteratorReturn>;
-    values(options?: ReadableStreamIteratorOptions): BuiltinAsyncIterator<R, BuiltinIteratorReturn>;
+    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
+    values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
 }
diff --git a/src/lib/dom.iterable.d.ts b/src/lib/dom.iterable.d.ts
index da56ceae7a647..d6d9975ddbde9 100644
--- a/src/lib/dom.iterable.d.ts
+++ b/src/lib/dom.iterable.d.ts
@@ -1,30 +1,34 @@
 /// <reference lib="dom" />
 
 interface DOMTokenList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
+}
+
+interface HeadersIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): HeadersIterator<T>;
 }
 
 interface Headers {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): HeadersIterator<[string, string]>;
     /**
      * Returns an iterator allowing to go through all key/value pairs contained in this object.
      */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): HeadersIterator<[string, string]>;
     /**
      * Returns an iterator allowing to go through all keys f the key/value pairs contained in this object.
      */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): HeadersIterator<string>;
     /**
      * Returns an iterator allowing to go through all values of the key/value pairs contained in this object.
      */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): HeadersIterator<string>;
 }
 
 interface NodeList {
     /**
      * Returns an array of key, value pairs for every entry in the list
      */
-    entries(): BuiltinIterator<[number, Node], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, Node]>;
     /**
      * Performs the specified action for each node in an list.
      * @param callbackfn  A function that accepts up to three arguments. forEach calls the callbackfn function one time for each element in the list.
@@ -34,21 +38,21 @@ interface NodeList {
     /**
      * Returns an list of keys in the list
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns an list of values in the list
      */
-    values(): BuiltinIterator<Node, BuiltinIteratorReturn>;
+    values(): ArrayIterator<Node>;
 
-    [Symbol.iterator](): BuiltinIterator<Node, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Node>;
 }
 
 interface NodeListOf<TNode extends Node> {
     /**
      * Returns an array of key, value pairs for every entry in the list
      */
-    entries(): BuiltinIterator<[number, TNode], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, TNode]>;
 
     /**
      * Performs the specified action for each node in an list.
@@ -59,55 +63,63 @@ interface NodeListOf<TNode extends Node> {
     /**
      * Returns an list of keys in the list
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the list
      */
-    values(): BuiltinIterator<TNode, BuiltinIteratorReturn>;
+    values(): ArrayIterator<TNode>;
 
-    [Symbol.iterator](): BuiltinIterator<TNode, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<TNode>;
 }
 
 interface HTMLCollectionBase {
-    [Symbol.iterator](): BuiltinIterator<Element, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Element>;
 }
 
 interface HTMLCollectionOf<T extends Element> {
-    [Symbol.iterator](): BuiltinIterator<T, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<T>;
+}
+
+interface FormDataIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): FormDataIterator<T>;
 }
 
 interface FormData {
     /**
      * Returns an array of key, value pairs for every entry in the list
      */
-    entries(): BuiltinIterator<[string, string | File], BuiltinIteratorReturn>;
+    entries(): FormDataIterator<[string, string | File]>;
     /**
      * Returns a list of keys in the list
      */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): FormDataIterator<string>;
     /**
      * Returns a list of values in the list
      */
-    values(): BuiltinIterator<string | File, BuiltinIteratorReturn>;
+    values(): FormDataIterator<string | File>;
+
+    [Symbol.iterator](): FormDataIterator<string | File>;
+}
 
-    [Symbol.iterator](): BuiltinIterator<string | File, BuiltinIteratorReturn>;
+interface URLSearchParamsIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): URLSearchParamsIterator<T>;
 }
 
 interface URLSearchParams {
     /**
      * Returns an array of key, value pairs for every entry in the search params
      */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): URLSearchParamsIterator<[string, string]>;
     /**
      * Returns a list of keys in the search params
      */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): URLSearchParamsIterator<string>;
     /**
      * Returns a list of values in the search params
      */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): URLSearchParamsIterator<string>;
     /**
      * iterate over key/value pairs
      */
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
 }
diff --git a/src/lib/dom.iterable.generated.d.ts b/src/lib/dom.iterable.generated.d.ts
index f23e1534c4638..70c0039ce0d35 100644
--- a/src/lib/dom.iterable.generated.d.ts
+++ b/src/lib/dom.iterable.generated.d.ts
@@ -23,36 +23,36 @@ interface BaseAudioContext {
 }
 
 interface CSSKeyframesRule {
-    [Symbol.iterator](): BuiltinIterator<CSSKeyframeRule, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSKeyframeRule>;
 }
 
 interface CSSNumericArray {
-    [Symbol.iterator](): BuiltinIterator<CSSNumericValue, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSNumericValue], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSNumericValue, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSNumericValue>;
+    entries(): ArrayIterator<[number, CSSNumericValue]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSNumericValue>;
 }
 
 interface CSSRuleList {
-    [Symbol.iterator](): BuiltinIterator<CSSRule, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSRule>;
 }
 
 interface CSSStyleDeclaration {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
 }
 
 interface CSSTransformValue {
-    [Symbol.iterator](): BuiltinIterator<CSSTransformComponent, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSTransformComponent], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSTransformComponent, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSTransformComponent>;
+    entries(): ArrayIterator<[number, CSSTransformComponent]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSTransformComponent>;
 }
 
 interface CSSUnparsedValue {
-    [Symbol.iterator](): BuiltinIterator<CSSUnparsedSegment, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSUnparsedSegment], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSUnparsedSegment, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSUnparsedSegment>;
+    entries(): ArrayIterator<[number, CSSUnparsedSegment]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSUnparsedSegment>;
 }
 
 interface Cache {
@@ -74,72 +74,80 @@ interface CustomStateSet extends Set<string> {
 }
 
 interface DOMRectList {
-    [Symbol.iterator](): BuiltinIterator<DOMRect, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<DOMRect>;
 }
 
 interface DOMStringList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
 }
 
 interface DOMTokenList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, string], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
+    entries(): ArrayIterator<[number, string]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<string>;
 }
 
 interface DataTransferItemList {
-    [Symbol.iterator](): BuiltinIterator<DataTransferItem, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<DataTransferItem>;
 }
 
 interface EventCounts extends ReadonlyMap<string, number> {
 }
 
 interface FileList {
-    [Symbol.iterator](): BuiltinIterator<File, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<File>;
 }
 
 interface FontFaceSet extends Set<FontFace> {
 }
 
+interface FormDataIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): FormDataIterator<T>;
+}
+
 interface FormData {
-    [Symbol.iterator](): BuiltinIterator<[string, FormDataEntryValue], BuiltinIteratorReturn>;
+    [Symbol.iterator](): FormDataIterator<[string, FormDataEntryValue]>;
     /** Returns an array of key, value pairs for every entry in the list. */
-    entries(): BuiltinIterator<[string, FormDataEntryValue], BuiltinIteratorReturn>;
+    entries(): FormDataIterator<[string, FormDataEntryValue]>;
     /** Returns a list of keys in the list. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): FormDataIterator<string>;
     /** Returns a list of values in the list. */
-    values(): BuiltinIterator<FormDataEntryValue, BuiltinIteratorReturn>;
+    values(): FormDataIterator<FormDataEntryValue>;
 }
 
 interface HTMLAllCollection {
-    [Symbol.iterator](): BuiltinIterator<Element, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Element>;
 }
 
 interface HTMLCollectionBase {
-    [Symbol.iterator](): BuiltinIterator<Element, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Element>;
 }
 
 interface HTMLCollectionOf<T extends Element> {
-    [Symbol.iterator](): BuiltinIterator<T, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<T>;
 }
 
 interface HTMLFormElement {
-    [Symbol.iterator](): BuiltinIterator<Element, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Element>;
 }
 
 interface HTMLSelectElement {
-    [Symbol.iterator](): BuiltinIterator<HTMLOptionElement, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<HTMLOptionElement>;
+}
+
+interface HeadersIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): HeadersIterator<T>;
 }
 
 interface Headers {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): HeadersIterator<[string, string]>;
     /** Returns an iterator allowing to go through all key/value pairs contained in this object. */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): HeadersIterator<[string, string]>;
     /** Returns an iterator allowing to go through all keys of the key/value pairs contained in this object. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): HeadersIterator<string>;
     /** Returns an iterator allowing to go through all values of the key/value pairs contained in this object. */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): HeadersIterator<string>;
 }
 
 interface Highlight extends Set<AbstractRange> {
@@ -179,15 +187,19 @@ interface MIDIOutput {
 interface MIDIOutputMap extends ReadonlyMap<string, MIDIOutput> {
 }
 
+interface MediaKeyStatusMapIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): MediaKeyStatusMapIterator<T>;
+}
+
 interface MediaKeyStatusMap {
-    [Symbol.iterator](): BuiltinIterator<[BufferSource, MediaKeyStatus], BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[BufferSource, MediaKeyStatus], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<BufferSource, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<MediaKeyStatus, BuiltinIteratorReturn>;
+    [Symbol.iterator](): MediaKeyStatusMapIterator<[BufferSource, MediaKeyStatus]>;
+    entries(): MediaKeyStatusMapIterator<[BufferSource, MediaKeyStatus]>;
+    keys(): MediaKeyStatusMapIterator<BufferSource>;
+    values(): MediaKeyStatusMapIterator<MediaKeyStatus>;
 }
 
 interface MediaList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
 }
 
 interface MessageEvent<T = any> {
@@ -196,11 +208,11 @@ interface MessageEvent<T = any> {
 }
 
 interface MimeTypeArray {
-    [Symbol.iterator](): BuiltinIterator<MimeType, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<MimeType>;
 }
 
 interface NamedNodeMap {
-    [Symbol.iterator](): BuiltinIterator<Attr, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Attr>;
 }
 
 interface Navigator {
@@ -215,31 +227,31 @@ interface Navigator {
 }
 
 interface NodeList {
-    [Symbol.iterator](): BuiltinIterator<Node, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Node>;
     /** Returns an array of key, value pairs for every entry in the list. */
-    entries(): BuiltinIterator<[number, Node], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, Node]>;
     /** Returns an list of keys in the list. */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /** Returns an list of values in the list. */
-    values(): BuiltinIterator<Node, BuiltinIteratorReturn>;
+    values(): ArrayIterator<Node>;
 }
 
 interface NodeListOf<TNode extends Node> {
-    [Symbol.iterator](): BuiltinIterator<TNode, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<TNode>;
     /** Returns an array of key, value pairs for every entry in the list. */
-    entries(): BuiltinIterator<[number, TNode], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, TNode]>;
     /** Returns an list of keys in the list. */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /** Returns an list of values in the list. */
-    values(): BuiltinIterator<TNode, BuiltinIteratorReturn>;
+    values(): ArrayIterator<TNode>;
 }
 
 interface Plugin {
-    [Symbol.iterator](): BuiltinIterator<MimeType, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<MimeType>;
 }
 
 interface PluginArray {
-    [Symbol.iterator](): BuiltinIterator<Plugin, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Plugin>;
 }
 
 interface RTCRtpTransceiver {
@@ -251,46 +263,50 @@ interface RTCStatsReport extends ReadonlyMap<string, any> {
 }
 
 interface SVGLengthList {
-    [Symbol.iterator](): BuiltinIterator<SVGLength, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<SVGLength>;
 }
 
 interface SVGNumberList {
-    [Symbol.iterator](): BuiltinIterator<SVGNumber, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<SVGNumber>;
 }
 
 interface SVGPointList {
-    [Symbol.iterator](): BuiltinIterator<DOMPoint, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<DOMPoint>;
 }
 
 interface SVGStringList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
 }
 
 interface SVGTransformList {
-    [Symbol.iterator](): BuiltinIterator<SVGTransform, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<SVGTransform>;
 }
 
 interface SourceBufferList {
-    [Symbol.iterator](): BuiltinIterator<SourceBuffer, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<SourceBuffer>;
 }
 
 interface SpeechRecognitionResult {
-    [Symbol.iterator](): BuiltinIterator<SpeechRecognitionAlternative, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<SpeechRecognitionAlternative>;
 }
 
 interface SpeechRecognitionResultList {
-    [Symbol.iterator](): BuiltinIterator<SpeechRecognitionResult, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<SpeechRecognitionResult>;
+}
+
+interface StylePropertyMapReadOnlyIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): StylePropertyMapReadOnlyIterator<T>;
 }
 
 interface StylePropertyMapReadOnly {
-    [Symbol.iterator](): BuiltinIterator<[string, Iterable<CSSStyleValue>], BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[string, Iterable<CSSStyleValue>], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<Iterable<CSSStyleValue>, BuiltinIteratorReturn>;
+    [Symbol.iterator](): StylePropertyMapReadOnlyIterator<[string, Iterable<CSSStyleValue>]>;
+    entries(): StylePropertyMapReadOnlyIterator<[string, Iterable<CSSStyleValue>]>;
+    keys(): StylePropertyMapReadOnlyIterator<string>;
+    values(): StylePropertyMapReadOnlyIterator<Iterable<CSSStyleValue>>;
 }
 
 interface StyleSheetList {
-    [Symbol.iterator](): BuiltinIterator<CSSStyleSheet, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSStyleSheet>;
 }
 
 interface SubtleCrypto {
@@ -309,25 +325,29 @@ interface SubtleCrypto {
 }
 
 interface TextTrackCueList {
-    [Symbol.iterator](): BuiltinIterator<TextTrackCue, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<TextTrackCue>;
 }
 
 interface TextTrackList {
-    [Symbol.iterator](): BuiltinIterator<TextTrack, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<TextTrack>;
 }
 
 interface TouchList {
-    [Symbol.iterator](): BuiltinIterator<Touch, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<Touch>;
+}
+
+interface URLSearchParamsIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): URLSearchParamsIterator<T>;
 }
 
 interface URLSearchParams {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
     /** Returns an array of key, value pairs for every entry in the search params. */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): URLSearchParamsIterator<[string, string]>;
     /** Returns a list of keys in the search params. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): URLSearchParamsIterator<string>;
     /** Returns a list of values in the search params. */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): URLSearchParamsIterator<string>;
 }
 
 interface WEBGL_draw_buffers {
diff --git a/src/lib/es2015.generator.d.ts b/src/lib/es2015.generator.d.ts
index 2397d79dddbd3..435806e925f1e 100644
--- a/src/lib/es2015.generator.d.ts
+++ b/src/lib/es2015.generator.d.ts
@@ -1,6 +1,6 @@
 /// <reference lib="es2015.iterable" />
 
-interface Generator<T = unknown, TReturn = any, TNext = any> extends BuiltinIterator<T, TReturn, TNext> {
+interface Generator<T = unknown, TReturn = any, TNext = any> extends IteratorObject<T, TReturn, TNext> {
     // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
     next(...[value]: [] | [TNext]): IteratorResult<T, TReturn>;
     return(value: TReturn): IteratorResult<T, TReturn>;
diff --git a/src/lib/es2015.iterable.d.ts b/src/lib/es2015.iterable.d.ts
index 00a0ff820ca09..50e2277c533e1 100644
--- a/src/lib/es2015.iterable.d.ts
+++ b/src/lib/es2015.iterable.d.ts
@@ -31,34 +31,48 @@ interface Iterable<T, TReturn = any, TNext = any> {
     [Symbol.iterator](): Iterator<T, TReturn, TNext>;
 }
 
+/**
+ * Describes a user-defined {@link Iterator} that is also iterable.
+ */
 interface IterableIterator<T, TReturn = any, TNext = any> extends Iterator<T, TReturn, TNext> {
     [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
 }
 
-interface BuiltinIterator<T, TReturn = any, TNext = any> extends Iterator<T, TReturn, TNext> {
-    [Symbol.iterator](): BuiltinIterator<T, TReturn, TNext>;
+/**
+ * Describes an {@link Iterator} produced by the runtime that inherits from the intrinsic `Iterator.prototype`.
+ */
+interface IteratorObject<T, TReturn = unknown, TNext = unknown> extends Iterator<T, TReturn, TNext> {
+    [Symbol.iterator](): IteratorObject<T, TReturn, TNext>;
 }
 
+/**
+ * Defines the `TReturn` type used for built-in iterators produced by `Array`, `Map`, `Set`, and others.
+ * This is `undefined` when `strictBuiltInIteratorReturn` is `true`; otherwise, this is `any`.
+ */
 type BuiltinIteratorReturn = intrinsic;
 
+interface ArrayIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): ArrayIterator<T>;
+}
+
 interface Array<T> {
     /** Iterator */
-    [Symbol.iterator](): BuiltinIterator<T, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<T>;
 
     /**
      * Returns an iterable of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, T], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, T]>;
 
     /**
      * Returns an iterable of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns an iterable of values in the array
      */
-    values(): BuiltinIterator<T, BuiltinIteratorReturn>;
+    values(): ArrayIterator<T>;
 }
 
 interface ArrayConstructor {
@@ -79,67 +93,71 @@ interface ArrayConstructor {
 
 interface ReadonlyArray<T> {
     /** Iterator of values in the array. */
-    [Symbol.iterator](): BuiltinIterator<T, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<T>;
 
     /**
      * Returns an iterable of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, T], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, T]>;
 
     /**
      * Returns an iterable of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns an iterable of values in the array
      */
-    values(): BuiltinIterator<T, BuiltinIteratorReturn>;
+    values(): ArrayIterator<T>;
 }
 
 interface IArguments {
     /** Iterator */
-    [Symbol.iterator](): BuiltinIterator<any, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<any>;
+}
+
+interface MapIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): MapIterator<T>;
 }
 
 interface Map<K, V> {
     /** Returns an iterable of entries in the map. */
-    [Symbol.iterator](): BuiltinIterator<[K, V], BuiltinIteratorReturn>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
 
     /**
      * Returns an iterable of key, value pairs for every entry in the map.
      */
-    entries(): BuiltinIterator<[K, V], BuiltinIteratorReturn>;
+    entries(): MapIterator<[K, V]>;
 
     /**
      * Returns an iterable of keys in the map
      */
-    keys(): BuiltinIterator<K, BuiltinIteratorReturn>;
+    keys(): MapIterator<K>;
 
     /**
      * Returns an iterable of values in the map
      */
-    values(): BuiltinIterator<V, BuiltinIteratorReturn>;
+    values(): MapIterator<V>;
 }
 
 interface ReadonlyMap<K, V> {
     /** Returns an iterable of entries in the map. */
-    [Symbol.iterator](): BuiltinIterator<[K, V], BuiltinIteratorReturn>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
 
     /**
      * Returns an iterable of key, value pairs for every entry in the map.
      */
-    entries(): BuiltinIterator<[K, V], BuiltinIteratorReturn>;
+    entries(): MapIterator<[K, V]>;
 
     /**
      * Returns an iterable of keys in the map
      */
-    keys(): BuiltinIterator<K, BuiltinIteratorReturn>;
+    keys(): MapIterator<K>;
 
     /**
      * Returns an iterable of values in the map
      */
-    values(): BuiltinIterator<V, BuiltinIteratorReturn>;
+    values(): MapIterator<V>;
 }
 
 interface MapConstructor {
@@ -153,42 +171,46 @@ interface WeakMapConstructor {
     new <K extends WeakKey, V>(iterable: Iterable<readonly [K, V]>): WeakMap<K, V>;
 }
 
+interface SetIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): SetIterator<T>;
+}
+
 interface Set<T> {
     /** Iterates over values in the set. */
-    [Symbol.iterator](): BuiltinIterator<T, BuiltinIteratorReturn>;
+    [Symbol.iterator](): SetIterator<T>;
     /**
      * Returns an iterable of [v,v] pairs for every value `v` in the set.
      */
-    entries(): BuiltinIterator<[T, T], BuiltinIteratorReturn>;
+    entries(): SetIterator<[T, T]>;
     /**
      * Despite its name, returns an iterable of the values in the set.
      */
-    keys(): BuiltinIterator<T, BuiltinIteratorReturn>;
+    keys(): SetIterator<T>;
 
     /**
      * Returns an iterable of values in the set.
      */
-    values(): BuiltinIterator<T, BuiltinIteratorReturn>;
+    values(): SetIterator<T>;
 }
 
 interface ReadonlySet<T> {
     /** Iterates over values in the set. */
-    [Symbol.iterator](): BuiltinIterator<T, BuiltinIteratorReturn>;
+    [Symbol.iterator](): SetIterator<T>;
 
     /**
      * Returns an iterable of [v,v] pairs for every value `v` in the set.
      */
-    entries(): BuiltinIterator<[T, T], BuiltinIteratorReturn>;
+    entries(): SetIterator<[T, T]>;
 
     /**
      * Despite its name, returns an iterable of the values in the set.
      */
-    keys(): BuiltinIterator<T, BuiltinIteratorReturn>;
+    keys(): SetIterator<T>;
 
     /**
      * Returns an iterable of values in the set.
      */
-    values(): BuiltinIterator<T, BuiltinIteratorReturn>;
+    values(): SetIterator<T>;
 }
 
 interface SetConstructor {
@@ -221,25 +243,29 @@ interface PromiseConstructor {
     race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
 }
 
+interface StringIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): StringIterator<T>;
+}
+
 interface String {
     /** Iterator */
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): StringIterator<string>;
 }
 
 interface Int8Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Int8ArrayConstructor {
@@ -255,19 +281,19 @@ interface Int8ArrayConstructor {
 }
 
 interface Uint8Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Uint8ArrayConstructor {
@@ -283,21 +309,21 @@ interface Uint8ArrayConstructor {
 }
 
 interface Uint8ClampedArray {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
 
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Uint8ClampedArrayConstructor {
@@ -313,21 +339,21 @@ interface Uint8ClampedArrayConstructor {
 }
 
 interface Int16Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
 
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Int16ArrayConstructor {
@@ -343,19 +369,19 @@ interface Int16ArrayConstructor {
 }
 
 interface Uint16Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Uint16ArrayConstructor {
@@ -371,19 +397,19 @@ interface Uint16ArrayConstructor {
 }
 
 interface Int32Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Int32ArrayConstructor {
@@ -399,19 +425,19 @@ interface Int32ArrayConstructor {
 }
 
 interface Uint32Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Uint32ArrayConstructor {
@@ -427,19 +453,19 @@ interface Uint32ArrayConstructor {
 }
 
 interface Float32Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Float32ArrayConstructor {
@@ -455,19 +481,19 @@ interface Float32ArrayConstructor {
 }
 
 interface Float64Array {
-    [Symbol.iterator](): BuiltinIterator<number, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<number>;
     /**
      * Returns an array of key, value pairs for every entry in the array
      */
-    entries(): BuiltinIterator<[number, number], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, number]>;
     /**
      * Returns an list of keys in the array
      */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
     /**
      * Returns an list of values in the array
      */
-    values(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    values(): ArrayIterator<number>;
 }
 
 interface Float64ArrayConstructor {
diff --git a/src/lib/es2018.asyncgenerator.d.ts b/src/lib/es2018.asyncgenerator.d.ts
index e5397a9e7afe2..543cf3a0798f6 100644
--- a/src/lib/es2018.asyncgenerator.d.ts
+++ b/src/lib/es2018.asyncgenerator.d.ts
@@ -1,6 +1,6 @@
 /// <reference lib="es2018.asynciterable" />
 
-interface AsyncGenerator<T = unknown, TReturn = any, TNext = any> extends BuiltinAsyncIterator<T, TReturn, TNext> {
+interface AsyncGenerator<T = unknown, TReturn = any, TNext = any> extends AsyncIteratorObject<T, TReturn, TNext> {
     // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
     next(...[value]: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
     return(value: TReturn | PromiseLike<TReturn>): Promise<IteratorResult<T, TReturn>>;
diff --git a/src/lib/es2018.asynciterable.d.ts b/src/lib/es2018.asynciterable.d.ts
index d5a587aef2767..9db5d98290adb 100644
--- a/src/lib/es2018.asynciterable.d.ts
+++ b/src/lib/es2018.asynciterable.d.ts
@@ -20,10 +20,16 @@ interface AsyncIterable<T, TReturn = any, TNext = any> {
     [Symbol.asyncIterator](): AsyncIterator<T, TReturn, TNext>;
 }
 
+/**
+ * Describes a user-defined {@link AsyncIterator} that is also async iterable.
+ */
 interface AsyncIterableIterator<T, TReturn = any, TNext = any> extends AsyncIterator<T, TReturn, TNext> {
     [Symbol.asyncIterator](): AsyncIterableIterator<T, TReturn, TNext>;
 }
 
-interface BuiltinAsyncIterator<T, TReturn = any, TNext = any> extends AsyncIterator<T, TReturn, TNext> {
-    [Symbol.asyncIterator](): BuiltinAsyncIterator<T, TReturn, TNext>;
+/**
+ * Describes an {@link AsyncIterator} produced by the runtime that inherits from the intrinsic `AsyncIterator.prototype`.
+ */
+interface AsyncIteratorObject<T, TReturn = unknown, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    [Symbol.asyncIterator](): AsyncIteratorObject<T, TReturn, TNext>;
 }
diff --git a/src/lib/es2020.bigint.d.ts b/src/lib/es2020.bigint.d.ts
index c6ee094a332dc..95d2ff245897c 100644
--- a/src/lib/es2020.bigint.d.ts
+++ b/src/lib/es2020.bigint.d.ts
@@ -153,7 +153,7 @@ interface BigInt64Array {
     copyWithin(target: number, start: number, end?: number): this;
 
     /** Yields index, value pairs for every entry in the array. */
-    entries(): BuiltinIterator<[number, bigint], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, bigint]>;
 
     /**
      * Determines whether all the members of an array satisfy the specified test.
@@ -238,7 +238,7 @@ interface BigInt64Array {
     join(separator?: string): string;
 
     /** Yields each index in the array. */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns the index of the last occurrence of a value in an array.
@@ -360,9 +360,9 @@ interface BigInt64Array {
     valueOf(): BigInt64Array;
 
     /** Yields each value in the array. */
-    values(): BuiltinIterator<bigint, BuiltinIteratorReturn>;
+    values(): ArrayIterator<bigint>;
 
-    [Symbol.iterator](): BuiltinIterator<bigint, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<bigint>;
 
     readonly [Symbol.toStringTag]: "BigInt64Array";
 
@@ -425,7 +425,7 @@ interface BigUint64Array {
     copyWithin(target: number, start: number, end?: number): this;
 
     /** Yields index, value pairs for every entry in the array. */
-    entries(): BuiltinIterator<[number, bigint], BuiltinIteratorReturn>;
+    entries(): ArrayIterator<[number, bigint]>;
 
     /**
      * Determines whether all the members of an array satisfy the specified test.
@@ -510,7 +510,7 @@ interface BigUint64Array {
     join(separator?: string): string;
 
     /** Yields each index in the array. */
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
+    keys(): ArrayIterator<number>;
 
     /**
      * Returns the index of the last occurrence of a value in an array.
@@ -632,9 +632,9 @@ interface BigUint64Array {
     valueOf(): BigUint64Array;
 
     /** Yields each value in the array. */
-    values(): BuiltinIterator<bigint, BuiltinIteratorReturn>;
+    values(): ArrayIterator<bigint>;
 
-    [Symbol.iterator](): BuiltinIterator<bigint, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<bigint>;
 
     readonly [Symbol.toStringTag]: "BigUint64Array";
 
diff --git a/src/lib/es2020.string.d.ts b/src/lib/es2020.string.d.ts
index 4d23b7f31941a..19c8f5ebb7dc5 100644
--- a/src/lib/es2020.string.d.ts
+++ b/src/lib/es2020.string.d.ts
@@ -1,4 +1,4 @@
-/// <reference lib="es2015.iterable" />
+/// <reference lib="es2020.symbol.wellknown" />
 
 interface String {
     /**
@@ -6,7 +6,7 @@ interface String {
      * containing the results of that search.
      * @param regexp A variable name or string literal containing the regular expression pattern and flags.
      */
-    matchAll(regexp: RegExp): BuiltinIterator<RegExpExecArray, BuiltinIteratorReturn>;
+    matchAll(regexp: RegExp): RegExpStringIterator<RegExpExecArray>;
 
     /** Converts all alphabetic characters to lowercase, taking into account the host environment's current locale. */
     toLocaleLowerCase(locales?: Intl.LocalesArgument): string;
diff --git a/src/lib/es2020.symbol.wellknown.d.ts b/src/lib/es2020.symbol.wellknown.d.ts
index 07aab68a09265..cdf0349f9b420 100644
--- a/src/lib/es2020.symbol.wellknown.d.ts
+++ b/src/lib/es2020.symbol.wellknown.d.ts
@@ -9,11 +9,15 @@ interface SymbolConstructor {
     readonly matchAll: unique symbol;
 }
 
+interface RegExpStringIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): RegExpStringIterator<T>;
+}
+
 interface RegExp {
     /**
      * Matches a string with this regular expression, and returns an iterable of matches
      * containing the results of that search.
      * @param string A string to search within.
      */
-    [Symbol.matchAll](str: string): BuiltinIterator<RegExpMatchArray, BuiltinIteratorReturn>;
+    [Symbol.matchAll](str: string): RegExpStringIterator<RegExpMatchArray>;
 }
diff --git a/src/lib/es2022.intl.d.ts b/src/lib/es2022.intl.d.ts
index 115e15a528249..e3b1d1d1a8cb3 100644
--- a/src/lib/es2022.intl.d.ts
+++ b/src/lib/es2022.intl.d.ts
@@ -28,6 +28,10 @@ declare namespace Intl {
         granularity: "grapheme" | "word" | "sentence";
     }
 
+    interface SegmentIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+        [Symbol.iterator](): SegmentIterator<T>;
+    }
+
     interface Segments {
         /**
          * Returns an object describing the segment in the original string that includes the code unit at a specified index.
@@ -37,7 +41,7 @@ declare namespace Intl {
         containing(codeUnitIndex?: number): SegmentData;
 
         /** Returns an iterator to iterate over the segments. */
-        [Symbol.iterator](): BuiltinIterator<SegmentData, BuiltinIteratorReturn>;
+        [Symbol.iterator](): SegmentIterator<SegmentData>;
     }
 
     interface SegmentData {
diff --git a/src/lib/esnext.iterator.d.ts b/src/lib/esnext.iterator.d.ts
index 6a8a85eea873e..fe929f59c2206 100644
--- a/src/lib/esnext.iterator.d.ts
+++ b/src/lib/esnext.iterator.d.ts
@@ -7,59 +7,59 @@
 export {};
 
 // Abstract type that allows us to mark `next` as `abstract`
-declare abstract class Iterator<T> { // eslint-disable-line @typescript-eslint/no-unsafe-declaration-merging
-    abstract next(value?: unknown): IteratorResult<T, undefined>;
+declare abstract class Iterator<T, TResult = undefined, TNext = unknown> { // eslint-disable-line @typescript-eslint/no-unsafe-declaration-merging
+    abstract next(value?: TNext): IteratorResult<T, TResult>;
 }
 
-// Merge all members of `BuiltinIterator<T>` into `Iterator<T>`
-interface Iterator<T> extends globalThis.BuiltinIterator<T, undefined, unknown> {}
+// Merge all members of `IteratorObject<T>` into `Iterator<T>`
+interface Iterator<T, TResult, TNext> extends globalThis.IteratorObject<T, TResult, TNext> {}
 
 // Capture the `Iterator` constructor in a type we can use in the `extends` clause of `IteratorConstructor`.
-type BuiltinIteratorConstructor = typeof Iterator;
+type IteratorObjectConstructor = typeof Iterator;
 
 declare global {
-    // Global `BuiltinIterator<T>` interface that can be augmented by polyfills
-    interface BuiltinIterator<T, TReturn, TNext> {
+    // Global `IteratorObject<T, TReturn, TNext>` interface that can be augmented by polyfills
+    interface IteratorObject<T, TReturn, TNext> {
         /**
          * Returns this iterator.
          */
-        [Symbol.iterator](): BuiltinIterator<T, TReturn, TNext>;
+        [Symbol.iterator](): IteratorObject<T, TReturn, TNext>;
 
         /**
          * Creates an iterator whose values are the result of applying the callback to the values from this iterator.
          * @param callbackfn A function that accepts up to two arguments to be used to transform values from the underlying iterator.
          */
-        map<U>(callbackfn: (value: T, index: number) => U): BuiltinIterator<U, undefined>;
+        map<U>(callbackfn: (value: T, index: number) => U): IteratorObject<U, undefined, unknown>;
 
         /**
          * Creates an iterator whose values are those from this iterator for which the provided predicate returns true.
          * @param predicate A function that accepts up to two arguments to be used to test values from the underlying iterator.
          */
-        filter<S extends T>(predicate: (value: T, index: number) => value is S): BuiltinIterator<S, undefined>;
+        filter<S extends T>(predicate: (value: T, index: number) => value is S): IteratorObject<S, undefined, unknown>;
 
         /**
          * Creates an iterator whose values are those from this iterator for which the provided predicate returns true.
          * @param predicate A function that accepts up to two arguments to be used to test values from the underlying iterator.
          */
-        filter(predicate: (value: T, index: number) => unknown): BuiltinIterator<T, undefined>;
+        filter(predicate: (value: T, index: number) => unknown): IteratorObject<T, undefined, unknown>;
 
         /**
          * Creates an iterator whose values are the values from this iterator, stopping once the provided limit is reached.
          * @param limit The maximum number of values to yield.
          */
-        take(limit: number): BuiltinIterator<T, undefined>;
+        take(limit: number): IteratorObject<T, undefined, unknown>;
 
         /**
          * Creates an iterator whose values are the values from this iterator after skipping the provided count.
          * @param count The number of values to drop.
          */
-        drop(count: number): BuiltinIterator<T, undefined>;
+        drop(count: number): IteratorObject<T, undefined, unknown>;
 
         /**
          * Creates an iterator whose values are the result of applying the callback to the values from this iterator and then flattening the resulting iterators or iterables.
          * @param callback A function that accepts up to two arguments to be used to transform values from the underlying iterator into new iterators or iterables to be flattened into the result.
          */
-        flatMap<U>(callback: (value: T, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>): BuiltinIterator<U, undefined>;
+        flatMap<U>(callback: (value: T, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>): IteratorObject<U, undefined, unknown>;
 
         /**
          * Calls the specified callback function for all the elements in this iterator. The return value of the callback function is the accumulated result, and is provided as an argument in the next call to the callback function.
@@ -117,13 +117,13 @@ declare global {
     }
 
     // Global `IteratorConstructor` interface that can be augmented by polyfills
-    interface IteratorConstructor extends BuiltinIteratorConstructor {
+    interface IteratorConstructor extends IteratorObjectConstructor {
         /**
          * Creates a native iterator from an iterator or iterable object.
          * Returns its input if the input already inherits from the built-in Iterator class.
          * @param value An iterator or iterable object to convert a native iterator.
          */
-        from<T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>): BuiltinIterator<T, undefined>;
+        from<T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>): IteratorObject<T, undefined, unknown>;
     }
 
     var Iterator: IteratorConstructor;
diff --git a/src/lib/webworker.asynciterable.generated.d.ts b/src/lib/webworker.asynciterable.generated.d.ts
index cd2b63eb5d790..d446d4f089b3e 100644
--- a/src/lib/webworker.asynciterable.generated.d.ts
+++ b/src/lib/webworker.asynciterable.generated.d.ts
@@ -2,14 +2,22 @@
 /// Worker Async Iterable APIs
 /////////////////////////////
 
+interface FileSystemDirectoryHandleAsyncIterator<T> extends AsyncIteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<T>;
+}
+
 interface FileSystemDirectoryHandle {
-    [Symbol.asyncIterator](): BuiltinAsyncIterator<[string, FileSystemHandle], BuiltinIteratorReturn>;
-    entries(): BuiltinAsyncIterator<[string, FileSystemHandle], BuiltinIteratorReturn>;
-    keys(): BuiltinAsyncIterator<string, BuiltinIteratorReturn>;
-    values(): BuiltinAsyncIterator<FileSystemHandle, BuiltinIteratorReturn>;
+    [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<[string, FileSystemHandle]>;
+    entries(): FileSystemDirectoryHandleAsyncIterator<[string, FileSystemHandle]>;
+    keys(): FileSystemDirectoryHandleAsyncIterator<string>;
+    values(): FileSystemDirectoryHandleAsyncIterator<FileSystemHandle>;
+}
+
+interface ReadableStreamAsyncIterator<T> extends AsyncIteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
 }
 
 interface ReadableStream<R = any> {
-    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): BuiltinAsyncIterator<R, BuiltinIteratorReturn>;
-    values(options?: ReadableStreamIteratorOptions): BuiltinAsyncIterator<R, BuiltinIteratorReturn>;
+    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
+    values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
 }
diff --git a/src/lib/webworker.iterable.generated.d.ts b/src/lib/webworker.iterable.generated.d.ts
index 46628a75b82e1..ad811e2b8b19f 100644
--- a/src/lib/webworker.iterable.generated.d.ts
+++ b/src/lib/webworker.iterable.generated.d.ts
@@ -8,24 +8,24 @@ interface AbortSignal {
 }
 
 interface CSSNumericArray {
-    [Symbol.iterator](): BuiltinIterator<CSSNumericValue, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSNumericValue], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSNumericValue, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSNumericValue>;
+    entries(): ArrayIterator<[number, CSSNumericValue]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSNumericValue>;
 }
 
 interface CSSTransformValue {
-    [Symbol.iterator](): BuiltinIterator<CSSTransformComponent, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSTransformComponent], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSTransformComponent, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSTransformComponent>;
+    entries(): ArrayIterator<[number, CSSTransformComponent]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSTransformComponent>;
 }
 
 interface CSSUnparsedValue {
-    [Symbol.iterator](): BuiltinIterator<CSSUnparsedSegment, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSUnparsedSegment], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSUnparsedSegment, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSUnparsedSegment>;
+    entries(): ArrayIterator<[number, CSSUnparsedSegment]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSUnparsedSegment>;
 }
 
 interface Cache {
@@ -44,34 +44,42 @@ interface CanvasPathDrawingStyles {
 }
 
 interface DOMStringList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
 }
 
 interface FileList {
-    [Symbol.iterator](): BuiltinIterator<File, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<File>;
 }
 
 interface FontFaceSet extends Set<FontFace> {
 }
 
+interface FormDataIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): FormDataIterator<T>;
+}
+
 interface FormData {
-    [Symbol.iterator](): BuiltinIterator<[string, FormDataEntryValue], BuiltinIteratorReturn>;
+    [Symbol.iterator](): FormDataIterator<[string, FormDataEntryValue]>;
     /** Returns an array of key, value pairs for every entry in the list. */
-    entries(): BuiltinIterator<[string, FormDataEntryValue], BuiltinIteratorReturn>;
+    entries(): FormDataIterator<[string, FormDataEntryValue]>;
     /** Returns a list of keys in the list. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): FormDataIterator<string>;
     /** Returns a list of values in the list. */
-    values(): BuiltinIterator<FormDataEntryValue, BuiltinIteratorReturn>;
+    values(): FormDataIterator<FormDataEntryValue>;
+}
+
+interface HeadersIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): HeadersIterator<T>;
 }
 
 interface Headers {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): HeadersIterator<[string, string]>;
     /** Returns an iterator allowing to go through all key/value pairs contained in this object. */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): HeadersIterator<[string, string]>;
     /** Returns an iterator allowing to go through all keys of the key/value pairs contained in this object. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): HeadersIterator<string>;
     /** Returns an iterator allowing to go through all values of the key/value pairs contained in this object. */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): HeadersIterator<string>;
 }
 
 interface IDBDatabase {
@@ -99,11 +107,15 @@ interface MessageEvent<T = any> {
     initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: Iterable<MessagePort>): void;
 }
 
+interface StylePropertyMapReadOnlyIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): StylePropertyMapReadOnlyIterator<T>;
+}
+
 interface StylePropertyMapReadOnly {
-    [Symbol.iterator](): BuiltinIterator<[string, Iterable<CSSStyleValue>], BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[string, Iterable<CSSStyleValue>], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<Iterable<CSSStyleValue>, BuiltinIteratorReturn>;
+    [Symbol.iterator](): StylePropertyMapReadOnlyIterator<[string, Iterable<CSSStyleValue>]>;
+    entries(): StylePropertyMapReadOnlyIterator<[string, Iterable<CSSStyleValue>]>;
+    keys(): StylePropertyMapReadOnlyIterator<string>;
+    values(): StylePropertyMapReadOnlyIterator<Iterable<CSSStyleValue>>;
 }
 
 interface SubtleCrypto {
@@ -121,14 +133,18 @@ interface SubtleCrypto {
     unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKey>;
 }
 
+interface URLSearchParamsIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): URLSearchParamsIterator<T>;
+}
+
 interface URLSearchParams {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
     /** Returns an array of key, value pairs for every entry in the search params. */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): URLSearchParamsIterator<[string, string]>;
     /** Returns a list of keys in the search params. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): URLSearchParamsIterator<string>;
     /** Returns a list of values in the search params. */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): URLSearchParamsIterator<string>;
 }
 
 interface WEBGL_draw_buffers {
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt b/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt
index bc8d50891705d..5dbe9fe2b5312 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt
+++ b/tests/baselines/reference/ES5For-ofTypeCheck10.errors.txt
@@ -1,10 +1,10 @@
 ES5For-ofTypeCheck10.ts(9,6): error TS2585: 'Symbol' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later.
-ES5For-ofTypeCheck10.ts(14,15): error TS2495: Type 'StringIterator' is not an array type or a string type.
+ES5For-ofTypeCheck10.ts(14,15): error TS2495: Type 'MyStringIterator' is not an array type or a string type.
 
 
 ==== ES5For-ofTypeCheck10.ts (2 errors) ====
     // In ES3/5, you cannot for...of over an arbitrary iterable.
-    class StringIterator {
+    class MyStringIterator {
         next() {
             return {
                 done: true,
@@ -18,6 +18,6 @@ ES5For-ofTypeCheck10.ts(14,15): error TS2495: Type 'StringIterator' is not an ar
         }
     }
     
-    for (var v of new StringIterator) { }
-                  ~~~~~~~~~~~~~~~~~~
-!!! error TS2495: Type 'StringIterator' is not an array type or a string type.
\ No newline at end of file
+    for (var v of new MyStringIterator) { }
+                  ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2495: Type 'MyStringIterator' is not an array type or a string type.
\ No newline at end of file
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.js b/tests/baselines/reference/ES5For-ofTypeCheck10.js
index efe4b27967d11..2537d78d12f63 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck10.js
+++ b/tests/baselines/reference/ES5For-ofTypeCheck10.js
@@ -2,7 +2,7 @@
 
 //// [ES5For-ofTypeCheck10.ts]
 // In ES3/5, you cannot for...of over an arbitrary iterable.
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: true,
@@ -14,24 +14,24 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [ES5For-ofTypeCheck10.js]
 // In ES3/5, you cannot for...of over an arbitrary iterable.
-var StringIterator = /** @class */ (function () {
-    function StringIterator() {
+var MyStringIterator = /** @class */ (function () {
+    function MyStringIterator() {
     }
-    StringIterator.prototype.next = function () {
+    MyStringIterator.prototype.next = function () {
         return {
             done: true,
             value: ""
         };
     };
-    StringIterator.prototype[Symbol.iterator] = function () {
+    MyStringIterator.prototype[Symbol.iterator] = function () {
         return this;
     };
-    return StringIterator;
+    return MyStringIterator;
 }());
-for (var _i = 0, _a = new StringIterator; _i < _a.length; _i++) {
+for (var _i = 0, _a = new MyStringIterator; _i < _a.length; _i++) {
     var v = _a[_i];
 }
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.symbols b/tests/baselines/reference/ES5For-ofTypeCheck10.symbols
index d6764447cfbeb..f301fbbf6a7b6 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck10.symbols
+++ b/tests/baselines/reference/ES5For-ofTypeCheck10.symbols
@@ -2,11 +2,11 @@
 
 === ES5For-ofTypeCheck10.ts ===
 // In ES3/5, you cannot for...of over an arbitrary iterable.
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(ES5For-ofTypeCheck10.ts, 1, 22))
+>next : Symbol(MyStringIterator.next, Decl(ES5For-ofTypeCheck10.ts, 1, 24))
 
         return {
             done: true,
@@ -18,14 +18,14 @@ class StringIterator {
         };
     }
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(ES5For-ofTypeCheck10.ts, 7, 5))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(ES5For-ofTypeCheck10.ts, 7, 5))
 
         return this;
->this : Symbol(StringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0))
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(ES5For-ofTypeCheck10.ts, 13, 8))
->StringIterator : Symbol(StringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(ES5For-ofTypeCheck10.ts, 0, 0))
 
diff --git a/tests/baselines/reference/ES5For-ofTypeCheck10.types b/tests/baselines/reference/ES5For-ofTypeCheck10.types
index 65d626c82eec8..5cb80fe9f9782 100644
--- a/tests/baselines/reference/ES5For-ofTypeCheck10.types
+++ b/tests/baselines/reference/ES5For-ofTypeCheck10.types
@@ -2,9 +2,9 @@
 
 === ES5For-ofTypeCheck10.ts ===
 // In ES3/5, you cannot for...of over an arbitrary iterable.
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => { done: boolean; value: string; }
@@ -44,11 +44,11 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
 >  : ^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/YieldStarExpression4_es6.types b/tests/baselines/reference/YieldStarExpression4_es6.types
index c2c8b54fde262..186939d83832f 100644
--- a/tests/baselines/reference/YieldStarExpression4_es6.types
+++ b/tests/baselines/reference/YieldStarExpression4_es6.types
@@ -2,8 +2,8 @@
 
 === YieldStarExpression4_es6.ts ===
 function *g() {
->g : () => Generator<any, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g : () => Generator<any, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield * [];
 >yield * [] : any
diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.types b/tests/baselines/reference/argumentsObjectIterator02_ES6.types
index c192ab9617b08..f77b4259cf9cd 100644
--- a/tests/baselines/reference/argumentsObjectIterator02_ES6.types
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.types
@@ -12,10 +12,10 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 >  : ^^^^^^
 
     let blah = arguments[Symbol.iterator];
->blah : () => BuiltinIterator<any, BuiltinIteratorReturn>
->     : ^^^^^^                                           
->arguments[Symbol.iterator] : () => BuiltinIterator<any, BuiltinIteratorReturn>
->                           : ^^^^^^                                           
+>blah : () => ArrayIterator<any>
+>     : ^^^^^^                  
+>arguments[Symbol.iterator] : () => ArrayIterator<any>
+>                           : ^^^^^^                  
 >arguments : IArguments
 >          : ^^^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -33,10 +33,10 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
 
     for (let arg of blah()) {
 >arg : any
->blah() : BuiltinIterator<any, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->blah : () => BuiltinIterator<any, BuiltinIteratorReturn>
->     : ^^^^^^                                           
+>blah() : ArrayIterator<any>
+>       : ^^^^^^^^^^^^^^^^^^
+>blah : () => ArrayIterator<any>
+>     : ^^^^^^                  
 
         result.push(arg + arg);
 >result.push(arg + arg) : number
diff --git a/tests/baselines/reference/arrayFrom.types b/tests/baselines/reference/arrayFrom.types
index 8829708cedd67..4350bcd3047e3 100644
--- a/tests/baselines/reference/arrayFrom.types
+++ b/tests/baselines/reference/arrayFrom.types
@@ -83,14 +83,14 @@ const result2: A[] = Array.from(inputA.values());
 >      : ^^^^^^^^^^^^^^^^
 >from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >     : ^^^ ^^         ^^            ^^^   ^^^ ^^ ^^         ^^            ^^     ^^                      ^^       ^^^   ^^^   ^^^ ^^        ^^                          ^^^   ^^^ ^^ ^^        ^^                          ^^     ^^                      ^^       ^^^   ^^^   ^^^
->inputA.values() : BuiltinIterator<A, any, any>
->                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->inputA.values : () => BuiltinIterator<A, any, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>inputA.values() : ArrayIterator<A>
+>                : ^^^^^^^^^^^^^^^^
+>inputA.values : () => ArrayIterator<A>
+>              : ^^^^^^^^^^^^^^^^^^^^^^
 >inputA : A[]
 >       : ^^^
->values : () => BuiltinIterator<A, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<A>
+>       : ^^^^^^^^^^^^^^^^^^^^^^
 
 const result3: B[] = Array.from(inputA.values()); // expect error
 >result3 : B[]
@@ -103,14 +103,14 @@ const result3: B[] = Array.from(inputA.values()); // expect error
 >      : ^^^^^^^^^^^^^^^^
 >from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >     : ^^^ ^^         ^^            ^^^   ^^^ ^^ ^^         ^^            ^^     ^^                      ^^       ^^^   ^^^   ^^^ ^^        ^^                          ^^^   ^^^ ^^ ^^        ^^                          ^^     ^^                      ^^       ^^^   ^^^   ^^^
->inputA.values() : BuiltinIterator<A, any, any>
->                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->inputA.values : () => BuiltinIterator<A, any, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>inputA.values() : ArrayIterator<A>
+>                : ^^^^^^^^^^^^^^^^
+>inputA.values : () => ArrayIterator<A>
+>              : ^^^^^^^^^^^^^^^^^^^^^^
 >inputA : A[]
 >       : ^^^
->values : () => BuiltinIterator<A, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<A>
+>       : ^^^^^^^^^^^^^^^^^^^^^^
 
 const result4: A[] = Array.from(inputB, ({ b }): A => ({ a: b }));
 >result4 : A[]
diff --git a/tests/baselines/reference/builtinIterator.errors.txt b/tests/baselines/reference/builtinIterator.errors.txt
index 26749ea24a683..c4fc043ee366e 100644
--- a/tests/baselines/reference/builtinIterator.errors.txt
+++ b/tests/baselines/reference/builtinIterator.errors.txt
@@ -1,19 +1,19 @@
 builtinIterator.ts(38,1): error TS2511: Cannot create an instance of an abstract class.
-builtinIterator.ts(40,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member next from class 'Iterator<number>'.
-builtinIterator.ts(44,3): error TS2416: Property 'next' in type 'BadIterator1' is not assignable to the same property in base type 'Iterator<number>'.
+builtinIterator.ts(40,7): error TS2515: Non-abstract class 'C' does not implement inherited abstract member next from class 'Iterator<number, undefined, unknown>'.
+builtinIterator.ts(44,3): error TS2416: Property 'next' in type 'BadIterator1' is not assignable to the same property in base type 'Iterator<number, undefined, unknown>'.
   Type '() => { readonly done: false; readonly value: 0; } | { readonly done: true; readonly value: "a string"; }' is not assignable to type '(value?: unknown) => IteratorResult<number, undefined>'.
     Type '{ readonly done: false; readonly value: 0; } | { readonly done: true; readonly value: "a string"; }' is not assignable to type 'IteratorResult<number, undefined>'.
       Type '{ readonly done: true; readonly value: "a string"; }' is not assignable to type 'IteratorResult<number, undefined>'.
         Type '{ readonly done: true; readonly value: "a string"; }' is not assignable to type 'IteratorReturnResult<undefined>'.
           Types of property 'value' are incompatible.
             Type '"a string"' is not assignable to type 'undefined'.
-builtinIterator.ts(54,3): error TS2416: Property 'next' in type 'BadIterator2' is not assignable to the same property in base type 'Iterator<number>'.
+builtinIterator.ts(54,3): error TS2416: Property 'next' in type 'BadIterator2' is not assignable to the same property in base type 'Iterator<number, undefined, unknown>'.
   Type '() => { done: boolean; value: number; }' is not assignable to type '(value?: unknown) => IteratorResult<number, undefined>'.
     Type '{ done: boolean; value: number; }' is not assignable to type 'IteratorResult<number, undefined>'.
       Type '{ done: boolean; value: number; }' is not assignable to type 'IteratorYieldResult<number>'.
         Types of property 'done' are incompatible.
           Type 'boolean' is not assignable to type 'false'.
-builtinIterator.ts(60,3): error TS2416: Property 'next' in type 'BadIterator3' is not assignable to the same property in base type 'Iterator<number>'.
+builtinIterator.ts(60,3): error TS2416: Property 'next' in type 'BadIterator3' is not assignable to the same property in base type 'Iterator<number, undefined, unknown>'.
   Type '() => { done: boolean; value: number; } | { done: boolean; value: string; }' is not assignable to type '(value?: unknown) => IteratorResult<number, undefined>'.
     Type '{ done: boolean; value: number; } | { done: boolean; value: string; }' is not assignable to type 'IteratorResult<number, undefined>'.
       Type '{ done: boolean; value: number; }' is not assignable to type 'IteratorResult<number, undefined>'.
@@ -84,13 +84,13 @@ builtinIterator.ts(73,35): error TS2322: Type 'Generator<string, number, boolean
     
     class C extends Iterator<number> {}
           ~
-!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member next from class 'Iterator<number>'.
+!!! error TS2515: Non-abstract class 'C' does not implement inherited abstract member next from class 'Iterator<number, undefined, unknown>'.
     
     // it's unfortunate that these are an error
     class BadIterator1 extends Iterator<number> {
       next() {
       ~~~~
-!!! error TS2416: Property 'next' in type 'BadIterator1' is not assignable to the same property in base type 'Iterator<number>'.
+!!! error TS2416: Property 'next' in type 'BadIterator1' is not assignable to the same property in base type 'Iterator<number, undefined, unknown>'.
 !!! error TS2416:   Type '() => { readonly done: false; readonly value: 0; } | { readonly done: true; readonly value: "a string"; }' is not assignable to type '(value?: unknown) => IteratorResult<number, undefined>'.
 !!! error TS2416:     Type '{ readonly done: false; readonly value: 0; } | { readonly done: true; readonly value: "a string"; }' is not assignable to type 'IteratorResult<number, undefined>'.
 !!! error TS2416:       Type '{ readonly done: true; readonly value: "a string"; }' is not assignable to type 'IteratorResult<number, undefined>'.
@@ -108,7 +108,7 @@ builtinIterator.ts(73,35): error TS2322: Type 'Generator<string, number, boolean
     class BadIterator2 extends Iterator<number> {
       next() {
       ~~~~
-!!! error TS2416: Property 'next' in type 'BadIterator2' is not assignable to the same property in base type 'Iterator<number>'.
+!!! error TS2416: Property 'next' in type 'BadIterator2' is not assignable to the same property in base type 'Iterator<number, undefined, unknown>'.
 !!! error TS2416:   Type '() => { done: boolean; value: number; }' is not assignable to type '(value?: unknown) => IteratorResult<number, undefined>'.
 !!! error TS2416:     Type '{ done: boolean; value: number; }' is not assignable to type 'IteratorResult<number, undefined>'.
 !!! error TS2416:       Type '{ done: boolean; value: number; }' is not assignable to type 'IteratorYieldResult<number>'.
@@ -121,7 +121,7 @@ builtinIterator.ts(73,35): error TS2322: Type 'Generator<string, number, boolean
     class BadIterator3 extends Iterator<number> {
       next() {
       ~~~~
-!!! error TS2416: Property 'next' in type 'BadIterator3' is not assignable to the same property in base type 'Iterator<number>'.
+!!! error TS2416: Property 'next' in type 'BadIterator3' is not assignable to the same property in base type 'Iterator<number, undefined, unknown>'.
 !!! error TS2416:   Type '() => { done: boolean; value: number; } | { done: boolean; value: string; }' is not assignable to type '(value?: unknown) => IteratorResult<number, undefined>'.
 !!! error TS2416:     Type '{ done: boolean; value: number; } | { done: boolean; value: string; }' is not assignable to type 'IteratorResult<number, undefined>'.
 !!! error TS2416:       Type '{ done: boolean; value: number; }' is not assignable to type 'IteratorResult<number, undefined>'.
@@ -149,7 +149,7 @@ builtinIterator.ts(73,35): error TS2322: Type 'Generator<string, number, boolean
 !!! error TS2345:               Type '[undefined]' is not assignable to type '[boolean]'.
 !!! error TS2345:                 Type 'undefined' is not assignable to type 'boolean'.
     
-    declare const iter2: BuiltinIterator<string, BuiltinIteratorReturn>;
+    declare const iter2: IteratorObject<string>;
     const iter3 = iter2.flatMap(() => g1);
                                       ~~
 !!! error TS2322: Type 'Generator<string, number, boolean>' is not assignable to type 'Iterator<string, unknown, undefined> | Iterable<string, unknown, undefined>'.
diff --git a/tests/baselines/reference/builtinIterator.js b/tests/baselines/reference/builtinIterator.js
index 192d53b106b25..a22b5baa673ec 100644
--- a/tests/baselines/reference/builtinIterator.js
+++ b/tests/baselines/reference/builtinIterator.js
@@ -72,7 +72,7 @@ class BadIterator3 extends Iterator<number> {
 declare const g1: Generator<string, number, boolean>;
 const iter1 = Iterator.from(g1);
 
-declare const iter2: BuiltinIterator<string, BuiltinIteratorReturn>;
+declare const iter2: IteratorObject<string>;
 const iter3 = iter2.flatMap(() => g1);
 
 //// [builtinIterator.js]
diff --git a/tests/baselines/reference/builtinIterator.symbols b/tests/baselines/reference/builtinIterator.symbols
index 4c8795a5a1dfe..00c37ef1982b3 100644
--- a/tests/baselines/reference/builtinIterator.symbols
+++ b/tests/baselines/reference/builtinIterator.symbols
@@ -9,16 +9,16 @@ const iterator = Iterator.from([0, 1, 2]);
 
 const mapped = iterator.map(String);
 >mapped : Symbol(mapped, Decl(builtinIterator.ts, 2, 5))
->iterator.map : Symbol(BuiltinIterator.map, Decl(lib.esnext.iterator.d.ts, --, --))
+>iterator.map : Symbol(IteratorObject.map, Decl(lib.esnext.iterator.d.ts, --, --))
 >iterator : Symbol(iterator, Decl(builtinIterator.ts, 0, 5))
->map : Symbol(BuiltinIterator.map, Decl(lib.esnext.iterator.d.ts, --, --))
+>map : Symbol(IteratorObject.map, Decl(lib.esnext.iterator.d.ts, --, --))
 >String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 7 more)
 
 const filtered = iterator.filter(x => x > 0);
 >filtered : Symbol(filtered, Decl(builtinIterator.ts, 4, 5))
->iterator.filter : Symbol(BuiltinIterator.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
+>iterator.filter : Symbol(IteratorObject.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
 >iterator : Symbol(iterator, Decl(builtinIterator.ts, 0, 5))
->filter : Symbol(BuiltinIterator.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
+>filter : Symbol(IteratorObject.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
 >x : Symbol(x, Decl(builtinIterator.ts, 4, 33))
 >x : Symbol(x, Decl(builtinIterator.ts, 4, 33))
 
@@ -32,9 +32,9 @@ function isZero(x: number): x is 0 {
 }
 const zero = iterator.filter(isZero);
 >zero : Symbol(zero, Decl(builtinIterator.ts, 9, 5))
->iterator.filter : Symbol(BuiltinIterator.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
+>iterator.filter : Symbol(IteratorObject.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
 >iterator : Symbol(iterator, Decl(builtinIterator.ts, 0, 5))
->filter : Symbol(BuiltinIterator.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
+>filter : Symbol(IteratorObject.filter, Decl(lib.esnext.iterator.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
 >isZero : Symbol(isZero, Decl(builtinIterator.ts, 4, 45))
 
 const iteratorFromBare = Iterator.from({
@@ -69,18 +69,18 @@ function* gen() {
 
 const mappedGen = gen().map(x => x === 0 ? "zero" : "other");
 >mappedGen : Symbol(mappedGen, Decl(builtinIterator.ts, 25, 5))
->gen().map : Symbol(BuiltinIterator.map, Decl(lib.esnext.iterator.d.ts, --, --))
+>gen().map : Symbol(IteratorObject.map, Decl(lib.esnext.iterator.d.ts, --, --))
 >gen : Symbol(gen, Decl(builtinIterator.ts, 18, 3))
->map : Symbol(BuiltinIterator.map, Decl(lib.esnext.iterator.d.ts, --, --))
+>map : Symbol(IteratorObject.map, Decl(lib.esnext.iterator.d.ts, --, --))
 >x : Symbol(x, Decl(builtinIterator.ts, 25, 28))
 >x : Symbol(x, Decl(builtinIterator.ts, 25, 28))
 
 const mappedValues = [0, 1, 2].values().map(x => x === 0 ? "zero" : "other");
 >mappedValues : Symbol(mappedValues, Decl(builtinIterator.ts, 27, 5))
->[0, 1, 2].values().map : Symbol(BuiltinIterator.map, Decl(lib.esnext.iterator.d.ts, --, --))
+>[0, 1, 2].values().map : Symbol(IteratorObject.map, Decl(lib.esnext.iterator.d.ts, --, --))
 >[0, 1, 2].values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --))
 >values : Symbol(Array.values, Decl(lib.es2015.iterable.d.ts, --, --))
->map : Symbol(BuiltinIterator.map, Decl(lib.esnext.iterator.d.ts, --, --))
+>map : Symbol(IteratorObject.map, Decl(lib.esnext.iterator.d.ts, --, --))
 >x : Symbol(x, Decl(builtinIterator.ts, 27, 44))
 >x : Symbol(x, Decl(builtinIterator.ts, 27, 44))
 
@@ -182,15 +182,14 @@ const iter1 = Iterator.from(g1);
 >from : Symbol(IteratorConstructor.from, Decl(lib.esnext.iterator.d.ts, --, --))
 >g1 : Symbol(g1, Decl(builtinIterator.ts, 68, 13))
 
-declare const iter2: BuiltinIterator<string, BuiltinIteratorReturn>;
+declare const iter2: IteratorObject<string>;
 >iter2 : Symbol(iter2, Decl(builtinIterator.ts, 71, 13))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+>IteratorObject : Symbol(IteratorObject, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
 
 const iter3 = iter2.flatMap(() => g1);
 >iter3 : Symbol(iter3, Decl(builtinIterator.ts, 72, 5))
->iter2.flatMap : Symbol(BuiltinIterator.flatMap, Decl(lib.esnext.iterator.d.ts, --, --))
+>iter2.flatMap : Symbol(IteratorObject.flatMap, Decl(lib.esnext.iterator.d.ts, --, --))
 >iter2 : Symbol(iter2, Decl(builtinIterator.ts, 71, 13))
->flatMap : Symbol(BuiltinIterator.flatMap, Decl(lib.esnext.iterator.d.ts, --, --))
+>flatMap : Symbol(IteratorObject.flatMap, Decl(lib.esnext.iterator.d.ts, --, --))
 >g1 : Symbol(g1, Decl(builtinIterator.ts, 68, 13))
 
diff --git a/tests/baselines/reference/builtinIterator.types b/tests/baselines/reference/builtinIterator.types
index 7ee1560178e54..75d934cddae8c 100644
--- a/tests/baselines/reference/builtinIterator.types
+++ b/tests/baselines/reference/builtinIterator.types
@@ -2,16 +2,16 @@
 
 === builtinIterator.ts ===
 const iterator = Iterator.from([0, 1, 2]);
->iterator : BuiltinIterator<number, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Iterator.from([0, 1, 2]) : BuiltinIterator<number, undefined, any>
->                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Iterator.from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => BuiltinIterator<T, undefined>
->              : ^ ^^     ^^                                                                 ^^^^^                             
+>iterator : IteratorObject<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Iterator.from([0, 1, 2]) : IteratorObject<number, undefined, unknown>
+>                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Iterator.from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => IteratorObject<T, undefined, unknown>
+>              : ^ ^^     ^^                                                                 ^^^^^                                     
 >Iterator : IteratorConstructor
 >         : ^^^^^^^^^^^^^^^^^^^
->from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => BuiltinIterator<T, undefined>
->     : ^ ^^     ^^                                                                 ^^^^^                             
+>from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => IteratorObject<T, undefined, unknown>
+>     : ^ ^^     ^^                                                                 ^^^^^                                     
 >[0, 1, 2] : number[]
 >          : ^^^^^^^^
 >0 : 0
@@ -22,30 +22,30 @@ const iterator = Iterator.from([0, 1, 2]);
 >  : ^
 
 const mapped = iterator.map(String);
->mapped : BuiltinIterator<string, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator.map(String) : BuiltinIterator<string, undefined, any>
->                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator.map : <U>(callbackfn: (value: number, index: number) => U) => BuiltinIterator<U, undefined, any>
->             : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator : BuiltinIterator<number, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map : <U>(callbackfn: (value: number, index: number) => U) => BuiltinIterator<U, undefined, any>
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>mapped : IteratorObject<string, undefined, unknown>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator.map(String) : IteratorObject<string, undefined, unknown>
+>                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator.map : <U>(callbackfn: (value: number, index: number) => U) => IteratorObject<U, undefined, unknown>
+>             : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator : IteratorObject<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map : <U>(callbackfn: (value: number, index: number) => U) => IteratorObject<U, undefined, unknown>
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >String : StringConstructor
 >       : ^^^^^^^^^^^^^^^^^
 
 const filtered = iterator.filter(x => x > 0);
->filtered : BuiltinIterator<number, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator.filter(x => x > 0) : BuiltinIterator<number, undefined, any>
->                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator.filter : { <S extends number>(predicate: (value: number, index: number) => value is S): BuiltinIterator<S, undefined, any>; (predicate: (value: number, index: number) => unknown): BuiltinIterator<number, undefined, any>; }
->                : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator : BuiltinIterator<number, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->filter : { <S extends number>(predicate: (value: number, index: number) => value is S): BuiltinIterator<S, undefined, any>; (predicate: (value: number, index: number) => unknown): BuiltinIterator<number, undefined, any>; }
->       : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>filtered : IteratorObject<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator.filter(x => x > 0) : IteratorObject<number, undefined, unknown>
+>                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator.filter : { <S extends number>(predicate: (value: number, index: number) => value is S): IteratorObject<S, undefined, unknown>; (predicate: (value: number, index: number) => unknown): IteratorObject<number, undefined, unknown>; }
+>                : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator : IteratorObject<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>filter : { <S extends number>(predicate: (value: number, index: number) => value is S): IteratorObject<S, undefined, unknown>; (predicate: (value: number, index: number) => unknown): IteratorObject<number, undefined, unknown>; }
+>       : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x > 0 : (x: number) => boolean
 >           : ^ ^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -72,30 +72,30 @@ function isZero(x: number): x is 0 {
 >  : ^
 }
 const zero = iterator.filter(isZero);
->zero : BuiltinIterator<0, undefined, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator.filter(isZero) : BuiltinIterator<0, undefined, any>
->                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator.filter : { <S extends number>(predicate: (value: number, index: number) => value is S): BuiltinIterator<S, undefined, any>; (predicate: (value: number, index: number) => unknown): BuiltinIterator<number, undefined, any>; }
->                : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iterator : BuiltinIterator<number, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->filter : { <S extends number>(predicate: (value: number, index: number) => value is S): BuiltinIterator<S, undefined, any>; (predicate: (value: number, index: number) => unknown): BuiltinIterator<number, undefined, any>; }
->       : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>zero : IteratorObject<0, undefined, unknown>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator.filter(isZero) : IteratorObject<0, undefined, unknown>
+>                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator.filter : { <S extends number>(predicate: (value: number, index: number) => value is S): IteratorObject<S, undefined, unknown>; (predicate: (value: number, index: number) => unknown): IteratorObject<number, undefined, unknown>; }
+>                : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iterator : IteratorObject<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>filter : { <S extends number>(predicate: (value: number, index: number) => value is S): IteratorObject<S, undefined, unknown>; (predicate: (value: number, index: number) => unknown): IteratorObject<number, undefined, unknown>; }
+>       : ^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >isZero : (x: number) => x is 0
 >       : ^ ^^      ^^^^^      
 
 const iteratorFromBare = Iterator.from({
->iteratorFromBare : BuiltinIterator<string, undefined, any>
->                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Iterator.from({  next() {    return {      done: Math.random() < .5,      value: "a string",    };  },}) : BuiltinIterator<string, undefined, any>
->                                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Iterator.from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => BuiltinIterator<T, undefined>
->              : ^ ^^     ^^                                                                 ^^^^^                             
+>iteratorFromBare : IteratorObject<string, undefined, unknown>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Iterator.from({  next() {    return {      done: Math.random() < .5,      value: "a string",    };  },}) : IteratorObject<string, undefined, unknown>
+>                                                                                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Iterator.from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => IteratorObject<T, undefined, unknown>
+>              : ^ ^^     ^^                                                                 ^^^^^                                     
 >Iterator : IteratorConstructor
 >         : ^^^^^^^^^^^^^^^^^^^
->from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => BuiltinIterator<T, undefined>
->     : ^ ^^     ^^                                                                 ^^^^^                             
+>from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => IteratorObject<T, undefined, unknown>
+>     : ^ ^^     ^^                                                                 ^^^^^                                     
 >{  next() {    return {      done: Math.random() < .5,      value: "a string",    };  },} : { next(): { done: boolean; value: string; }; }
 >                                                                                          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -146,18 +146,18 @@ function* gen() {
 }
 
 const mappedGen = gen().map(x => x === 0 ? "zero" : "other");
->mappedGen : BuiltinIterator<"zero" | "other", undefined, any>
->          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->gen().map(x => x === 0 ? "zero" : "other") : BuiltinIterator<"zero" | "other", undefined, any>
->                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->gen().map : <U>(callbackfn: (value: number, index: number) => U) => BuiltinIterator<U, undefined, any>
->          : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>mappedGen : IteratorObject<"zero" | "other", undefined, unknown>
+>          : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>gen().map(x => x === 0 ? "zero" : "other") : IteratorObject<"zero" | "other", undefined, unknown>
+>                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>gen().map : <U>(callbackfn: (value: number, index: number) => U) => IteratorObject<U, undefined, unknown>
+>          : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >gen() : Generator<number, void, unknown>
 >      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >gen : () => Generator<number, void, unknown>
 >    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map : <U>(callbackfn: (value: number, index: number) => U) => BuiltinIterator<U, undefined, any>
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map : <U>(callbackfn: (value: number, index: number) => U) => IteratorObject<U, undefined, unknown>
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x === 0 ? "zero" : "other" : (x: number) => "zero" | "other"
 >                                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -176,16 +176,16 @@ const mappedGen = gen().map(x => x === 0 ? "zero" : "other");
 >        : ^^^^^^^
 
 const mappedValues = [0, 1, 2].values().map(x => x === 0 ? "zero" : "other");
->mappedValues : BuiltinIterator<"zero" | "other", undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->[0, 1, 2].values().map(x => x === 0 ? "zero" : "other") : BuiltinIterator<"zero" | "other", undefined, any>
->                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->[0, 1, 2].values().map : <U>(callbackfn: (value: number, index: number) => U) => BuiltinIterator<U, undefined, any>
->                       : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->[0, 1, 2].values() : BuiltinIterator<number, undefined, any>
->                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->[0, 1, 2].values : () => BuiltinIterator<number, undefined, any>
->                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>mappedValues : IteratorObject<"zero" | "other", undefined, unknown>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[0, 1, 2].values().map(x => x === 0 ? "zero" : "other") : IteratorObject<"zero" | "other", undefined, unknown>
+>                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[0, 1, 2].values().map : <U>(callbackfn: (value: number, index: number) => U) => IteratorObject<U, undefined, unknown>
+>                       : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[0, 1, 2].values() : ArrayIterator<number>
+>                   : ^^^^^^^^^^^^^^^^^^^^^
+>[0, 1, 2].values : () => ArrayIterator<number>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[0, 1, 2] : number[]
 >          : ^^^^^^^^
 >0 : 0
@@ -194,10 +194,10 @@ const mappedValues = [0, 1, 2].values().map(x => x === 0 ? "zero" : "other");
 >  : ^
 >2 : 2
 >  : ^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map : <U>(callbackfn: (value: number, index: number) => U) => BuiltinIterator<U, undefined, any>
->    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map : <U>(callbackfn: (value: number, index: number) => U) => IteratorObject<U, undefined, unknown>
+>    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x => x === 0 ? "zero" : "other" : (x: number) => "zero" | "other"
 >                                : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >x : number
@@ -219,8 +219,8 @@ const mappedValues = [0, 1, 2].values().map(x => x === 0 ? "zero" : "other");
 class GoodIterator extends Iterator<number> {
 >GoodIterator : GoodIterator
 >             : ^^^^^^^^^^^^
->Iterator : Iterator<number>
->         : ^^^^^^^^^^^^^^^^
+>Iterator : Iterator<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   next() {
 >next : () => { readonly done: false; readonly value: 0; }
@@ -252,15 +252,15 @@ new Iterator<number>();
 class C extends Iterator<number> {}
 >C : C
 >  : ^
->Iterator : Iterator<number>
->         : ^^^^^^^^^^^^^^^^
+>Iterator : Iterator<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // it's unfortunate that these are an error
 class BadIterator1 extends Iterator<number> {
 >BadIterator1 : BadIterator1
 >             : ^^^^^^^^^^^^
->Iterator : Iterator<number>
->         : ^^^^^^^^^^^^^^^^
+>Iterator : Iterator<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   next() {
 >next : () => { readonly done: false; readonly value: 0; } | { readonly done: true; readonly value: "a string"; }
@@ -315,8 +315,8 @@ class BadIterator1 extends Iterator<number> {
 class BadIterator2 extends Iterator<number> {
 >BadIterator2 : BadIterator2
 >             : ^^^^^^^^^^^^
->Iterator : Iterator<number>
->         : ^^^^^^^^^^^^^^^^
+>Iterator : Iterator<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   next() {
 >next : () => { done: boolean; value: number; }
@@ -339,8 +339,8 @@ class BadIterator2 extends Iterator<number> {
 class BadIterator3 extends Iterator<number> {
 >BadIterator3 : BadIterator3
 >             : ^^^^^^^^^^^^
->Iterator : Iterator<number>
->         : ^^^^^^^^^^^^^^^^
+>Iterator : Iterator<number, undefined, unknown>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
   next() {
 >next : () => { done: boolean; value: number; } | { done: boolean; value: string; }
@@ -393,34 +393,34 @@ declare const g1: Generator<string, number, boolean>;
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const iter1 = Iterator.from(g1);
->iter1 : BuiltinIterator<string, undefined, any>
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Iterator.from(g1) : BuiltinIterator<string, undefined, any>
->                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->Iterator.from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => BuiltinIterator<T, undefined>
->              : ^ ^^     ^^                                                                 ^^^^^                             
+>iter1 : IteratorObject<string, undefined, unknown>
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Iterator.from(g1) : IteratorObject<string, undefined, unknown>
+>                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>Iterator.from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => IteratorObject<T, undefined, unknown>
+>              : ^ ^^     ^^                                                                 ^^^^^                                     
 >Iterator : IteratorConstructor
 >         : ^^^^^^^^^^^^^^^^^^^
->from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => BuiltinIterator<T, undefined>
->     : ^ ^^     ^^                                                                 ^^^^^                             
+>from : <T>(value: Iterator<T, unknown, undefined> | Iterable<T, unknown, undefined>) => IteratorObject<T, undefined, unknown>
+>     : ^ ^^     ^^                                                                 ^^^^^                                     
 >g1 : Generator<string, number, boolean>
 >   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-declare const iter2: BuiltinIterator<string, BuiltinIteratorReturn>;
->iter2 : BuiltinIterator<string, undefined, any>
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+declare const iter2: IteratorObject<string>;
+>iter2 : IteratorObject<string, unknown, unknown>
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const iter3 = iter2.flatMap(() => g1);
->iter3 : BuiltinIterator<string, undefined, any>
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iter2.flatMap(() => g1) : BuiltinIterator<string, undefined, any>
->                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iter2.flatMap : <U>(callback: (value: string, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>) => BuiltinIterator<U, undefined, any>
->              : ^ ^^        ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->iter2 : BuiltinIterator<string, undefined, any>
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->flatMap : <U>(callback: (value: string, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>) => BuiltinIterator<U, undefined, any>
->        : ^ ^^        ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iter3 : IteratorObject<string, undefined, unknown>
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iter2.flatMap(() => g1) : IteratorObject<string, undefined, unknown>
+>                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iter2.flatMap : <U>(callback: (value: string, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>) => IteratorObject<U, undefined, unknown>
+>              : ^ ^^        ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>iter2 : IteratorObject<string, unknown, unknown>
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>flatMap : <U>(callback: (value: string, index: number) => Iterator<U, unknown, undefined> | Iterable<U, unknown, undefined>) => IteratorObject<U, undefined, unknown>
+>        : ^ ^^        ^^^     ^^^^^^^^^^     ^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >() => g1 : () => Generator<string, number, boolean>
 >         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >g1 : Generator<string, number, boolean>
diff --git a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types
index 3ed7928926650..8c2630930a4cc 100644
--- a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types
+++ b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=false).types
@@ -14,12 +14,12 @@ declare const set: Set<number>;
 >    : ^^^^^^^^^^^
 
 const i0 = array[Symbol.iterator]();
->i0 : BuiltinIterator<number, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array[Symbol.iterator]() : BuiltinIterator<number, any, any>
->                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array[Symbol.iterator] : () => BuiltinIterator<number, any, any>
->                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i0 : ArrayIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^^^
+>array[Symbol.iterator]() : ArrayIterator<number>
+>                         : ^^^^^^^^^^^^^^^^^^^^^
+>array[Symbol.iterator] : () => ArrayIterator<number>
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -30,40 +30,40 @@ const i0 = array[Symbol.iterator]();
 >         : ^^^^^^^^^^^^^
 
 const i1 = array.values();
->i1 : BuiltinIterator<number, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.values() : BuiltinIterator<number, any, any>
->               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.values : () => BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i1 : ArrayIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^^^
+>array.values() : ArrayIterator<number>
+>               : ^^^^^^^^^^^^^^^^^^^^^
+>array.values : () => ArrayIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
->values : () => BuiltinIterator<number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i2 = array.keys();
->i2 : BuiltinIterator<number, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.keys() : BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.keys : () => BuiltinIterator<number, BuiltinIteratorReturn>
->           : ^^^^^^                                              
+>i2 : ArrayIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^^^
+>array.keys() : ArrayIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^^^
+>array.keys : () => ArrayIterator<number>
+>           : ^^^^^^                     
 >array : number[]
 >      : ^^^^^^^^
->keys : () => BuiltinIterator<number, BuiltinIteratorReturn>
->     : ^^^^^^                                              
+>keys : () => ArrayIterator<number>
+>     : ^^^^^^                     
 
 const i3 = array.entries();
->i3 : BuiltinIterator<[number, number], any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.entries() : BuiltinIterator<[number, number], any, any>
->                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.entries : () => BuiltinIterator<[number, number], any, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i3 : ArrayIterator<[number, number]>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>array.entries() : ArrayIterator<[number, number]>
+>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>array.entries : () => ArrayIterator<[number, number]>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
->entries : () => BuiltinIterator<[number, number], any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>entries : () => ArrayIterator<[number, number]>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 for (const x of array);
 >x : number
@@ -72,12 +72,12 @@ for (const x of array);
 >      : ^^^^^^^^
 
 const i4 = map[Symbol.iterator]();
->i4 : BuiltinIterator<[string, number], any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map[Symbol.iterator]() : BuiltinIterator<[string, number], any, any>
->                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map[Symbol.iterator] : () => BuiltinIterator<[string, number], any, any>
->                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i4 : MapIterator<[string, number]>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map[Symbol.iterator]() : MapIterator<[string, number]>
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map[Symbol.iterator] : () => MapIterator<[string, number]>
+>                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -88,40 +88,40 @@ const i4 = map[Symbol.iterator]();
 >         : ^^^^^^^^^^^^^
 
 const i5 = map.values();
->i5 : BuiltinIterator<number, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values() : BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values : () => BuiltinIterator<number, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i5 : MapIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^
+>map.values() : MapIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>map.values : () => MapIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->values : () => BuiltinIterator<number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => MapIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i6 = map.keys();
->i6 : BuiltinIterator<string, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.keys() : BuiltinIterator<string, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.keys : () => BuiltinIterator<string, any, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i6 : MapIterator<string>
+>   : ^^^^^^^^^^^^^^^^^^^
+>map.keys() : MapIterator<string>
+>           : ^^^^^^^^^^^^^^^^^^^
+>map.keys : () => MapIterator<string>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->keys : () => BuiltinIterator<string, any, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => MapIterator<string>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i7 = map.entries();
->i7 : BuiltinIterator<[string, number], any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.entries() : BuiltinIterator<[string, number], any, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.entries : () => BuiltinIterator<[string, number], any, any>
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i7 : MapIterator<[string, number]>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.entries() : MapIterator<[string, number]>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.entries : () => MapIterator<[string, number]>
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->entries : () => BuiltinIterator<[string, number], any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>entries : () => MapIterator<[string, number]>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 for (const x of map);
 >x : [string, number]
@@ -130,12 +130,12 @@ for (const x of map);
 >    : ^^^^^^^^^^^^^^^^^^^
 
 const i8 = set[Symbol.iterator]();
->i8 : BuiltinIterator<number, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set[Symbol.iterator]() : BuiltinIterator<number, any, any>
->                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set[Symbol.iterator] : () => BuiltinIterator<number, any, any>
->                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i8 : SetIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^
+>set[Symbol.iterator]() : SetIterator<number>
+>                       : ^^^^^^^^^^^^^^^^^^^
+>set[Symbol.iterator] : () => SetIterator<number>
+>                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -146,40 +146,40 @@ const i8 = set[Symbol.iterator]();
 >         : ^^^^^^^^^^^^^
 
 const i9 = set.values();
->i9 : BuiltinIterator<number, any, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values() : BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values : () => BuiltinIterator<number, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i9 : SetIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^
+>set.values() : SetIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>set.values : () => SetIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->values : () => BuiltinIterator<number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => SetIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i10 = set.keys();
->i10 : BuiltinIterator<number, any, any>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.keys() : BuiltinIterator<number, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.keys : () => BuiltinIterator<number, any, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i10 : SetIterator<number>
+>    : ^^^^^^^^^^^^^^^^^^^
+>set.keys() : SetIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^
+>set.keys : () => SetIterator<number>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->keys : () => BuiltinIterator<number, any, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => SetIterator<number>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i11 = set.entries();
->i11 : BuiltinIterator<[number, number], any, any>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.entries() : BuiltinIterator<[number, number], any, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.entries : () => BuiltinIterator<[number, number], any, any>
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i11 : SetIterator<[number, number]>
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.entries() : SetIterator<[number, number]>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.entries : () => SetIterator<[number, number]>
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->entries : () => BuiltinIterator<[number, number], any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>entries : () => SetIterator<[number, number]>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 for (const x of set);
 >x : number
diff --git a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types
index 4a4d461d4a71f..8c2630930a4cc 100644
--- a/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types
+++ b/tests/baselines/reference/builtinIteratorReturn(strictbuiltiniteratorreturn=true).types
@@ -14,12 +14,12 @@ declare const set: Set<number>;
 >    : ^^^^^^^^^^^
 
 const i0 = array[Symbol.iterator]();
->i0 : BuiltinIterator<number, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array[Symbol.iterator]() : BuiltinIterator<number, undefined, any>
->                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array[Symbol.iterator] : () => BuiltinIterator<number, undefined, any>
->                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i0 : ArrayIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^^^
+>array[Symbol.iterator]() : ArrayIterator<number>
+>                         : ^^^^^^^^^^^^^^^^^^^^^
+>array[Symbol.iterator] : () => ArrayIterator<number>
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -30,40 +30,40 @@ const i0 = array[Symbol.iterator]();
 >         : ^^^^^^^^^^^^^
 
 const i1 = array.values();
->i1 : BuiltinIterator<number, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.values() : BuiltinIterator<number, undefined, any>
->               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.values : () => BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i1 : ArrayIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^^^
+>array.values() : ArrayIterator<number>
+>               : ^^^^^^^^^^^^^^^^^^^^^
+>array.values : () => ArrayIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i2 = array.keys();
->i2 : BuiltinIterator<number, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.keys() : BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.keys : () => BuiltinIterator<number, BuiltinIteratorReturn>
->           : ^^^^^^                                              
+>i2 : ArrayIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^^^
+>array.keys() : ArrayIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^^^
+>array.keys : () => ArrayIterator<number>
+>           : ^^^^^^                     
 >array : number[]
 >      : ^^^^^^^^
->keys : () => BuiltinIterator<number, BuiltinIteratorReturn>
->     : ^^^^^^                                              
+>keys : () => ArrayIterator<number>
+>     : ^^^^^^                     
 
 const i3 = array.entries();
->i3 : BuiltinIterator<[number, number], undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.entries() : BuiltinIterator<[number, number], undefined, any>
->                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->array.entries : () => BuiltinIterator<[number, number], undefined, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i3 : ArrayIterator<[number, number]>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>array.entries() : ArrayIterator<[number, number]>
+>                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>array.entries : () => ArrayIterator<[number, number]>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >array : number[]
 >      : ^^^^^^^^
->entries : () => BuiltinIterator<[number, number], undefined, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>entries : () => ArrayIterator<[number, number]>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 for (const x of array);
 >x : number
@@ -72,12 +72,12 @@ for (const x of array);
 >      : ^^^^^^^^
 
 const i4 = map[Symbol.iterator]();
->i4 : BuiltinIterator<[string, number], undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map[Symbol.iterator]() : BuiltinIterator<[string, number], undefined, any>
->                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map[Symbol.iterator] : () => BuiltinIterator<[string, number], undefined, any>
->                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i4 : MapIterator<[string, number]>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map[Symbol.iterator]() : MapIterator<[string, number]>
+>                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map[Symbol.iterator] : () => MapIterator<[string, number]>
+>                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -88,40 +88,40 @@ const i4 = map[Symbol.iterator]();
 >         : ^^^^^^^^^^^^^
 
 const i5 = map.values();
->i5 : BuiltinIterator<number, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values() : BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values : () => BuiltinIterator<number, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i5 : MapIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^
+>map.values() : MapIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>map.values : () => MapIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => MapIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i6 = map.keys();
->i6 : BuiltinIterator<string, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.keys() : BuiltinIterator<string, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.keys : () => BuiltinIterator<string, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i6 : MapIterator<string>
+>   : ^^^^^^^^^^^^^^^^^^^
+>map.keys() : MapIterator<string>
+>           : ^^^^^^^^^^^^^^^^^^^
+>map.keys : () => MapIterator<string>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->keys : () => BuiltinIterator<string, undefined, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => MapIterator<string>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i7 = map.entries();
->i7 : BuiltinIterator<[string, number], undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.entries() : BuiltinIterator<[string, number], undefined, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.entries : () => BuiltinIterator<[string, number], undefined, any>
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i7 : MapIterator<[string, number]>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.entries() : MapIterator<[string, number]>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.entries : () => MapIterator<[string, number]>
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->entries : () => BuiltinIterator<[string, number], undefined, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>entries : () => MapIterator<[string, number]>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 for (const x of map);
 >x : [string, number]
@@ -130,12 +130,12 @@ for (const x of map);
 >    : ^^^^^^^^^^^^^^^^^^^
 
 const i8 = set[Symbol.iterator]();
->i8 : BuiltinIterator<number, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set[Symbol.iterator]() : BuiltinIterator<number, undefined, any>
->                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set[Symbol.iterator] : () => BuiltinIterator<number, undefined, any>
->                     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i8 : SetIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^
+>set[Symbol.iterator]() : SetIterator<number>
+>                       : ^^^^^^^^^^^^^^^^^^^
+>set[Symbol.iterator] : () => SetIterator<number>
+>                     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
 >Symbol.iterator : unique symbol
@@ -146,40 +146,40 @@ const i8 = set[Symbol.iterator]();
 >         : ^^^^^^^^^^^^^
 
 const i9 = set.values();
->i9 : BuiltinIterator<number, undefined, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values() : BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values : () => BuiltinIterator<number, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i9 : SetIterator<number>
+>   : ^^^^^^^^^^^^^^^^^^^
+>set.values() : SetIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>set.values : () => SetIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => SetIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i10 = set.keys();
->i10 : BuiltinIterator<number, undefined, any>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.keys() : BuiltinIterator<number, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.keys : () => BuiltinIterator<number, undefined, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i10 : SetIterator<number>
+>    : ^^^^^^^^^^^^^^^^^^^
+>set.keys() : SetIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^
+>set.keys : () => SetIterator<number>
+>         : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->keys : () => BuiltinIterator<number, undefined, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => SetIterator<number>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const i11 = set.entries();
->i11 : BuiltinIterator<[number, number], undefined, any>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.entries() : BuiltinIterator<[number, number], undefined, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.entries : () => BuiltinIterator<[number, number], undefined, any>
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i11 : SetIterator<[number, number]>
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.entries() : SetIterator<[number, number]>
+>              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.entries : () => SetIterator<[number, number]>
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->entries : () => BuiltinIterator<[number, number], undefined, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>entries : () => SetIterator<[number, number]>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 for (const x of set);
 >x : number
diff --git a/tests/baselines/reference/conditionalTypeDoesntSpinForever.types b/tests/baselines/reference/conditionalTypeDoesntSpinForever.types
index 9d9489fd8ddff..73fb1f2d6e19d 100644
--- a/tests/baselines/reference/conditionalTypeDoesntSpinForever.types
+++ b/tests/baselines/reference/conditionalTypeDoesntSpinForever.types
@@ -1,8 +1,8 @@
 //// [tests/cases/compiler/conditionalTypeDoesntSpinForever.ts] ////
 
 === Performance Stats ===
-Type Count: 1,000 -> 2,500
-Instantiation count: 5,000
+Type Count: 1,000
+Instantiation count: 2,500 -> 5,000
 
 === conditionalTypeDoesntSpinForever.ts ===
 // A *self-contained* demonstration of the problem follows...
diff --git a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
index 3a69a723a7b2f..eb6edb1fac68d 100644
--- a/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
+++ b/tests/baselines/reference/destructuredLateBoundNameHasCorrectTypes.types
@@ -8,16 +8,16 @@ let { [Symbol.iterator]: destructured } = [];
 >       : ^^^^^^^^^^^^^^^^^
 >iterator : unique symbol
 >         : ^^^^^^^^^^^^^
->destructured : () => BuiltinIterator<undefined, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>destructured : () => ArrayIterator<undefined>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 
 void destructured;
 >void destructured : undefined
 >                  : ^^^^^^^^^
->destructured : () => BuiltinIterator<undefined, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>destructured : () => ArrayIterator<undefined>
+>             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const named = "prop";
 >named : "prop"
diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types
index dc92b10c489ff..21621981a4c79 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2015.types
@@ -46,8 +46,8 @@ class C4 {
 >   : ^^
 
     async * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types
index 42a23acadf4ed..01da6be08506f 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es2018.types
@@ -46,8 +46,8 @@ class C4 {
 >   : ^^
 
     async * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types
index 93ea693423f50..b11c7c75fa475 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.classMethods.es5.types
@@ -46,8 +46,8 @@ class C4 {
 >   : ^^
 
     async * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types
index d3f253300a53c..d291bdc0cd056 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2015.types
@@ -27,8 +27,8 @@ async function * f3() {
 }
 === F4.ts ===
 async function * f4() {
->f4 : () => AsyncGenerator<number, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f4 : () => AsyncGenerator<number, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types
index c9e8a861c147e..f737ba595effd 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es2018.types
@@ -27,8 +27,8 @@ async function * f3() {
 }
 === F4.ts ===
 async function * f4() {
->f4 : () => AsyncGenerator<number, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f4 : () => AsyncGenerator<number, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types
index e9f6d8a5c12e3..3489a92210c5e 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionDeclarations.es5.types
@@ -27,8 +27,8 @@ async function * f3() {
 }
 === F4.ts ===
 async function * f4() {
->f4 : () => AsyncGenerator<number, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f4 : () => AsyncGenerator<number, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types
index 385726d4ec892..b3d8d1525c942 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2015.types
@@ -33,10 +33,10 @@ const f3 = async function * () {
 }
 === F4.ts ===
 const f4 = async function * () {
->f4 : () => AsyncGenerator<number, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, any>
->                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f4 : () => AsyncGenerator<number, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, unknown>
+>                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types
index 074449e1ccf11..05ff8b2df1042 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es2018.types
@@ -33,10 +33,10 @@ const f3 = async function * () {
 }
 === F4.ts ===
 const f4 = async function * () {
->f4 : () => AsyncGenerator<number, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, any>
->                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f4 : () => AsyncGenerator<number, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, unknown>
+>                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types
index 0e2315bd1ddc2..ff2dc953caf2b 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.functionExpressions.es5.types
@@ -33,10 +33,10 @@ const f3 = async function * () {
 }
 === F4.ts ===
 const f4 = async function * () {
->f4 : () => AsyncGenerator<number, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, any>
->                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f4 : () => AsyncGenerator<number, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    const x = yield* [1];} : () => AsyncGenerator<number, void, unknown>
+>                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types
index 58de2b68a6ca4..3aa61b810a254 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2015.types
@@ -48,14 +48,14 @@ const o3 = {
 }
 === O4.ts ===
 const o4 = {
->o4 : { f(): AsyncGenerator<number, void, any>; }
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, any>; }
->                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>o4 : { f(): AsyncGenerator<number, void, unknown>; }
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, unknown>; }
+>                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     async * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types
index 024281295e40d..91624582a4ecd 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es2018.types
@@ -48,14 +48,14 @@ const o3 = {
 }
 === O4.ts ===
 const o4 = {
->o4 : { f(): AsyncGenerator<number, void, any>; }
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, any>; }
->                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>o4 : { f(): AsyncGenerator<number, void, unknown>; }
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, unknown>; }
+>                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     async * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types
index 6bb7ecf62404c..3ffdf9a74569a 100644
--- a/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types
+++ b/tests/baselines/reference/emitter.asyncGenerators.objectLiteralMethods.es5.types
@@ -48,14 +48,14 @@ const o3 = {
 }
 === O4.ts ===
 const o4 = {
->o4 : { f(): AsyncGenerator<number, void, any>; }
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, any>; }
->                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>o4 : { f(): AsyncGenerator<number, void, unknown>; }
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    async * f() {        const x = yield* [1];    }} : { f(): AsyncGenerator<number, void, unknown>; }
+>                                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     async * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         const x = yield* [1];
 >x : any
diff --git a/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types b/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
index a5fdfa43c94c8..b409385e2c46e 100644
--- a/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
+++ b/tests/baselines/reference/esNextWeakRefs_IterableWeakMap.types
@@ -2,7 +2,7 @@
 
 === Performance Stats ===
 Type Count: 1,000
-Instantiation count: 1,000 -> 2,500
+Instantiation count: 2,500
 
 === esNextWeakRefs_IterableWeakMap.ts ===
 /** `static #cleanup` */
diff --git a/tests/baselines/reference/excessiveStackDepthFlatArray.types b/tests/baselines/reference/excessiveStackDepthFlatArray.types
index 6058609386027..17365af09d86d 100644
--- a/tests/baselines/reference/excessiveStackDepthFlatArray.types
+++ b/tests/baselines/reference/excessiveStackDepthFlatArray.types
@@ -1,7 +1,8 @@
 //// [tests/cases/compiler/excessiveStackDepthFlatArray.ts] ////
 
 === Performance Stats ===
-Instantiation count: 1,000 -> 2,500
+Type Count: 1,000
+Instantiation count: 2,500
 
 === index.tsx ===
 interface MiddlewareArray<T> extends Array<T> {}
diff --git a/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types b/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
index e4ec2fa695c69..38636565617db 100644
--- a/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
+++ b/tests/baselines/reference/flatArrayNoExcessiveStackDepth.types
@@ -1,8 +1,8 @@
 //// [tests/cases/compiler/flatArrayNoExcessiveStackDepth.ts] ////
 
 === Performance Stats ===
-Type Count: 1,000
-Instantiation count: 2,500
+Type Count: 2,500
+Instantiation count: 5,000
 
 === flatArrayNoExcessiveStackDepth.ts ===
 // Repro from #43493
diff --git a/tests/baselines/reference/for-of12.types b/tests/baselines/reference/for-of12.types
index 3bab8ba58592f..0a803fbce71cd 100644
--- a/tests/baselines/reference/for-of12.types
+++ b/tests/baselines/reference/for-of12.types
@@ -8,16 +8,16 @@ var v: string;
 for (v of [0, ""].values()) { }
 >v : string
 >  : ^^^^^^
->[0, ""].values() : BuiltinIterator<string | number, any, any>
->                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->[0, ""].values : () => BuiltinIterator<string | number, any, any>
->               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[0, ""].values() : ArrayIterator<string | number>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[0, ""].values : () => ArrayIterator<string | number>
+>               : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[0, ""] : (string | number)[]
 >        : ^^^^^^^^^^^^^^^^^^^
 >0 : 0
 >  : ^
 >"" : ""
 >   : ^^
->values : () => BuiltinIterator<string | number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<string | number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of13.types b/tests/baselines/reference/for-of13.types
index 42aef034f7446..1cb2638d64f3e 100644
--- a/tests/baselines/reference/for-of13.types
+++ b/tests/baselines/reference/for-of13.types
@@ -8,14 +8,14 @@ var v: string;
 for (v of [""].values()) { }
 >v : string
 >  : ^^^^^^
->[""].values() : BuiltinIterator<string, any, any>
->              : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->[""].values : () => BuiltinIterator<string, any, any>
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[""].values() : ArrayIterator<string>
+>              : ^^^^^^^^^^^^^^^^^^^^^
+>[""].values : () => ArrayIterator<string>
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[""] : string[]
 >     : ^^^^^^^^
 >"" : ""
 >   : ^^
->values : () => BuiltinIterator<string, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => ArrayIterator<string>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of14.errors.txt b/tests/baselines/reference/for-of14.errors.txt
index d6608338f5777..4aa61b4a7666a 100644
--- a/tests/baselines/reference/for-of14.errors.txt
+++ b/tests/baselines/reference/for-of14.errors.txt
@@ -1,14 +1,14 @@
-for-of14.ts(8,11): error TS2488: Type 'StringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
+for-of14.ts(8,11): error TS2488: Type 'MyStringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== for-of14.ts (1 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         next() {
             return "";
         }
     }
     
     var v: string;
-    for (v of new StringIterator) { } // Should fail because the iterator is not iterable
-              ~~~~~~~~~~~~~~~~~~
-!!! error TS2488: Type 'StringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
\ No newline at end of file
+    for (v of new MyStringIterator) { } // Should fail because the iterator is not iterable
+              ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2488: Type 'MyStringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of14.js b/tests/baselines/reference/for-of14.js
index ee51477b12121..92d9613bfe622 100644
--- a/tests/baselines/reference/for-of14.js
+++ b/tests/baselines/reference/for-of14.js
@@ -1,20 +1,20 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of14.ts] ////
 
 //// [for-of14.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return "";
     }
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should fail because the iterator is not iterable
+for (v of new MyStringIterator) { } // Should fail because the iterator is not iterable
 
 //// [for-of14.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return "";
     }
 }
 var v;
-for (v of new StringIterator) { } // Should fail because the iterator is not iterable
+for (v of new MyStringIterator) { } // Should fail because the iterator is not iterable
diff --git a/tests/baselines/reference/for-of14.symbols b/tests/baselines/reference/for-of14.symbols
index e38832fcce1c9..23b893e125c6e 100644
--- a/tests/baselines/reference/for-of14.symbols
+++ b/tests/baselines/reference/for-of14.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of14.ts] ////
 
 === for-of14.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of14.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of14.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of14.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of14.ts, 0, 24))
 
         return "";
     }
@@ -14,7 +14,7 @@ class StringIterator {
 var v: string;
 >v : Symbol(v, Decl(for-of14.ts, 6, 3))
 
-for (v of new StringIterator) { } // Should fail because the iterator is not iterable
+for (v of new MyStringIterator) { } // Should fail because the iterator is not iterable
 >v : Symbol(v, Decl(for-of14.ts, 6, 3))
->StringIterator : Symbol(StringIterator, Decl(for-of14.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of14.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of14.types b/tests/baselines/reference/for-of14.types
index e72978e40db01..60fb9f7fad6cb 100644
--- a/tests/baselines/reference/for-of14.types
+++ b/tests/baselines/reference/for-of14.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of14.ts] ////
 
 === for-of14.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => string
@@ -19,11 +19,11 @@ var v: string;
 >v : string
 >  : ^^^^^^
 
-for (v of new StringIterator) { } // Should fail because the iterator is not iterable
+for (v of new MyStringIterator) { } // Should fail because the iterator is not iterable
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of15.errors.txt b/tests/baselines/reference/for-of15.errors.txt
index 301ee3da74bab..37ee2d77dacf9 100644
--- a/tests/baselines/reference/for-of15.errors.txt
+++ b/tests/baselines/reference/for-of15.errors.txt
@@ -2,7 +2,7 @@ for-of15.ts(11,11): error TS2490: The type returned by the 'next()' method of an
 
 
 ==== for-of15.ts (1 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         next() {
             return "";
         }
@@ -12,6 +12,6 @@ for-of15.ts(11,11): error TS2490: The type returned by the 'next()' method of an
     }
     
     var v: string;
-    for (v of new StringIterator) { } // Should fail
-              ~~~~~~~~~~~~~~~~~~
+    for (v of new MyStringIterator) { } // Should fail
+              ~~~~~~~~~~~~~~~~~~~~
 !!! error TS2490: The type returned by the 'next()' method of an iterator must have a 'value' property.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of15.js b/tests/baselines/reference/for-of15.js
index 519b7ba792e2e..3505ed87fe29c 100644
--- a/tests/baselines/reference/for-of15.js
+++ b/tests/baselines/reference/for-of15.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of15.ts] ////
 
 //// [for-of15.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return "";
     }
@@ -11,10 +11,10 @@ class StringIterator {
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 
 //// [for-of15.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return "";
     }
@@ -23,4 +23,4 @@ class StringIterator {
     }
 }
 var v;
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
diff --git a/tests/baselines/reference/for-of15.symbols b/tests/baselines/reference/for-of15.symbols
index 43c14cf824f56..e4bf338a0541b 100644
--- a/tests/baselines/reference/for-of15.symbols
+++ b/tests/baselines/reference/for-of15.symbols
@@ -1,29 +1,29 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of15.ts] ////
 
 === for-of15.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of15.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of15.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of15.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of15.ts, 0, 24))
 
         return "";
     }
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of15.ts, 3, 5))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of15.ts, 3, 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(for-of15.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of15.ts, 0, 0))
     }
 }
 
 var v: string;
 >v : Symbol(v, Decl(for-of15.ts, 9, 3))
 
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 >v : Symbol(v, Decl(for-of15.ts, 9, 3))
->StringIterator : Symbol(StringIterator, Decl(for-of15.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of15.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of15.types b/tests/baselines/reference/for-of15.types
index 9bd1335f79dc3..3eeabe29b5dd8 100644
--- a/tests/baselines/reference/for-of15.types
+++ b/tests/baselines/reference/for-of15.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of15.ts] ////
 
 === for-of15.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => string
@@ -33,11 +33,11 @@ var v: string;
 >v : string
 >  : ^^^^^^
 
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of16.errors.txt b/tests/baselines/reference/for-of16.errors.txt
index 37b9b6d05503d..0af867a2c66ad 100644
--- a/tests/baselines/reference/for-of16.errors.txt
+++ b/tests/baselines/reference/for-of16.errors.txt
@@ -1,21 +1,21 @@
-for-of16.ts(8,11): error TS2488: Type 'StringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
-for-of16.ts(10,11): error TS2488: Type 'StringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
+for-of16.ts(8,11): error TS2488: Type 'MyStringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
+for-of16.ts(10,11): error TS2488: Type 'MyStringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
 
 
 ==== for-of16.ts (2 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         [Symbol.iterator]() {
             return this;
         }
     }
     
     var v: string;
-    for (v of new StringIterator) { } // Should fail
-              ~~~~~~~~~~~~~~~~~~
-!!! error TS2488: Type 'StringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
+    for (v of new MyStringIterator) { } // Should fail
+              ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2488: Type 'MyStringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
 !!! related TS2489 for-of16.ts:8:11: An iterator must have a 'next()' method.
     
-    for (v of new StringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
-              ~~~~~~~~~~~~~~~~~~
-!!! error TS2488: Type 'StringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
+    for (v of new MyStringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
+              ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2488: Type 'MyStringIterator' must have a '[Symbol.iterator]()' method that returns an iterator.
 !!! related TS2489 for-of16.ts:10:11: An iterator must have a 'next()' method.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of16.js b/tests/baselines/reference/for-of16.js
index 64c7588b72e0a..cf7699af90a5b 100644
--- a/tests/baselines/reference/for-of16.js
+++ b/tests/baselines/reference/for-of16.js
@@ -1,23 +1,23 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of16.ts] ////
 
 //// [for-of16.ts]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return this;
     }
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 
-for (v of new StringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
+for (v of new MyStringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
 
 //// [for-of16.js]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return this;
     }
 }
 var v;
-for (v of new StringIterator) { } // Should fail
-for (v of new StringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
+for (v of new MyStringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
diff --git a/tests/baselines/reference/for-of16.symbols b/tests/baselines/reference/for-of16.symbols
index 03a26d1435320..bab17a526bd43 100644
--- a/tests/baselines/reference/for-of16.symbols
+++ b/tests/baselines/reference/for-of16.symbols
@@ -1,28 +1,28 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of16.ts] ////
 
 === for-of16.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of16.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of16.ts, 0, 0))
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of16.ts, 0, 22))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of16.ts, 0, 24))
 >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(for-of16.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of16.ts, 0, 0))
     }
 }
 
 var v: string;
 >v : Symbol(v, Decl(for-of16.ts, 6, 3))
 
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 >v : Symbol(v, Decl(for-of16.ts, 6, 3))
->StringIterator : Symbol(StringIterator, Decl(for-of16.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of16.ts, 0, 0))
 
-for (v of new StringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
+for (v of new MyStringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
 >v : Symbol(v, Decl(for-of16.ts, 6, 3))
->StringIterator : Symbol(StringIterator, Decl(for-of16.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of16.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of16.types b/tests/baselines/reference/for-of16.types
index 896c3513a2cf8..fb051c331165f 100644
--- a/tests/baselines/reference/for-of16.types
+++ b/tests/baselines/reference/for-of16.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of16.ts] ////
 
 === for-of16.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => this
@@ -25,19 +25,19 @@ var v: string;
 >v : string
 >  : ^^^^^^
 
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
-for (v of new StringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
+for (v of new MyStringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of18.js b/tests/baselines/reference/for-of18.js
index a0673561e882e..c81fa6a0bc405 100644
--- a/tests/baselines/reference/for-of18.js
+++ b/tests/baselines/reference/for-of18.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of18.ts] ////
 
 //// [for-of18.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             value: "",
@@ -14,10 +14,10 @@ class StringIterator {
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should succeed
+for (v of new MyStringIterator) { } // Should succeed
 
 //// [for-of18.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             value: "",
@@ -29,4 +29,4 @@ class StringIterator {
     }
 }
 var v;
-for (v of new StringIterator) { } // Should succeed
+for (v of new MyStringIterator) { } // Should succeed
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index 8bbbb40c329f9..032604bfe0154 100644
--- a/tests/baselines/reference/for-of18.symbols
+++ b/tests/baselines/reference/for-of18.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of18.ts] ////
 
 === for-of18.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of18.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of18.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of18.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of18.ts, 0, 24))
 
         return {
             value: "",
@@ -17,20 +17,20 @@ class StringIterator {
         };
     }
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of18.ts, 6, 5))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of18.ts, 6, 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(for-of18.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of18.ts, 0, 0))
     }
 }
 
 var v: string;
 >v : Symbol(v, Decl(for-of18.ts, 12, 3))
 
-for (v of new StringIterator) { } // Should succeed
+for (v of new MyStringIterator) { } // Should succeed
 >v : Symbol(v, Decl(for-of18.ts, 12, 3))
->StringIterator : Symbol(StringIterator, Decl(for-of18.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of18.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of18.types b/tests/baselines/reference/for-of18.types
index 34a7e20a9549c..0ac03cf3e9e2d 100644
--- a/tests/baselines/reference/for-of18.types
+++ b/tests/baselines/reference/for-of18.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of18.ts] ////
 
 === for-of18.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => { value: string; done: boolean; }
@@ -47,11 +47,11 @@ var v: string;
 >v : string
 >  : ^^^^^^
 
-for (v of new StringIterator) { } // Should succeed
+for (v of new MyStringIterator) { } // Should succeed
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of25.js b/tests/baselines/reference/for-of25.js
index 66111df6394d5..bac7342af9714 100644
--- a/tests/baselines/reference/for-of25.js
+++ b/tests/baselines/reference/for-of25.js
@@ -1,20 +1,20 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of25.ts] ////
 
 //// [for-of25.ts]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return x;
     }
 }
 
 var x: any;
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of25.js]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return x;
     }
 }
 var x;
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols
index fdb51126c8922..86a223aa335d3 100644
--- a/tests/baselines/reference/for-of25.symbols
+++ b/tests/baselines/reference/for-of25.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of25.ts] ////
 
 === for-of25.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of25.ts, 0, 0))
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of25.ts, 0, 22))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of25.ts, 0, 24))
 >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, --, --))
@@ -18,7 +18,7 @@ class StringIterator {
 var x: any;
 >x : Symbol(x, Decl(for-of25.ts, 6, 3))
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of25.ts, 7, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of25.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of25.types b/tests/baselines/reference/for-of25.types
index 5d3aaaeb2cfba..3ad54a1aea16f 100644
--- a/tests/baselines/reference/for-of25.types
+++ b/tests/baselines/reference/for-of25.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of25.ts] ////
 
 === for-of25.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => any
@@ -23,10 +23,10 @@ class StringIterator {
 var x: any;
 >x : any
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of26.js b/tests/baselines/reference/for-of26.js
index 23a51ad7d8a0d..133ad856d2516 100644
--- a/tests/baselines/reference/for-of26.js
+++ b/tests/baselines/reference/for-of26.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of26.ts] ////
 
 //// [for-of26.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return x;
     }
@@ -11,10 +11,10 @@ class StringIterator {
 }
 
 var x: any;
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of26.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return x;
     }
@@ -23,4 +23,4 @@ class StringIterator {
     }
 }
 var x;
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols
index a5170241f422b..a5b90df679a57 100644
--- a/tests/baselines/reference/for-of26.symbols
+++ b/tests/baselines/reference/for-of26.symbols
@@ -1,30 +1,30 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of26.ts] ////
 
 === for-of26.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of26.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of26.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of26.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of26.ts, 0, 24))
 
         return x;
 >x : Symbol(x, Decl(for-of26.ts, 9, 3))
     }
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of26.ts, 3, 5))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of26.ts, 3, 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(for-of26.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of26.ts, 0, 0))
     }
 }
 
 var x: any;
 >x : Symbol(x, Decl(for-of26.ts, 9, 3))
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of26.ts, 10, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of26.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of26.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of26.types b/tests/baselines/reference/for-of26.types
index d324690555ca0..404fe9d373830 100644
--- a/tests/baselines/reference/for-of26.types
+++ b/tests/baselines/reference/for-of26.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of26.ts] ////
 
 === for-of26.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => any
@@ -31,10 +31,10 @@ class StringIterator {
 var x: any;
 >x : any
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of27.js b/tests/baselines/reference/for-of27.js
index e8e71a9513b90..eaa09a06b72b3 100644
--- a/tests/baselines/reference/for-of27.js
+++ b/tests/baselines/reference/for-of27.js
@@ -1,14 +1,14 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of27.ts] ////
 
 //// [for-of27.ts]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]: any;
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of27.js]
-class StringIterator {
+class MyStringIterator {
 }
 Symbol.iterator;
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols
index 62f6b6a7069f1..a3d03b9f5a89a 100644
--- a/tests/baselines/reference/for-of27.symbols
+++ b/tests/baselines/reference/for-of27.symbols
@@ -1,17 +1,17 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of27.ts] ////
 
 === for-of27.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of27.ts, 0, 0))
 
     [Symbol.iterator]: any;
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of27.ts, 0, 22))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of27.ts, 0, 24))
 >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, --, --))
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of27.ts, 4, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of27.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of27.types b/tests/baselines/reference/for-of27.types
index 9968893ec59b8..c783168764dbe 100644
--- a/tests/baselines/reference/for-of27.types
+++ b/tests/baselines/reference/for-of27.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of27.ts] ////
 
 === for-of27.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     [Symbol.iterator]: any;
 >[Symbol.iterator] : any
@@ -15,10 +15,10 @@ class StringIterator {
 >         : ^^^^^^^^^^^^^
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of28.js b/tests/baselines/reference/for-of28.js
index bddd76685c326..a144ef9260d38 100644
--- a/tests/baselines/reference/for-of28.js
+++ b/tests/baselines/reference/for-of28.js
@@ -1,19 +1,19 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of28.ts] ////
 
 //// [for-of28.ts]
-class StringIterator {
+class MyStringIterator {
     next: any;
     [Symbol.iterator]() {
         return this;
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of28.js]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return this;
     }
 }
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols
index 39b1997ddb66c..d7d95b3491a3c 100644
--- a/tests/baselines/reference/for-of28.symbols
+++ b/tests/baselines/reference/for-of28.symbols
@@ -1,24 +1,24 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of28.ts] ////
 
 === for-of28.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of28.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of28.ts, 0, 0))
 
     next: any;
->next : Symbol(StringIterator.next, Decl(for-of28.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of28.ts, 0, 24))
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of28.ts, 1, 14))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of28.ts, 1, 14))
 >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(for-of28.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of28.ts, 0, 0))
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of28.ts, 7, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of28.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of28.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of28.types b/tests/baselines/reference/for-of28.types
index ba5d79822dfdf..c6d9d8ab16bdb 100644
--- a/tests/baselines/reference/for-of28.types
+++ b/tests/baselines/reference/for-of28.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of28.ts] ////
 
 === for-of28.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next: any;
 >next : any
@@ -24,10 +24,10 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of30.errors.txt b/tests/baselines/reference/for-of30.errors.txt
index c577b8c11a796..e4d06358865d1 100644
--- a/tests/baselines/reference/for-of30.errors.txt
+++ b/tests/baselines/reference/for-of30.errors.txt
@@ -2,7 +2,7 @@ for-of30.ts(16,15): error TS2767: The 'return' property of an iterator must be a
 
 
 ==== for-of30.ts (1 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         next() {
             return {
                 done: false,
@@ -17,6 +17,6 @@ for-of30.ts(16,15): error TS2767: The 'return' property of an iterator must be a
         }
     }
     
-    for (var v of new StringIterator) { }
-                  ~~~~~~~~~~~~~~~~~~
+    for (var v of new MyStringIterator) { }
+                  ~~~~~~~~~~~~~~~~~~~~
 !!! 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 b964ab44e2738..cb7a096a5a6b6 100644
--- a/tests/baselines/reference/for-of30.js
+++ b/tests/baselines/reference/for-of30.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of30.ts] ////
 
 //// [for-of30.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: false,
@@ -16,10 +16,10 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of30.js]
-class StringIterator {
+class MyStringIterator {
     constructor() {
         this.return = 0;
     }
@@ -33,4 +33,4 @@ class StringIterator {
         return this;
     }
 }
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of30.symbols b/tests/baselines/reference/for-of30.symbols
index 39ec1bffa0e66..d6f57f3e9dce0 100644
--- a/tests/baselines/reference/for-of30.symbols
+++ b/tests/baselines/reference/for-of30.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of30.ts] ////
 
 === for-of30.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of30.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of30.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of30.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of30.ts, 0, 24))
 
         return {
             done: false,
@@ -17,20 +17,20 @@ class StringIterator {
     }
 
     return = 0;
->return : Symbol(StringIterator.return, Decl(for-of30.ts, 6, 5))
+>return : Symbol(MyStringIterator.return, Decl(for-of30.ts, 6, 5))
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of30.ts, 8, 15))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of30.ts, 8, 15))
 >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(for-of30.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of30.ts, 0, 0))
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of30.ts, 15, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of30.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of30.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of30.types b/tests/baselines/reference/for-of30.types
index e7e10b3ad168c..3b05a65c38762 100644
--- a/tests/baselines/reference/for-of30.types
+++ b/tests/baselines/reference/for-of30.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of30.ts] ////
 
 === for-of30.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => { done: boolean; value: string; }
@@ -49,11 +49,11 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of31.js b/tests/baselines/reference/for-of31.js
index 8459c4c7c82bd..76395f273241c 100644
--- a/tests/baselines/reference/for-of31.js
+++ b/tests/baselines/reference/for-of31.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of31.ts] ////
 
 //// [for-of31.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             // no done property
@@ -14,10 +14,10 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of31.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             // no done property
@@ -28,4 +28,4 @@ class StringIterator {
         return this;
     }
 }
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of31.symbols b/tests/baselines/reference/for-of31.symbols
index 010e2c4f50cc2..71f3b5773ca92 100644
--- a/tests/baselines/reference/for-of31.symbols
+++ b/tests/baselines/reference/for-of31.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of31.ts] ////
 
 === for-of31.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of31.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of31.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of31.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of31.ts, 0, 24))
 
         return {
             // no done property
@@ -15,17 +15,17 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of31.ts, 6, 5))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of31.ts, 6, 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(for-of31.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of31.ts, 0, 0))
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of31.ts, 13, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of31.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of31.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of31.types b/tests/baselines/reference/for-of31.types
index 4b706a0eb0638..79cf5a3748f86 100644
--- a/tests/baselines/reference/for-of31.types
+++ b/tests/baselines/reference/for-of31.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of31.ts] ////
 
 === for-of31.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => { value: string; }
@@ -38,11 +38,11 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : string
 >  : ^^^^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of33.errors.txt b/tests/baselines/reference/for-of33.errors.txt
index 3937f05d0730f..2549e78d9c7e4 100644
--- a/tests/baselines/reference/for-of33.errors.txt
+++ b/tests/baselines/reference/for-of33.errors.txt
@@ -3,7 +3,7 @@ for-of33.ts(7,10): error TS7022: 'v' implicitly has type 'any' because it does n
 
 
 ==== for-of33.ts (2 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         [Symbol.iterator]() {
         ~~~~~~~~~~~~~~~~~
 !!! error TS7023: '[Symbol.iterator]' 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.
@@ -11,6 +11,6 @@ for-of33.ts(7,10): error TS7022: 'v' implicitly has type 'any' because it does n
         }
     }
     
-    for (var v of new StringIterator) { }
+    for (var v of new MyStringIterator) { }
              ~
 !!! error TS7022: 'v' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of33.js b/tests/baselines/reference/for-of33.js
index ae019516d14c4..5018026b9651e 100644
--- a/tests/baselines/reference/for-of33.js
+++ b/tests/baselines/reference/for-of33.js
@@ -1,18 +1,18 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of33.ts] ////
 
 //// [for-of33.ts]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return v;
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of33.js]
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return v;
     }
 }
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of33.symbols b/tests/baselines/reference/for-of33.symbols
index ece2b2d06e672..89becb49083ab 100644
--- a/tests/baselines/reference/for-of33.symbols
+++ b/tests/baselines/reference/for-of33.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of33.ts] ////
 
 === for-of33.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of33.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of33.ts, 0, 0))
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of33.ts, 0, 22))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of33.ts, 0, 24))
 >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, --, --))
@@ -15,7 +15,7 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of33.ts, 6, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of33.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of33.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of33.types b/tests/baselines/reference/for-of33.types
index ea1266df15efa..c493ce3deab46 100644
--- a/tests/baselines/reference/for-of33.types
+++ b/tests/baselines/reference/for-of33.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of33.ts] ////
 
 === for-of33.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     [Symbol.iterator]() {
 >[Symbol.iterator] : () => any
@@ -21,11 +21,11 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
 >  : ^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of34.errors.txt b/tests/baselines/reference/for-of34.errors.txt
index 8517429bc651e..f2540a155909e 100644
--- a/tests/baselines/reference/for-of34.errors.txt
+++ b/tests/baselines/reference/for-of34.errors.txt
@@ -3,7 +3,7 @@ for-of34.ts(11,10): error TS7022: 'v' implicitly has type 'any' because it does
 
 
 ==== for-of34.ts (2 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         next() {
         ~~~~
 !!! 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.
@@ -15,6 +15,6 @@ for-of34.ts(11,10): error TS7022: 'v' implicitly has type 'any' because it does
         }
     }
     
-    for (var v of new StringIterator) { }
+    for (var v of new MyStringIterator) { }
              ~
 !!! error TS7022: 'v' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of34.js b/tests/baselines/reference/for-of34.js
index d583893db5a8b..bb674e84e1c63 100644
--- a/tests/baselines/reference/for-of34.js
+++ b/tests/baselines/reference/for-of34.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of34.ts] ////
 
 //// [for-of34.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return v;
     }
@@ -11,10 +11,10 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of34.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return v;
     }
@@ -22,4 +22,4 @@ class StringIterator {
         return this;
     }
 }
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of34.symbols b/tests/baselines/reference/for-of34.symbols
index 5f0f856fc918f..d00c6bf26563c 100644
--- a/tests/baselines/reference/for-of34.symbols
+++ b/tests/baselines/reference/for-of34.symbols
@@ -1,28 +1,28 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of34.ts] ////
 
 === for-of34.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of34.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of34.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of34.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of34.ts, 0, 24))
 
         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(MyStringIterator[Symbol.iterator], Decl(for-of34.ts, 3, 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(for-of34.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of34.ts, 0, 0))
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of34.ts, 10, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of34.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of34.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of34.types b/tests/baselines/reference/for-of34.types
index ec160d279249e..7cd4841204cdd 100644
--- a/tests/baselines/reference/for-of34.types
+++ b/tests/baselines/reference/for-of34.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of34.ts] ////
 
 === for-of34.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => any
@@ -30,11 +30,11 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
 >  : ^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/for-of35.errors.txt b/tests/baselines/reference/for-of35.errors.txt
index 19ec2cac8b2ad..52b8e6d498e88 100644
--- a/tests/baselines/reference/for-of35.errors.txt
+++ b/tests/baselines/reference/for-of35.errors.txt
@@ -3,7 +3,7 @@ for-of35.ts(14,10): error TS7022: 'v' implicitly has type 'any' because it does
 
 
 ==== for-of35.ts (2 errors) ====
-    class StringIterator {
+    class MyStringIterator {
         next() {
         ~~~~
 !!! 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.
@@ -18,6 +18,6 @@ for-of35.ts(14,10): error TS7022: 'v' implicitly has type 'any' because it does
         }
     }
     
-    for (var v of new StringIterator) { }
+    for (var v of new MyStringIterator) { }
              ~
 !!! error TS7022: 'v' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer.
\ No newline at end of file
diff --git a/tests/baselines/reference/for-of35.js b/tests/baselines/reference/for-of35.js
index d4b803a929ea0..66b4d298db03a 100644
--- a/tests/baselines/reference/for-of35.js
+++ b/tests/baselines/reference/for-of35.js
@@ -1,7 +1,7 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of35.ts] ////
 
 //// [for-of35.ts]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: true,
@@ -14,10 +14,10 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 
 //// [for-of35.js]
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: true,
@@ -28,4 +28,4 @@ class StringIterator {
         return this;
     }
 }
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
diff --git a/tests/baselines/reference/for-of35.symbols b/tests/baselines/reference/for-of35.symbols
index dd35d74df2817..4f8aa152e0163 100644
--- a/tests/baselines/reference/for-of35.symbols
+++ b/tests/baselines/reference/for-of35.symbols
@@ -1,11 +1,11 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of35.ts] ////
 
 === for-of35.ts ===
-class StringIterator {
->StringIterator : Symbol(StringIterator, Decl(for-of35.ts, 0, 0))
+class MyStringIterator {
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of35.ts, 0, 0))
 
     next() {
->next : Symbol(StringIterator.next, Decl(for-of35.ts, 0, 22))
+>next : Symbol(MyStringIterator.next, Decl(for-of35.ts, 0, 24))
 
         return {
             done: true,
@@ -18,17 +18,17 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->[Symbol.iterator] : Symbol(StringIterator[Symbol.iterator], Decl(for-of35.ts, 6, 5))
+>[Symbol.iterator] : Symbol(MyStringIterator[Symbol.iterator], Decl(for-of35.ts, 6, 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(for-of35.ts, 0, 0))
+>this : Symbol(MyStringIterator, Decl(for-of35.ts, 0, 0))
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : Symbol(v, Decl(for-of35.ts, 13, 8))
->StringIterator : Symbol(StringIterator, Decl(for-of35.ts, 0, 0))
+>MyStringIterator : Symbol(MyStringIterator, Decl(for-of35.ts, 0, 0))
 
diff --git a/tests/baselines/reference/for-of35.types b/tests/baselines/reference/for-of35.types
index d8d5b51f4a132..6f458f5fce0b9 100644
--- a/tests/baselines/reference/for-of35.types
+++ b/tests/baselines/reference/for-of35.types
@@ -1,9 +1,9 @@
 //// [tests/cases/conformance/es6/for-ofStatements/for-of35.ts] ////
 
 === for-of35.ts ===
-class StringIterator {
->StringIterator : StringIterator
->               : ^^^^^^^^^^^^^^
+class MyStringIterator {
+>MyStringIterator : MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^
 
     next() {
 >next : () => any
@@ -43,11 +43,11 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
+for (var v of new MyStringIterator) { }
 >v : any
 >  : ^^^
->new StringIterator : StringIterator
->                   : ^^^^^^^^^^^^^^
->StringIterator : typeof StringIterator
->               : ^^^^^^^^^^^^^^^^^^^^^
+>new MyStringIterator : MyStringIterator
+>                     : ^^^^^^^^^^^^^^^^
+>MyStringIterator : typeof MyStringIterator
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/generatorReturnTypeInference.types b/tests/baselines/reference/generatorReturnTypeInference.types
index e6249102d6437..6f13c13bc8435 100644
--- a/tests/baselines/reference/generatorReturnTypeInference.types
+++ b/tests/baselines/reference/generatorReturnTypeInference.types
@@ -40,8 +40,8 @@ function* g002() { // Generator<number, void, unknown>
 }
 
 function* g003() { // Generator<never, void, undefined>
->g003 : () => Generator<never, void, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g003 : () => Generator<never, void, unknown>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [];
 >yield* [] : any
diff --git a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types
index 03155f5fd2b4e..cd4c2569fbe6b 100644
--- a/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types
+++ b/tests/baselines/reference/generatorReturnTypeInferenceNonStrict.types
@@ -40,8 +40,8 @@ function* g002() { // Generator<number, void, unknown>
 }
 
 function* g003() { // Generator<any (implicit), void, unknown>
->g003 : () => Generator<any, void, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g003 : () => Generator<any, void, unknown>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     // NOTE: In strict mode, `[]` produces the type `never[]`.
     //       In non-strict mode, `[]` produces the type `undefined[]` which is implicitly any.
diff --git a/tests/baselines/reference/generatorTypeCheck22.types b/tests/baselines/reference/generatorTypeCheck22.types
index f8f6580b45433..3e05be0eaa5d9 100644
--- a/tests/baselines/reference/generatorTypeCheck22.types
+++ b/tests/baselines/reference/generatorTypeCheck22.types
@@ -22,8 +22,8 @@ class Baz { z: number }
 >  : ^^^^^^
 
 function* g3() {
->g3 : () => Generator<Bar | Baz, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g3 : () => Generator<Bar | Baz, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck23.types b/tests/baselines/reference/generatorTypeCheck23.types
index 50e76794cc437..2fdf66a6e6976 100644
--- a/tests/baselines/reference/generatorTypeCheck23.types
+++ b/tests/baselines/reference/generatorTypeCheck23.types
@@ -22,8 +22,8 @@ class Baz { z: number }
 >  : ^^^^^^
 
 function* g3() {
->g3 : () => Generator<Foo | Baz, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g3 : () => Generator<Foo | Baz, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck24.types b/tests/baselines/reference/generatorTypeCheck24.types
index d0869e1134889..13bfe853c6d4b 100644
--- a/tests/baselines/reference/generatorTypeCheck24.types
+++ b/tests/baselines/reference/generatorTypeCheck24.types
@@ -22,8 +22,8 @@ class Baz { z: number }
 >  : ^^^^^^
 
 function* g3() {
->g3 : () => Generator<Foo | Baz, void, any>
->   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g3 : () => Generator<Foo | Baz, void, unknown>
+>   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck25.errors.txt b/tests/baselines/reference/generatorTypeCheck25.errors.txt
index 2113fedd55fd5..5a0fdf0fc791a 100644
--- a/tests/baselines/reference/generatorTypeCheck25.errors.txt
+++ b/tests/baselines/reference/generatorTypeCheck25.errors.txt
@@ -1,5 +1,5 @@
-generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator<Bar | Baz, void, any>' is not assignable to type '() => Iterable<Foo>'.
-  Call signature return types 'Generator<Bar | Baz, void, any>' and 'Iterable<Foo>' are incompatible.
+generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator<Bar | Baz, void, unknown>' is not assignable to type '() => Iterable<Foo>'.
+  Call signature return types 'Generator<Bar | Baz, void, unknown>' and 'Iterable<Foo>' are incompatible.
     The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
       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>'.
@@ -14,8 +14,8 @@ generatorTypeCheck25.ts(4,5): error TS2322: Type '() => Generator<Bar | Baz, voi
     class Baz { z: number }
     var g3: () => Iterable<Foo> = function* () {
         ~~
-!!! error TS2322: Type '() => Generator<Bar | Baz, void, any>' is not assignable to type '() => Iterable<Foo>'.
-!!! error TS2322:   Call signature return types 'Generator<Bar | Baz, void, any>' and 'Iterable<Foo>' are incompatible.
+!!! error TS2322: Type '() => Generator<Bar | Baz, void, unknown>' is not assignable to type '() => Iterable<Foo>'.
+!!! error TS2322:   Call signature return types 'Generator<Bar | Baz, void, unknown>' and 'Iterable<Foo>' are incompatible.
 !!! error TS2322:     The types returned by '[Symbol.iterator]().next(...)' are incompatible between these types.
 !!! 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>'.
diff --git a/tests/baselines/reference/generatorTypeCheck25.types b/tests/baselines/reference/generatorTypeCheck25.types
index 322bb4b92688c..65a5e73672b80 100644
--- a/tests/baselines/reference/generatorTypeCheck25.types
+++ b/tests/baselines/reference/generatorTypeCheck25.types
@@ -24,8 +24,8 @@ 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];} : () => Generator<Bar | Baz, void, any>
->                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>function* () {    yield;    yield new Bar;    yield new Baz;    yield *[new Bar];    yield *[new Baz];} : () => Generator<Bar | Baz, void, unknown>
+>                                                                                                        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield;
 >yield : any
diff --git a/tests/baselines/reference/generatorTypeCheck53.types b/tests/baselines/reference/generatorTypeCheck53.types
index 308c3c45f0e42..96cfa3ff36c4a 100644
--- a/tests/baselines/reference/generatorTypeCheck53.types
+++ b/tests/baselines/reference/generatorTypeCheck53.types
@@ -14,8 +14,8 @@ class Baz { z: number }
 >  : ^^^^^^
 
 function* g() {
->g : () => Generator<Foo | Baz, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g : () => Generator<Foo | Baz, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield new Foo;
 >yield new Foo : any
diff --git a/tests/baselines/reference/generatorTypeCheck54.types b/tests/baselines/reference/generatorTypeCheck54.types
index 3162d1537f12c..fc37b2ba451f0 100644
--- a/tests/baselines/reference/generatorTypeCheck54.types
+++ b/tests/baselines/reference/generatorTypeCheck54.types
@@ -14,8 +14,8 @@ class Baz { z: number }
 >  : ^^^^^^
 
 function* g() {
->g : () => Generator<Foo | Baz, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>g : () => Generator<Foo | Baz, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [new Foo];
 >yield* [new Foo] : any
diff --git a/tests/baselines/reference/importAliasInModuleAugmentation.types b/tests/baselines/reference/importAliasInModuleAugmentation.types
index 5733d12e0d40f..361cff4f663d4 100644
--- a/tests/baselines/reference/importAliasInModuleAugmentation.types
+++ b/tests/baselines/reference/importAliasInModuleAugmentation.types
@@ -5,41 +5,60 @@ export { }
 
 namespace A {
 >A : typeof A
+>  : ^^^^^^^^
 
     export const y = 34;
 >y : 34
+>  : ^^
 >34 : 34
+>   : ^^
 
     export interface y { s: string }
 >s : string
+>  : ^^^^^^
 }
 
 declare global {
 >global : typeof global
+>       : ^^^^^^^^^^^^^
 
     export import x = A.y;
 >x : 34
+>  : ^^
 >A : typeof A
+>  : ^^^^^^^^
 >y : x
+>  : ^
 
     // Should still error
     import f = require("fs");
 >f : any
+>  : ^^^
 }
 
 const m: number = x;
 >m : number
+>  : ^^^^^^
 >x : 34
+>  : ^^
 
 let s: x = { s: "" };
 >s : x
+>  : ^
 >{ s: "" } : { s: string; }
+>          : ^^^^^^^^^^^^^^
 >s : string
+>  : ^^^^^^
 >"" : ""
+>   : ^^
 
 void s.s;
 >void s.s : undefined
+>         : ^^^^^^^^^
 >s.s : string
+>    : ^^^^^^
 >s : x
+>  : ^
 >s : string
+>  : ^^^^^^
 
diff --git a/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types b/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types
index 3bf6420170b9d..9d221f738586b 100644
--- a/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types
+++ b/tests/baselines/reference/importHelpersNoHelpersForAsyncGenerators.types
@@ -2,8 +2,8 @@
 
 === main.ts ===
 export async function * f() {
->f : () => AsyncGenerator<number, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<number, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     await 1;
 >await 1 : 1
diff --git a/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types b/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types
index 65c655b1ea332..56cc1e8004baa 100644
--- a/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types
+++ b/tests/baselines/reference/indirectGlobalSymbolPartOfObjectType.types
@@ -13,8 +13,8 @@ const Symbol = globalThis.Symbol;
 >       : ^^^^^^^^^^^^^^^^^
 
 [][Symbol.iterator];
->[][Symbol.iterator] : () => BuiltinIterator<undefined, any, any>
->                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[][Symbol.iterator] : () => ArrayIterator<undefined>
+>                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >[] : undefined[]
 >   : ^^^^^^^^^^^
 >Symbol.iterator : unique symbol
diff --git a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
index c4a3eace14466..e20de1c2bbd86 100644
--- a/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
+++ b/tests/baselines/reference/inferFromGenericFunctionReturnTypes3.types
@@ -1,5 +1,8 @@
 //// [tests/cases/compiler/inferFromGenericFunctionReturnTypes3.ts] ////
 
+=== Performance Stats ===
+Type Count: 1,000
+
 === inferFromGenericFunctionReturnTypes3.ts ===
 // Repros from #5487
 
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js
index b79d0bfee7fa5..9a58042032979 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).js
@@ -37,9 +37,9 @@ class MyMap implements Map<string, number> {
     get(key: string): number | undefined { return undefined; }
     has(key: string): boolean { return false; }
     set(key: string, value: number): this { return this; }
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols
index c1e1de41c3035..1806f8d645812 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).symbols
@@ -118,30 +118,27 @@ class MyMap implements Map<string, number> {
 >value : Symbol(value, Decl(iterableTReturnTNext.ts, 35, 20))
 >this : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57))
 
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
 >entries : Symbol(MyMap.entries, Decl(iterableTReturnTNext.ts, 35, 58))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+>MapIterator : Symbol(MapIterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->keys : Symbol(MyMap.keys, Decl(iterableTReturnTNext.ts, 36, 119))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+>keys : Symbol(MyMap.keys, Decl(iterableTReturnTNext.ts, 36, 92))
+>MapIterator : Symbol(MapIterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->[Symbol.iterator] : Symbol(MyMap[Symbol.iterator], Decl(iterableTReturnTNext.ts, 37, 106))
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+>[Symbol.iterator] : Symbol(MyMap[Symbol.iterator], Decl(iterableTReturnTNext.ts, 37, 79))
 >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, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+>MapIterator : Symbol(MapIterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
->values : Symbol(MyMap.values, Decl(iterableTReturnTNext.ts, 38, 129))
+>values : Symbol(MyMap.values, Decl(iterableTReturnTNext.ts, 38, 102))
 
         yield* this._values;
 >this._values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36))
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types
index 64293b894dba4..881e9e6a2af25 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=false).types
@@ -18,18 +18,18 @@ const r1: number = map.values().next().value; // error when strictBuiltinIterato
 >map.values().next().value : any
 >map.values().next() : IteratorResult<number, any>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values().next : (...[value]: [] | [any]) => IteratorResult<number, any>
->                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values() : BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values : () => BuiltinIterator<number, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values().next : (...[value]: [] | [unknown]) => IteratorResult<number, any>
+>                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values() : MapIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>map.values : () => MapIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->values : () => BuiltinIterator<number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->next : (...[value]: [] | [any]) => IteratorResult<number, any>
->     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => MapIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>next : (...[value]: [] | [unknown]) => IteratorResult<number, any>
+>     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : any
 >      : ^^^
 
@@ -48,18 +48,18 @@ const r2: Next<number> = map.values().next(); // error when strictBuiltinIterato
 >   : ^^^^^^^^^^^^
 >map.values().next() : IteratorResult<number, any>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values().next : (...[value]: [] | [any]) => IteratorResult<number, any>
->                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values() : BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values : () => BuiltinIterator<number, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values().next : (...[value]: [] | [unknown]) => IteratorResult<number, any>
+>                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values() : MapIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>map.values : () => MapIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->values : () => BuiltinIterator<number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->next : (...[value]: [] | [any]) => IteratorResult<number, any>
->     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => MapIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>next : (...[value]: [] | [unknown]) => IteratorResult<number, any>
+>     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175
 async function* source() { yield 1; yield 2; yield 3; }
@@ -100,18 +100,18 @@ const r3: number | undefined = set.values().next().value;
 >set.values().next().value : any
 >set.values().next() : IteratorResult<number, any>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values().next : (...[value]: [] | [any]) => IteratorResult<number, any>
->                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values() : BuiltinIterator<number, any, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values : () => BuiltinIterator<number, any, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.values().next : (...[value]: [] | [unknown]) => IteratorResult<number, any>
+>                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.values() : SetIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>set.values : () => SetIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->values : () => BuiltinIterator<number, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->next : (...[value]: [] | [any]) => IteratorResult<number, any>
->     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => SetIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>next : (...[value]: [] | [unknown]) => IteratorResult<number, any>
+>     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : any
 >      : ^^^
 
@@ -193,9 +193,9 @@ class MyMap implements Map<string, number> {
 >this : this
 >     : ^^^^
 
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->entries : () => BuiltinIterator<[string, number], BuiltinIteratorReturn>
->        : ^^^^^^                                                        
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+>entries : () => MapIterator<[string, number]>
+>        : ^^^^^^                             
 >new Error("Method not implemented.") : Error
 >                                     : ^^^^^
 >Error : ErrorConstructor
@@ -203,9 +203,9 @@ class MyMap implements Map<string, number> {
 >"Method not implemented." : "Method not implemented."
 >                          : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->keys : () => BuiltinIterator<string, BuiltinIteratorReturn>
->     : ^^^^^^                                              
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+>keys : () => MapIterator<string>
+>     : ^^^^^^                   
 >new Error("Method not implemented.") : Error
 >                                     : ^^^^^
 >Error : ErrorConstructor
@@ -213,9 +213,9 @@ class MyMap implements Map<string, number> {
 >"Method not implemented." : "Method not implemented."
 >                          : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->[Symbol.iterator] : () => BuiltinIterator<[string, number], BuiltinIteratorReturn>
->                  : ^^^^^^                                                        
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+>[Symbol.iterator] : () => MapIterator<[string, number]>
+>                  : ^^^^^^                             
 >Symbol.iterator : unique symbol
 >                : ^^^^^^^^^^^^^
 >Symbol : SymbolConstructor
@@ -231,8 +231,8 @@ class MyMap implements Map<string, number> {
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
->values : () => Generator<number, void, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => Generator<number, void, unknown>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         yield* this._values;
 >yield* this._values : any
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt
index 4912e19f699a7..00a1ae1a8d330 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).errors.txt
@@ -5,8 +5,8 @@ iterableTReturnTNext.ts(14,7): error TS2322: Type 'IteratorResult<number, undefi
     Types of property 'value' are incompatible.
       Type 'undefined' is not assignable to type 'number'.
 iterableTReturnTNext.ts(42,7): error TS2416: Property 'values' in type 'MyMap' is not assignable to the same property in base type 'Map<string, number>'.
-  Type '() => Generator<number, void, any>' is not assignable to type '() => BuiltinIterator<number, undefined, any>'.
-    Call signature return types 'Generator<number, void, any>' and 'BuiltinIterator<number, undefined, any>' are incompatible.
+  Type '() => Generator<number, void, unknown>' is not assignable to type '() => MapIterator<number>'.
+    Call signature return types 'Generator<number, void, unknown>' and 'MapIterator<number>' are incompatible.
       The types returned by 'next(...)' are incompatible between these types.
         Type 'IteratorResult<number, void>' is not assignable to type 'IteratorResult<number, undefined>'.
           Type 'IteratorReturnResult<void>' is not assignable to type 'IteratorResult<number, undefined>'.
@@ -59,16 +59,16 @@ iterableTReturnTNext.ts(42,7): error TS2416: Property 'values' in type 'MyMap' i
         get(key: string): number | undefined { return undefined; }
         has(key: string): boolean { return false; }
         set(key: string, value: number): this { return this; }
-        entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-        keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-        [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
+        entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+        keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+        [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
     
         // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
         * values() {
           ~~~~~~
 !!! error TS2416: Property 'values' in type 'MyMap' is not assignable to the same property in base type 'Map<string, number>'.
-!!! error TS2416:   Type '() => Generator<number, void, any>' is not assignable to type '() => BuiltinIterator<number, undefined, any>'.
-!!! error TS2416:     Call signature return types 'Generator<number, void, any>' and 'BuiltinIterator<number, undefined, any>' are incompatible.
+!!! error TS2416:   Type '() => Generator<number, void, unknown>' is not assignable to type '() => MapIterator<number>'.
+!!! error TS2416:     Call signature return types 'Generator<number, void, unknown>' and 'MapIterator<number>' are incompatible.
 !!! error TS2416:       The types returned by 'next(...)' are incompatible between these types.
 !!! error TS2416:         Type 'IteratorResult<number, void>' is not assignable to type 'IteratorResult<number, undefined>'.
 !!! error TS2416:           Type 'IteratorReturnResult<void>' is not assignable to type 'IteratorResult<number, undefined>'.
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js
index b79d0bfee7fa5..9a58042032979 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).js
@@ -37,9 +37,9 @@ class MyMap implements Map<string, number> {
     get(key: string): number | undefined { return undefined; }
     has(key: string): boolean { return false; }
     set(key: string, value: number): this { return this; }
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols
index c1e1de41c3035..1806f8d645812 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).symbols
@@ -118,30 +118,27 @@ class MyMap implements Map<string, number> {
 >value : Symbol(value, Decl(iterableTReturnTNext.ts, 35, 20))
 >this : Symbol(MyMap, Decl(iterableTReturnTNext.ts, 21, 57))
 
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
 >entries : Symbol(MyMap.entries, Decl(iterableTReturnTNext.ts, 35, 58))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+>MapIterator : Symbol(MapIterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->keys : Symbol(MyMap.keys, Decl(iterableTReturnTNext.ts, 36, 119))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+>keys : Symbol(MyMap.keys, Decl(iterableTReturnTNext.ts, 36, 92))
+>MapIterator : Symbol(MapIterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->[Symbol.iterator] : Symbol(MyMap[Symbol.iterator], Decl(iterableTReturnTNext.ts, 37, 106))
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+>[Symbol.iterator] : Symbol(MyMap[Symbol.iterator], Decl(iterableTReturnTNext.ts, 37, 79))
 >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, --, --), Decl(lib.es2019.symbol.d.ts, --, --))
 >iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --))
->BuiltinIterator : Symbol(BuiltinIterator, Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.esnext.iterator.d.ts, --, --))
->BuiltinIteratorReturn : Symbol(BuiltinIteratorReturn, Decl(lib.es2015.iterable.d.ts, --, --))
+>MapIterator : Symbol(MapIterator, Decl(lib.es2015.iterable.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --))
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
->values : Symbol(MyMap.values, Decl(iterableTReturnTNext.ts, 38, 129))
+>values : Symbol(MyMap.values, Decl(iterableTReturnTNext.ts, 38, 102))
 
         yield* this._values;
 >this._values : Symbol(MyMap._values, Decl(iterableTReturnTNext.ts, 25, 36))
diff --git a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types
index 71a1e6da57570..a18a9d65133f7 100644
--- a/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types
+++ b/tests/baselines/reference/iterableTReturnTNext(strictbuiltiniteratorreturn=true).types
@@ -19,18 +19,18 @@ const r1: number = map.values().next().value; // error when strictBuiltinIterato
 >                          : ^^^^^^^^^^^^^^^^^^
 >map.values().next() : IteratorResult<number, undefined>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values().next : (...[value]: [] | [any]) => IteratorResult<number, undefined>
->                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values() : BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values : () => BuiltinIterator<number, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values().next : (...[value]: [] | [unknown]) => IteratorResult<number, undefined>
+>                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values() : MapIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>map.values : () => MapIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->next : (...[value]: [] | [any]) => IteratorResult<number, undefined>
->     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => MapIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>next : (...[value]: [] | [unknown]) => IteratorResult<number, undefined>
+>     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : number | undefined
 >      : ^^^^^^^^^^^^^^^^^^
 
@@ -49,18 +49,18 @@ const r2: Next<number> = map.values().next(); // error when strictBuiltinIterato
 >   : ^^^^^^^^^^^^
 >map.values().next() : IteratorResult<number, undefined>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values().next : (...[value]: [] | [any]) => IteratorResult<number, undefined>
->                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values() : BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->map.values : () => BuiltinIterator<number, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values().next : (...[value]: [] | [unknown]) => IteratorResult<number, undefined>
+>                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>map.values() : MapIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>map.values : () => MapIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >map : Map<string, number>
 >    : ^^^^^^^^^^^^^^^^^^^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->next : (...[value]: [] | [any]) => IteratorResult<number, undefined>
->     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => MapIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>next : (...[value]: [] | [unknown]) => IteratorResult<number, undefined>
+>     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // based on: https://github.com/graphql/graphql-js/blob/e15c3ec4dc21d9fd1df34fe9798cadf3bf02c6ea/src/execution/__tests__/mapAsyncIterable-test.ts#L175
 async function* source() { yield 1; yield 2; yield 3; }
@@ -105,18 +105,18 @@ const r3: number | undefined = set.values().next().value;
 >                          : ^^^^^^^^^^^^^^^^^^
 >set.values().next() : IteratorResult<number, undefined>
 >                    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values().next : (...[value]: [] | [any]) => IteratorResult<number, undefined>
->                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values() : BuiltinIterator<number, undefined, any>
->             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->set.values : () => BuiltinIterator<number, undefined, any>
->           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.values().next : (...[value]: [] | [unknown]) => IteratorResult<number, undefined>
+>                  : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>set.values() : SetIterator<number>
+>             : ^^^^^^^^^^^^^^^^^^^
+>set.values : () => SetIterator<number>
+>           : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >set : Set<number>
 >    : ^^^^^^^^^^^
->values : () => BuiltinIterator<number, undefined, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->next : (...[value]: [] | [any]) => IteratorResult<number, undefined>
->     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => SetIterator<number>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
+>next : (...[value]: [] | [unknown]) => IteratorResult<number, undefined>
+>     : ^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >value : number | undefined
 >      : ^^^^^^^^^^^^^^^^^^
 
@@ -199,9 +199,9 @@ class MyMap implements Map<string, number> {
 >this : this
 >     : ^^^^
 
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->entries : () => BuiltinIterator<[string, number], BuiltinIteratorReturn>
->        : ^^^^^^                                                        
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+>entries : () => MapIterator<[string, number]>
+>        : ^^^^^^                             
 >new Error("Method not implemented.") : Error
 >                                     : ^^^^^
 >Error : ErrorConstructor
@@ -209,9 +209,9 @@ class MyMap implements Map<string, number> {
 >"Method not implemented." : "Method not implemented."
 >                          : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->keys : () => BuiltinIterator<string, BuiltinIteratorReturn>
->     : ^^^^^^                                              
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+>keys : () => MapIterator<string>
+>     : ^^^^^^                   
 >new Error("Method not implemented.") : Error
 >                                     : ^^^^^
 >Error : ErrorConstructor
@@ -219,9 +219,9 @@ class MyMap implements Map<string, number> {
 >"Method not implemented." : "Method not implemented."
 >                          : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
->[Symbol.iterator] : () => BuiltinIterator<[string, number], BuiltinIteratorReturn>
->                  : ^^^^^^                                                        
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+>[Symbol.iterator] : () => MapIterator<[string, number]>
+>                  : ^^^^^^                             
 >Symbol.iterator : unique symbol
 >                : ^^^^^^^^^^^^^
 >Symbol : SymbolConstructor
@@ -237,8 +237,8 @@ class MyMap implements Map<string, number> {
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
->values : () => Generator<number, void, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>values : () => Generator<number, void, unknown>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         yield* this._values;
 >yield* this._values : undefined
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.errors.txt b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.errors.txt
index bca4e124b9ed3..2dae16154f20d 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.errors.txt
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.errors.txt
@@ -1,4 +1,4 @@
-mappedTypeWithAsClauseAndLateBoundProperty.ts(3,1): error TS2741: Property 'length' is missing in type '{ [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, any, any>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }' but required in type 'number[]'.
+mappedTypeWithAsClauseAndLateBoundProperty.ts(3,1): error TS2741: Property 'length' is missing in type '{ [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }' but required in type 'number[]'.
 
 
 ==== mappedTypeWithAsClauseAndLateBoundProperty.ts (1 errors) ====
@@ -6,6 +6,6 @@ mappedTypeWithAsClauseAndLateBoundProperty.ts(3,1): error TS2741: Property 'leng
     declare let src2: { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] };
     tgt2 = src2; // Should error
     ~~~~
-!!! error TS2741: Property 'length' is missing in type '{ [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, any, any>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }' but required in type 'number[]'.
+!!! error TS2741: Property 'length' is missing in type '{ [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: NumberFormatOptions & DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }' but required in type 'number[]'.
 !!! related TS2728 lib.es5.d.ts:--:--: 'length' is declared here.
     
\ No newline at end of file
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types
index 7caab51892d4f..7dcab74e21c48 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty.types
@@ -6,14 +6,14 @@ declare let tgt2: number[];
 >     : ^^^^^^^^
 
 declare let src2: { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] };
->src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, BuiltinIteratorReturn>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 tgt2 = src2; // Should error
->tgt2 = src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, BuiltinIteratorReturn>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>tgt2 = src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >tgt2 : number[]
 >     : ^^^^^^^^
->src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, BuiltinIteratorReturn>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>src2 : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js
index 4aa389086c111..36696aa90cffe 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.js
@@ -62,13 +62,13 @@ export declare const thing: {
     findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number;
     fill: (value: number, start?: number, end?: number) => number[];
     copyWithin: (target: number, start: number, end?: number) => number[];
-    entries: () => BuiltinIterator<[number, number], any, any>;
-    keys: () => BuiltinIterator<number, BuiltinIteratorReturn>;
-    values: () => BuiltinIterator<number, any, any>;
+    entries: () => ArrayIterator<[number, number]>;
+    keys: () => ArrayIterator<number>;
+    values: () => ArrayIterator<number>;
     includes: (searchElement: number, fromIndex?: number) => boolean;
     flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[];
     flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[];
-    [Symbol.iterator]: () => BuiltinIterator<number, any, any>;
+    [Symbol.iterator]: () => ArrayIterator<number>;
     readonly [Symbol.unscopables]: {
         [x: number]: boolean;
         length?: boolean;
diff --git a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types
index 4f712549244c2..8e0a2e605bb3e 100644
--- a/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types
+++ b/tests/baselines/reference/mappedTypeWithAsClauseAndLateBoundProperty2.types
@@ -2,11 +2,11 @@
 
 === mappedTypeWithAsClauseAndLateBoundProperty2.ts ===
 export const thing = (null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] });
->thing : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, BuiltinIteratorReturn>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->(null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] }) : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, BuiltinIteratorReturn>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] } : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => BuiltinIterator<[number, number], any, any>; keys: () => BuiltinIterator<number, BuiltinIteratorReturn>; values: () => BuiltinIterator<number, any, any>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => BuiltinIterator<number, any, any>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
->                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>thing : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>(null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] }) : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>                                                                                  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>null as any as { [K in keyof number[] as Exclude<K, "length">]: (number[])[K] } : { [x: number]: number; toString: () => string; toLocaleString: { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }; pop: () => number; push: (...items: number[]) => number; concat: { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }; join: (separator?: string) => string; reverse: () => number[]; shift: () => number; slice: (start?: number, end?: number) => number[]; sort: (compareFn?: (a: number, b: number) => number) => number[]; splice: { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }; unshift: (...items: number[]) => number; indexOf: (searchElement: number, fromIndex?: number) => number; lastIndexOf: (searchElement: number, fromIndex?: number) => number; every: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): boolean; }; some: (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any) => boolean; forEach: (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void; map: <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]; filter: { <S extends number>(predicate: (value: number, index: number, array: number[]) => value is S, thisArg?: any): S[]; (predicate: (value: number, index: number, array: number[]) => unknown, thisArg?: any): number[]; }; reduce: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; reduceRight: { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }; find: { <S extends number>(predicate: (value: number, index: number, obj: number[]) => value is S, thisArg?: any): S; (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any): number; }; findIndex: (predicate: (value: number, index: number, obj: number[]) => unknown, thisArg?: any) => number; fill: (value: number, start?: number, end?: number) => number[]; copyWithin: (target: number, start: number, end?: number) => number[]; entries: () => ArrayIterator<[number, number]>; keys: () => ArrayIterator<number>; values: () => ArrayIterator<number>; includes: (searchElement: number, fromIndex?: number) => boolean; flatMap: <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]; flat: <A, D extends number = 1>(this: A, depth?: D) => FlatArray<A, D>[]; [Symbol.iterator]: () => ArrayIterator<number>; readonly [Symbol.unscopables]: { [x: number]: boolean; length?: boolean; toString?: boolean; toLocaleString?: boolean; pop?: boolean; push?: boolean; concat?: boolean; join?: boolean; reverse?: boolean; shift?: boolean; slice?: boolean; sort?: boolean; splice?: boolean; unshift?: boolean; indexOf?: boolean; lastIndexOf?: boolean; every?: boolean; some?: boolean; forEach?: boolean; map?: boolean; filter?: boolean; reduce?: boolean; reduceRight?: boolean; find?: boolean; findIndex?: boolean; fill?: boolean; copyWithin?: boolean; entries?: boolean; keys?: boolean; values?: boolean; includes?: boolean; flatMap?: boolean; flat?: boolean; [Symbol.iterator]?: boolean; readonly [Symbol.unscopables]?: boolean; }; }
+>                                                                                : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^      ^^^       ^^                 ^^       ^^^                                                     ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^         ^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^      ^^           ^^^      ^^^^^^^^^^^^^^     ^^      ^^           ^^      ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     ^^^^^^^^^^^^^^^      ^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^      ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^        ^  ^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^       ^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^       ^^^^^^^^^^^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^    ^^       ^^^   ^^^^^    ^^^^^^^^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^          ^^^             ^^^^^^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^ ^^          ^^^             ^^^^^            ^^^^^^^^^^            ^^      ^^     ^^^^^^^^^^^^^^^^^^            ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^^^^^^^^^^^^^^^^^^^^^^         ^^^     ^^^^^^^^^^     ^^      ^^   ^^^^^^^^^^^^^^^       ^^       ^^^   ^^^^^      ^^^^^^^^^     ^^^^^^^^^^     ^^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^      ^^      ^^     ^^      ^^   ^^^      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^             ^^^^^^^^^^         ^^^      ^^^^^       ^^^^^^^^^^^^ ^^    ^^^^^^^^^^^^^^        ^^^    ^^^^^^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^      ^^^^^^    ^^^^^     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 >null as any : any
 
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
index 075659bb6c643..7e3956c6ebc25 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.types
@@ -58,14 +58,14 @@ m.clear();
 
 // Using ES6 iterable
 m.keys();
->m.keys() : BuiltinIterator<string, any, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->m.keys : () => BuiltinIterator<string, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>m.keys() : MapIterator<string>
+>         : ^^^^^^^^^^^^^^^^^^^
+>m.keys : () => MapIterator<string>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
->keys : () => BuiltinIterator<string, any, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => MapIterator<string>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
index 21ebd84450062..6901043410e96 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.types
@@ -58,14 +58,14 @@ m.clear();
 
 // Using ES6 iterable
 m.keys();
->m.keys() : BuiltinIterator<string, any, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->m.keys : () => BuiltinIterator<string, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>m.keys() : MapIterator<string>
+>         : ^^^^^^^^^^^^^^^^^^^
+>m.keys : () => MapIterator<string>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
->keys : () => BuiltinIterator<string, any, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => MapIterator<string>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
index 14688b34b1362..a1da8cedb1464 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.types
@@ -58,14 +58,14 @@ m.clear();
 
 // Using ES6 iterable
 m.keys();
->m.keys() : BuiltinIterator<string, any, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->m.keys : () => BuiltinIterator<string, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>m.keys() : MapIterator<string>
+>         : ^^^^^^^^^^^^^^^^^^^
+>m.keys : () => MapIterator<string>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
->keys : () => BuiltinIterator<string, any, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => MapIterator<string>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
index 67cc3c013d5a8..dad02bc4bf693 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
+++ b/tests/baselines/reference/modularizeLibrary_TargetES6UsingES6Lib.types
@@ -58,14 +58,14 @@ m.clear();
 
 // Using ES6 iterable
 m.keys();
->m.keys() : BuiltinIterator<string, any, any>
->         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->m.keys : () => BuiltinIterator<string, any, any>
->       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>m.keys() : MapIterator<string>
+>         : ^^^^^^^^^^^^^^^^^^^
+>m.keys : () => MapIterator<string>
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^
 >m : Map<string, number>
 >  : ^^^^^^^^^^^^^^^^^^^
->keys : () => BuiltinIterator<string, any, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>keys : () => MapIterator<string>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 // Using ES6 function
 function Baz() { }
diff --git a/tests/baselines/reference/narrowingPastLastAssignment.types b/tests/baselines/reference/narrowingPastLastAssignment.types
index ba185b982df4f..057c24d71516e 100644
--- a/tests/baselines/reference/narrowingPastLastAssignment.types
+++ b/tests/baselines/reference/narrowingPastLastAssignment.types
@@ -2,7 +2,7 @@
 
 === Performance Stats ===
 Type Count: 1,000
-Instantiation count: 1,000
+Instantiation count: 2,500
 
 === narrowingPastLastAssignment.ts ===
 function action(f: Function) {}
diff --git a/tests/baselines/reference/newNamesInGlobalAugmentations1.types b/tests/baselines/reference/newNamesInGlobalAugmentations1.types
index f46c99b0c5bca..324a8b494003a 100644
--- a/tests/baselines/reference/newNamesInGlobalAugmentations1.types
+++ b/tests/baselines/reference/newNamesInGlobalAugmentations1.types
@@ -26,7 +26,6 @@ declare global {
 >Cls : Cls
 >    : ^^^
 >x : any
->  : ^^^
 
     let [a, b]: number[];
 >a : number
@@ -56,7 +55,6 @@ Symbol.observable;
 
 new Cls().x
 >new Cls().x : any
->            : ^^^
 >new Cls() : Cls
 >          : ^^^
 >Cls : typeof Cls
diff --git a/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types b/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types
index e138921e963b2..61141eebd4c63 100644
--- a/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types
+++ b/tests/baselines/reference/parenthesizedJSDocCastAtReturnStatement.types
@@ -2,7 +2,7 @@
 
 === Performance Stats ===
 Type Count: 1,000
-Instantiation count: 1,000
+Instantiation count: 2,500
 
 === index.js ===
 /** @type {Map<string, string | Set<string>>} */
diff --git a/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types
index 41859c1f7190e..1aa65a69c8cd4 100644
--- a/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.classMethods.es2018.types
@@ -221,8 +221,8 @@ class C16 {
 >    : ^^^
 
     async * f() {
->f : () => AsyncGenerator<any, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<any, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         yield * [];
 >yield * [] : any
diff --git a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types
index 145171838a86b..8b708f94c95a6 100644
--- a/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.functionDeclarations.es2018.types
@@ -142,8 +142,8 @@ async function * f15() {
 }
 === yieldStarWithValueIsOk.ts ===
 async function * f16() {
->f16 : () => AsyncGenerator<any, void, any>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f16 : () => AsyncGenerator<any, void, unknown>
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield * [];
 >yield * [] : any
diff --git a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types
index 9082a5732d5a0..036bdb2f62b80 100644
--- a/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.functionExpressions.es2018.types
@@ -188,10 +188,10 @@ const f15 = async function * () {
 };
 === yieldStarWithValueIsOk.ts ===
 const f16 = async function * () {
->f16 : () => AsyncGenerator<any, void, any>
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->async function * () {    yield * [];} : () => AsyncGenerator<any, void, any>
->                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f16 : () => AsyncGenerator<any, void, unknown>
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield * [];} : () => AsyncGenerator<any, void, unknown>
+>                                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield * [];
 >yield * [] : any
diff --git a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types
index a1c287cfa1fd3..0a67b43853d48 100644
--- a/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types
+++ b/tests/baselines/reference/parser.asyncGenerators.objectLiteralMethods.es2018.types
@@ -247,14 +247,14 @@ const o15 = {
 };
 === yieldStarWithValueIsOk.ts ===
 const o16 = {
->o16 : { f(): AsyncGenerator<any, void, any>; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->{    async * f() {        yield * [];    }} : { f(): AsyncGenerator<any, void, any>; }
->                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>o16 : { f(): AsyncGenerator<any, void, unknown>; }
+>    : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>{    async * f() {        yield * [];    }} : { f(): AsyncGenerator<any, void, unknown>; }
+>                                            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     async * f() {
->f : () => AsyncGenerator<any, void, any>
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>f : () => AsyncGenerator<any, void, unknown>
+>  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
         yield * [];
 >yield * [] : any
diff --git a/tests/baselines/reference/regexMatchAll-esnext.types b/tests/baselines/reference/regexMatchAll-esnext.types
index 80790de11283e..af8bf8d1466a9 100644
--- a/tests/baselines/reference/regexMatchAll-esnext.types
+++ b/tests/baselines/reference/regexMatchAll-esnext.types
@@ -2,12 +2,12 @@
 
 === regexMatchAll-esnext.ts ===
 const matches = /\w/g[Symbol.matchAll]("matchAll");
->matches : BuiltinIterator<RegExpMatchArray, any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->/\w/g[Symbol.matchAll]("matchAll") : BuiltinIterator<RegExpMatchArray, any, any>
->                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->/\w/g[Symbol.matchAll] : (str: string) => BuiltinIterator<RegExpMatchArray, BuiltinIteratorReturn>
->                       : ^   ^^      ^^^^^                                                        
+>matches : RegExpStringIterator<RegExpMatchArray>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>/\w/g[Symbol.matchAll]("matchAll") : RegExpStringIterator<RegExpMatchArray>
+>                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>/\w/g[Symbol.matchAll] : (str: string) => RegExpStringIterator<RegExpMatchArray>
+>                       : ^   ^^      ^^^^^                                      
 >/\w/g : RegExp
 >      : ^^^^^^
 >Symbol.matchAll : unique symbol
@@ -26,8 +26,8 @@ const array = [...matches];
 >             : ^^^^^^^^^^^^^^^^^^
 >...matches : RegExpMatchArray
 >           : ^^^^^^^^^^^^^^^^
->matches : BuiltinIterator<RegExpMatchArray, any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>matches : RegExpStringIterator<RegExpMatchArray>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const { index, input } = array[0];
 >index : number
diff --git a/tests/baselines/reference/regexMatchAll.types b/tests/baselines/reference/regexMatchAll.types
index 3237c73dba1d3..9b937a0577e25 100644
--- a/tests/baselines/reference/regexMatchAll.types
+++ b/tests/baselines/reference/regexMatchAll.types
@@ -2,12 +2,12 @@
 
 === regexMatchAll.ts ===
 const matches = /\w/g[Symbol.matchAll]("matchAll");
->matches : BuiltinIterator<RegExpMatchArray, any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->/\w/g[Symbol.matchAll]("matchAll") : BuiltinIterator<RegExpMatchArray, any, any>
->                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->/\w/g[Symbol.matchAll] : (str: string) => BuiltinIterator<RegExpMatchArray, BuiltinIteratorReturn>
->                       : ^   ^^      ^^^^^                                                        
+>matches : RegExpStringIterator<RegExpMatchArray>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>/\w/g[Symbol.matchAll]("matchAll") : RegExpStringIterator<RegExpMatchArray>
+>                                   : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>/\w/g[Symbol.matchAll] : (str: string) => RegExpStringIterator<RegExpMatchArray>
+>                       : ^   ^^      ^^^^^                                      
 >/\w/g : RegExp
 >      : ^^^^^^
 >Symbol.matchAll : unique symbol
@@ -26,8 +26,8 @@ const array = [...matches];
 >             : ^^^^^^^^^^^^^^^^^^
 >...matches : RegExpMatchArray
 >           : ^^^^^^^^^^^^^^^^
->matches : BuiltinIterator<RegExpMatchArray, any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>matches : RegExpStringIterator<RegExpMatchArray>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const { index, input } = array[0];
 >index : number
diff --git a/tests/baselines/reference/stringMatchAll.types b/tests/baselines/reference/stringMatchAll.types
index 13e45697d8bcd..0de59f913a9a2 100644
--- a/tests/baselines/reference/stringMatchAll.types
+++ b/tests/baselines/reference/stringMatchAll.types
@@ -2,16 +2,16 @@
 
 === stringMatchAll.ts ===
 const matches = "matchAll".matchAll(/\w/g);
->matches : BuiltinIterator<RegExpExecArray, any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->"matchAll".matchAll(/\w/g) : BuiltinIterator<RegExpExecArray, any, any>
->                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->"matchAll".matchAll : (regexp: RegExp) => BuiltinIterator<RegExpExecArray, BuiltinIteratorReturn>
->                    : ^      ^^      ^^^^^                                                       
+>matches : RegExpStringIterator<RegExpExecArray>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>"matchAll".matchAll(/\w/g) : RegExpStringIterator<RegExpExecArray>
+>                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>"matchAll".matchAll : (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>
+>                    : ^      ^^      ^^^^^                                     
 >"matchAll" : "matchAll"
 >           : ^^^^^^^^^^
->matchAll : (regexp: RegExp) => BuiltinIterator<RegExpExecArray, BuiltinIteratorReturn>
->         : ^      ^^      ^^^^^                                                       
+>matchAll : (regexp: RegExp) => RegExpStringIterator<RegExpExecArray>
+>         : ^      ^^      ^^^^^                                     
 >/\w/g : RegExp
 >      : ^^^^^^
 
@@ -22,8 +22,8 @@ const array = [...matches];
 >             : ^^^^^^^^^^^^^^^^^
 >...matches : RegExpExecArray
 >           : ^^^^^^^^^^^^^^^
->matches : BuiltinIterator<RegExpExecArray, any, any>
->        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>matches : RegExpStringIterator<RegExpExecArray>
+>        : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 const { index, input } = array[0];
 >index : number
diff --git a/tests/baselines/reference/substitutionTypePassedToExtends.types b/tests/baselines/reference/substitutionTypePassedToExtends.types
index a5d81c4699c7a..102d4d17d567f 100644
--- a/tests/baselines/reference/substitutionTypePassedToExtends.types
+++ b/tests/baselines/reference/substitutionTypePassedToExtends.types
@@ -2,7 +2,7 @@
 
 === Performance Stats ===
 Type Count: 500 -> 1,000
-Instantiation count: 100 -> 1,000
+Instantiation count: 100 -> 2,500
 
 === substitutionTypePassedToExtends.ts ===
 type Foo1<A,B> = [A, B] extends unknown[][] ? Bar1<[A, B]> : 'else'
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.1.types b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
index 2d2f8df98e490..1cb91c6012c40 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.1.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.1.types
@@ -61,8 +61,8 @@ async function * inferReturnType5() {
 >  : ^
 }
 async function * inferReturnType6() {
->inferReturnType6 : () => AsyncGenerator<number, void, any>
->                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>inferReturnType6 : () => AsyncGenerator<number, void, unknown>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -74,8 +74,8 @@ async function * inferReturnType6() {
 >  : ^
 }
 async function * inferReturnType7() {
->inferReturnType7 : () => AsyncGenerator<number, void, any>
->                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>inferReturnType7 : () => AsyncGenerator<number, void, unknown>
+>                 : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -144,8 +144,8 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
 const assignability3: () => AsyncIterableIterator<number> = async function * () {
 >assignability3 : () => AsyncIterableIterator<number>
 >               : ^^^^^^                             
->async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, any>
->                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, unknown>
+>                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -160,8 +160,8 @@ const assignability3: () => AsyncIterableIterator<number> = async function * ()
 const assignability4: () => AsyncIterableIterator<number> = async function * () {
 >assignability4 : () => AsyncIterableIterator<number>
 >               : ^^^^^^                             
->async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, any>
->                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, unknown>
+>                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -234,8 +234,8 @@ const assignability7: () => AsyncIterable<number> = async function * () {
 const assignability8: () => AsyncIterable<number> = async function * () {
 >assignability8 : () => AsyncIterable<number>
 >               : ^^^^^^                     
->async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, any>
->                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, unknown>
+>                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -250,8 +250,8 @@ const assignability8: () => AsyncIterable<number> = async function * () {
 const assignability9: () => AsyncIterable<number> = async function * () {
 >assignability9 : () => AsyncIterable<number>
 >               : ^^^^^^                     
->async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, any>
->                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, unknown>
+>                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
@@ -324,8 +324,8 @@ const assignability12: () => AsyncIterator<number> = async function * () {
 const assignability13: () => AsyncIterator<number> = async function * () {
 >assignability13 : () => AsyncIterator<number>
 >                : ^^^^^^                     
->async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, any>
->                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* [1, 2];} : () => AsyncGenerator<number, void, unknown>
+>                                         : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [1, 2];
 >yield* [1, 2] : any
@@ -340,8 +340,8 @@ const assignability13: () => AsyncIterator<number> = async function * () {
 const assignability14: () => AsyncIterator<number> = async function * () {
 >assignability14 : () => AsyncIterator<number>
 >                : ^^^^^^                     
->async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, any>
->                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* [Promise.resolve(1)];} : () => AsyncGenerator<number, void, unknown>
+>                                                       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* [Promise.resolve(1)];
 >yield* [Promise.resolve(1)] : any
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
index 4aa4491e4234b..130ef20c6f136 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.errors.txt
@@ -8,8 +8,8 @@ types.asyncGenerators.es2018.2.ts(10,7): error TS2322: Type '() => AsyncGenerato
           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'.
-types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator<string, void, any>' is not assignable to type '() => AsyncIterableIterator<number>'.
-  Call signature return types 'AsyncGenerator<string, void, any>' and 'AsyncIterableIterator<number>' are incompatible.
+types.asyncGenerators.es2018.2.ts(13,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
+  Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterableIterator<number>' are incompatible.
     The types returned by 'next(...)' are incompatible between these types.
       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>'.
@@ -32,8 +32,8 @@ types.asyncGenerators.es2018.2.ts(19,7): error TS2322: Type '() => AsyncGenerato
           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'.
-types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncGenerator<string, void, any>' is not assignable to type '() => AsyncIterable<number>'.
-  Call signature return types 'AsyncGenerator<string, void, any>' and 'AsyncIterable<number>' are incompatible.
+types.asyncGenerators.es2018.2.ts(22,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
+  Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterable<number>' are incompatible.
     The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types.
       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>'.
@@ -56,8 +56,8 @@ types.asyncGenerators.es2018.2.ts(28,7): error TS2322: Type '() => AsyncGenerato
           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'.
-types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncGenerator<string, void, any>' is not assignable to type '() => AsyncIterator<number, any, any>'.
-  Call signature return types 'AsyncGenerator<string, void, any>' and 'AsyncIterator<number, any, any>' are incompatible.
+types.asyncGenerators.es2018.2.ts(31,7): error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, any>'.
+  Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterator<number, any, any>' are incompatible.
     The types returned by 'next(...)' are incompatible between these types.
       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>'.
@@ -118,8 +118,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[
     };
     const assignability2: () => AsyncIterableIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncGenerator<string, void, any>' is not assignable to type '() => AsyncIterableIterator<number>'.
-!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, any>' and 'AsyncIterableIterator<number>' are incompatible.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterableIterator<number>'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterableIterator<number>' are incompatible.
 !!! error TS2322:     The types returned by 'next(...)' are incompatible between these types.
 !!! 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>'.
@@ -154,8 +154,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[
     };
     const assignability5: () => AsyncIterable<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncGenerator<string, void, any>' is not assignable to type '() => AsyncIterable<number>'.
-!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, any>' and 'AsyncIterable<number>' are incompatible.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterable<number>'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterable<number>' are incompatible.
 !!! error TS2322:     The types returned by '[Symbol.asyncIterator]().next(...)' are incompatible between these types.
 !!! 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>'.
@@ -190,8 +190,8 @@ types.asyncGenerators.es2018.2.ts(74,12): error TS2504: Type '{}' must have a '[
     };
     const assignability8: () => AsyncIterator<number> = async function * () {
           ~~~~~~~~~~~~~~
-!!! error TS2322: Type '() => AsyncGenerator<string, void, any>' is not assignable to type '() => AsyncIterator<number, any, any>'.
-!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, any>' and 'AsyncIterator<number, any, any>' are incompatible.
+!!! error TS2322: Type '() => AsyncGenerator<string, void, unknown>' is not assignable to type '() => AsyncIterator<number, any, any>'.
+!!! error TS2322:   Call signature return types 'AsyncGenerator<string, void, unknown>' and 'AsyncIterator<number, any, any>' are incompatible.
 !!! error TS2322:     The types returned by 'next(...)' are incompatible between these types.
 !!! 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>'.
diff --git a/tests/baselines/reference/types.asyncGenerators.es2018.2.types b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
index 1f65af986e913..466a9ef6e7039 100644
--- a/tests/baselines/reference/types.asyncGenerators.es2018.2.types
+++ b/tests/baselines/reference/types.asyncGenerators.es2018.2.types
@@ -61,8 +61,8 @@ const assignability1: () => AsyncIterableIterator<number> = async function * ()
 const assignability2: () => AsyncIterableIterator<number> = async function * () {
 >assignability2 : () => AsyncIterableIterator<number>
 >               : ^^^^^^                             
->async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, any>
->                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, unknown>
+>                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
@@ -112,8 +112,8 @@ const assignability4: () => AsyncIterable<number> = async function * () {
 const assignability5: () => AsyncIterable<number> = async function * () {
 >assignability5 : () => AsyncIterable<number>
 >               : ^^^^^^                     
->async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, any>
->                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, unknown>
+>                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
@@ -163,8 +163,8 @@ const assignability7: () => AsyncIterator<number> = async function * () {
 const assignability8: () => AsyncIterator<number> = async function * () {
 >assignability8 : () => AsyncIterator<number>
 >               : ^^^^^^                     
->async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, any>
->                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>async function * () {    yield* ["a", "b"];} : () => AsyncGenerator<string, void, unknown>
+>                                             : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     yield* ["a", "b"];
 >yield* ["a", "b"] : any
diff --git a/tests/baselines/reference/yieldExpressionInnerCommentEmit.types b/tests/baselines/reference/yieldExpressionInnerCommentEmit.types
index bba612bd5c756..58f588f237f80 100644
--- a/tests/baselines/reference/yieldExpressionInnerCommentEmit.types
+++ b/tests/baselines/reference/yieldExpressionInnerCommentEmit.types
@@ -2,8 +2,8 @@
 
 === yieldExpressionInnerCommentEmit.ts ===
 function * foo2() {
->foo2 : () => Generator<number, void, any>
->     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>foo2 : () => Generator<number, void, unknown>
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
     /*comment1*/ yield 1;
 >yield 1 : any
diff --git a/tests/cases/compiler/builtinIterator.ts b/tests/cases/compiler/builtinIterator.ts
index 3b20d9fe53dda..e80bda3e44ab1 100644
--- a/tests/cases/compiler/builtinIterator.ts
+++ b/tests/cases/compiler/builtinIterator.ts
@@ -72,5 +72,5 @@ class BadIterator3 extends Iterator<number> {
 declare const g1: Generator<string, number, boolean>;
 const iter1 = Iterator.from(g1);
 
-declare const iter2: BuiltinIterator<string, BuiltinIteratorReturn>;
+declare const iter2: IteratorObject<string>;
 const iter3 = iter2.flatMap(() => g1);
\ No newline at end of file
diff --git a/tests/cases/compiler/iterableTReturnTNext.ts b/tests/cases/compiler/iterableTReturnTNext.ts
index f51ecdbf019e4..f17276e4c6797 100644
--- a/tests/cases/compiler/iterableTReturnTNext.ts
+++ b/tests/cases/compiler/iterableTReturnTNext.ts
@@ -38,9 +38,9 @@ class MyMap implements Map<string, number> {
     get(key: string): number | undefined { return undefined; }
     has(key: string): boolean { return false; }
     set(key: string, value: number): this { return this; }
-    entries(): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
-    [Symbol.iterator](): BuiltinIterator<[string, number], BuiltinIteratorReturn> { throw new Error("Method not implemented."); }
+    entries(): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
+    keys(): MapIterator<string> { throw new Error("Method not implemented."); }
+    [Symbol.iterator](): MapIterator<[string, number]> { throw new Error("Method not implemented."); }
 
     // error when strictBuiltinIteratorReturn is true because values() has implicit `void` return, which isn't assignable to `undefined`
     * values() {
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of14.ts b/tests/cases/conformance/es6/for-ofStatements/for-of14.ts
index f79794d59d507..a20b564163c4b 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of14.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of14.ts
@@ -1,9 +1,9 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next() {
         return "";
     }
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should fail because the iterator is not iterable
\ No newline at end of file
+for (v of new MyStringIterator) { } // Should fail because the iterator is not iterable
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of15.ts b/tests/cases/conformance/es6/for-ofStatements/for-of15.ts
index b2e788bdef247..7c30b32593b72 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of15.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of15.ts
@@ -1,5 +1,5 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next() {
         return "";
     }
@@ -9,4 +9,4 @@ class StringIterator {
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should fail
\ No newline at end of file
+for (v of new MyStringIterator) { } // Should fail
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of16.ts b/tests/cases/conformance/es6/for-ofStatements/for-of16.ts
index b63e061425ee9..a5918dd94062b 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of16.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of16.ts
@@ -1,11 +1,11 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return this;
     }
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should fail
+for (v of new MyStringIterator) { } // Should fail
 
-for (v of new StringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
\ No newline at end of file
+for (v of new MyStringIterator) { } // Should still fail (related errors should still be shown even though type is cached).
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of18.ts b/tests/cases/conformance/es6/for-ofStatements/for-of18.ts
index 647ae314b4d86..88f18cc88c3b6 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of18.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of18.ts
@@ -1,5 +1,5 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             value: "",
@@ -12,4 +12,4 @@ class StringIterator {
 }
 
 var v: string;
-for (v of new StringIterator) { } // Should succeed
\ No newline at end of file
+for (v of new MyStringIterator) { } // Should succeed
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of25.ts b/tests/cases/conformance/es6/for-ofStatements/for-of25.ts
index 61e6a58ce30fd..f63137c6cfc4e 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of25.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of25.ts
@@ -1,9 +1,9 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return x;
     }
 }
 
 var x: any;
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of26.ts b/tests/cases/conformance/es6/for-ofStatements/for-of26.ts
index 4414fdc1592a3..8dd94be99018f 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of26.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of26.ts
@@ -1,5 +1,5 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next() {
         return x;
     }
@@ -9,4 +9,4 @@ class StringIterator {
 }
 
 var x: any;
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of27.ts b/tests/cases/conformance/es6/for-ofStatements/for-of27.ts
index f7244eed34c22..a87960cd4411d 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of27.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of27.ts
@@ -1,6 +1,6 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]: any;
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of28.ts b/tests/cases/conformance/es6/for-ofStatements/for-of28.ts
index e1b86f6135f05..bb241e389ac24 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of28.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of28.ts
@@ -1,9 +1,9 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next: any;
     [Symbol.iterator]() {
         return this;
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of30.ts b/tests/cases/conformance/es6/for-ofStatements/for-of30.ts
index 3d8ac3a93af51..019f71a0f4cd1 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of30.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of30.ts
@@ -1,5 +1,5 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: false,
@@ -14,4 +14,4 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of31.ts b/tests/cases/conformance/es6/for-ofStatements/for-of31.ts
index 1e8d7e106301b..847d7d0dd7cb1 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of31.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of31.ts
@@ -1,5 +1,5 @@
 //@target: ES6
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             // no done property
@@ -12,4 +12,4 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of33.ts b/tests/cases/conformance/es6/for-ofStatements/for-of33.ts
index f0af5c4a40820..f952c23e09cd5 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of33.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of33.ts
@@ -1,9 +1,9 @@
 //@target: ES6
 //@noImplicitAny: true
-class StringIterator {
+class MyStringIterator {
     [Symbol.iterator]() {
         return v;
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of34.ts b/tests/cases/conformance/es6/for-ofStatements/for-of34.ts
index b38a6a68bf663..d7cecf6a40f7e 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of34.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of34.ts
@@ -1,6 +1,6 @@
 //@target: ES6
 //@noImplicitAny: true
-class StringIterator {
+class MyStringIterator {
     next() {
         return v;
     }
@@ -10,4 +10,4 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/for-ofStatements/for-of35.ts b/tests/cases/conformance/es6/for-ofStatements/for-of35.ts
index 041f611699e2f..148260323f614 100644
--- a/tests/cases/conformance/es6/for-ofStatements/for-of35.ts
+++ b/tests/cases/conformance/es6/for-ofStatements/for-of35.ts
@@ -1,6 +1,6 @@
 //@target: ES6
 //@noImplicitAny: true
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: true,
@@ -13,4 +13,4 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file
diff --git a/tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts b/tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts
index b832d57855ed2..f5f96e5c44a29 100644
--- a/tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts
+++ b/tests/cases/conformance/statements/for-ofStatements/ES5For-ofTypeCheck10.ts
@@ -1,7 +1,7 @@
 //@target: ES5
 
 // In ES3/5, you cannot for...of over an arbitrary iterable.
-class StringIterator {
+class MyStringIterator {
     next() {
         return {
             done: true,
@@ -13,4 +13,4 @@ class StringIterator {
     }
 }
 
-for (var v of new StringIterator) { }
\ No newline at end of file
+for (var v of new MyStringIterator) { }
\ No newline at end of file