From 24fa19d3dae3c75d02f89a176874fec8de1c4459 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Tue, 1 Oct 2019 16:53:14 -0700
Subject: [PATCH 01/10] Add full implemention of Map and Set to shims

---
 src/compiler/core.ts                          |  32 +-
 src/compiler/corePublic.ts                    | 182 +++++--
 src/compiler/utilities.ts                     |   2 +-
 src/shims/collectionShims.ts                  | 490 ++++++++++++++++++
 src/shims/mapShim.ts                          | 220 --------
 src/shims/tsconfig.json                       |   2 +-
 src/testRunner/unittests/createMapShim.ts     | 127 +++--
 .../reference/api/tsserverlibrary.d.ts        |  50 +-
 tests/baselines/reference/api/typescript.d.ts |  50 +-
 9 files changed, 839 insertions(+), 316 deletions(-)
 create mode 100644 src/shims/collectionShims.ts
 delete mode 100644 src/shims/mapShim.ts

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 4be5998d6f3f9..092d95df86276 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -5,13 +5,17 @@ namespace ts {
     export const emptyArray: never[] = [] as never[];
 
     /** Create a new map. */
-    export function createMap<T>(): Map<T> {
-        return new Map<T>();
+    export function createMap<T>(): Map<T>;
+    export function createMap<K, V>(): ESMap<K, V>;
+    export function createMap<K, V>(): ESMap<K, V> {
+        return new Map<K, V>();
     }
 
     /** Create a new map from an array of entries. */
-    export function createMapFromEntries<T>(entries: [string, T][]): Map<T> {
-        const map = createMap<T>();
+    export function createMapFromEntries<T>(entries: readonly [string, T][]): Map<T>;
+    export function createMapFromEntries<K, V>(entries: readonly [K, V][]): ESMap<K, V>;
+    export function createMapFromEntries<K, V>(entries: readonly [K, V][]): ESMap<K, V> {
+        const map = createMap<K, V>();
         for (const [key, value] of entries) {
             map.set(key, value);
         }
@@ -20,7 +24,7 @@ namespace ts {
 
     /** Create a new map from a template object is provided, the map will copy entries from it. */
     export function createMapFromTemplate<T>(template: MapLike<T>): Map<T> {
-        const map: Map<T> = new Map<T>();
+        const map: Map<T> = new Map<string, T>();
 
         // Copies keys/values from template. Note that for..in will not throw if
         // template is undefined, and instead will just exit the loop.
@@ -33,6 +37,18 @@ namespace ts {
         return map;
     }
 
+    export function createSet<T>(): Set<T> {
+        return new Set<T>();
+    }
+
+    export function createSetFromValues<T>(values: readonly T[]): Set<T> {
+        const set = createSet<T>();
+        for (const value of values) {
+            set.add(value);
+        }
+        return set;
+    }
+
     export function length(array: readonly any[] | undefined): number {
         return array ? array.length : 0;
     }
@@ -1587,7 +1603,7 @@ namespace ts {
      * Case-sensitive comparisons compare both strings one code-point at a time using the integer
      * value of each code-point after applying `toUpperCase` to each string. We always map both
      * strings to their upper-case form as some unicode characters do not properly round-trip to
-     * lowercase (such as `ẞ` (German sharp capital s)).
+     * lowercase (such as `ẞ` (German sharp capital s)).
      */
     export function equateStringsCaseInsensitive(a: string, b: string) {
         return a === b
@@ -1645,7 +1661,7 @@ namespace ts {
      * Case-insensitive comparisons compare both strings one code-point at a time using the integer
      * value of each code-point after applying `toUpperCase` to each string. We always map both
      * strings to their upper-case form as some unicode characters do not properly round-trip to
-     * lowercase (such as `ẞ` (German sharp capital s)).
+     * lowercase (such as `ẞ` (German sharp capital s)).
      */
     export function compareStringsCaseInsensitive(a: string, b: string) {
         if (a === b) return Comparison.EqualTo;
@@ -1717,7 +1733,7 @@ namespace ts {
             //
             // For case insensitive comparisons we always map both strings to their
             // upper-case form as some unicode characters do not properly round-trip to
-            // lowercase (such as `ẞ` (German sharp capital s)).
+            // lowercase (such as `ẞ` (German sharp capital s)).
             return (a, b) => compareWithCallback(a, b, compareDictionaryOrder);
 
             function compareDictionaryOrder(a: string, b: string) {
diff --git a/src/compiler/corePublic.ts b/src/compiler/corePublic.ts
index f77b4bda4c260..3d0b77fe2dc30 100644
--- a/src/compiler/corePublic.ts
+++ b/src/compiler/corePublic.ts
@@ -23,53 +23,82 @@ namespace ts {
     }
 
     /** ES6 Map interface, only read methods included. */
-    export interface ReadonlyMap<T> {
-        get(key: string): T | undefined;
-        has(key: string): boolean;
-        forEach(action: (value: T, key: string) => void): void;
+    export interface ReadonlyESMap<K, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        forEach(action: (value: V, key: K) => void): void;
         readonly size: number;
-        keys(): Iterator<string>;
-        values(): Iterator<T>;
-        entries(): Iterator<[string, T]>;
+        keys(): Iterator<K>;
+        values(): Iterator<V>;
+        entries(): Iterator<[K, V]>;
     }
 
     /** ES6 Map interface. */
-    export interface Map<T> extends ReadonlyMap<T> {
-        set(key: string, value: T): this;
-        delete(key: string): boolean;
+    export interface ESMap<K, V> extends ReadonlyESMap<K, V> {
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
         clear(): void;
     }
 
+    /** ES6 Map interface, only read methods included. */
+    export interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
+    }
+
+    /** ES6 Map interface. */
+    export interface Map<T> extends ESMap<string, T>, ReadonlyMap<T> {
+    }
+
     /* @internal */
     export interface MapConstructor {
         // eslint-disable-next-line @typescript-eslint/prefer-function-type
-        new <T>(): Map<T>;
+        new <K, V>(): ESMap<K, V>;
+    }
+
+    export interface ReadonlySet<T> {
+        readonly size: number;
+        has(value: T): boolean;
+        forEach(action: (value: T, key: T) => void): void;
+        keys(): Iterator<T>;
+        values(): Iterator<T>;
+        entries(): Iterator<[T, T]>;
+    }
+
+    export interface Set<T> extends ReadonlySet<T> {
+        add(value: T): this;
+        delete(value: T): boolean;
+        clear(): void;
     }
 
-    /**
-     * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
-     */
     /* @internal */
-    export function tryGetNativeMap(): MapConstructor | undefined {
-        // Internet Explorer's Map doesn't support iteration, so don't use it.
-        // Natives
-        // NOTE: TS doesn't strictly allow in-line declares, but if we suppress the error, the declaration
-        // is still used for typechecking _and_ correctly elided, which is out goal, as this prevents us from
-        // needing to pollute an outer scope with a declaration of `Map` just to satisfy the checks in this function
-        //@ts-ignore
-        declare const Map: (new <T>() => Map<T>) | undefined;
-        // eslint-disable-next-line no-in-operator
-        return typeof Map !== "undefined" && "entries" in Map.prototype ? Map : undefined;
+    export interface SetConstructor {
+        // eslint-disable-next-line @typescript-eslint/prefer-function-type
+        new <T>(): Set<T>;
+    }
+
+    export interface WeakMap<K extends object, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
     }
 
     /* @internal */
-    export const Map: MapConstructor = tryGetNativeMap() || (() => {
-        // NOTE: createMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createMapShim === "function") {
-            return createMapShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
-    })();
+    export interface WeakMapConstructor {
+        // eslint-disable-next-line @typescript-eslint/prefer-function-type
+        new <K extends object, V>(): WeakMap<K, V>;
+    }
+
+    export interface WeakSet<T extends object> {
+        has(key: T): boolean;
+        add(key: T): this;
+        delete(key: T): boolean;
+    }
+
+    /* @internal */
+    export interface WeakSetConstructor {
+        // eslint-disable-next-line @typescript-eslint/prefer-function-type
+        new <T extends object>(): WeakSet<T>;
+    }
 
     /** ES6 Iterator type. */
     export interface Iterator<T> {
@@ -94,4 +123,95 @@ namespace ts {
         EqualTo     = 0,
         GreaterThan = 1
     }
+
+    namespace NativeCollections {
+        declare const Map: MapConstructor | undefined;
+        declare const Set: SetConstructor | undefined;
+        declare const WeakMap: WeakMapConstructor | undefined;
+        declare const WeakSet: WeakSetConstructor | undefined;
+
+        export function tryGetNativeMap(): MapConstructor | undefined {
+            // Internet Explorer's Map doesn't support iteration, so don't use it.
+            // eslint-disable-next-line no-in-operator
+            return typeof Map !== "undefined" && "entries" in Map.prototype ? Map : undefined;
+        }
+
+        export function tryGetNativeSet(): SetConstructor | undefined {
+            // Internet Explorer's Set doesn't support iteration, so don't use it.
+            // eslint-disable-next-line no-in-operator
+            return typeof Set !== "undefined" && "entries" in Set.prototype ? Set : undefined;
+        }
+
+        export function tryGetNativeWeakMap(): WeakMapConstructor | undefined {
+            return typeof WeakMap !== "undefined" ? WeakMap : undefined;
+        }
+
+        export function tryGetNativeWeakSet(): WeakSetConstructor | undefined {
+            return typeof WeakSet !== "undefined" ? WeakSet : undefined;
+        }
+    }
+
+    /**
+     * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
+     */
+    /* @internal */
+    export function tryGetNativeMap() {
+        return NativeCollections.tryGetNativeMap();
+    }
+
+    /**
+     * Returns the native Set implementation if it is available and compatible (i.e. supports iteration).
+     */
+    /* @internal */
+    export function tryGetNativeSet() {
+        return NativeCollections.tryGetNativeSet();
+    }
+
+    /**
+     * Returns the native WeakMap implementation if it is available.
+     */
+    /* @internal */
+    export function tryGetNativeWeakMap() {
+        return NativeCollections.tryGetNativeWeakMap();
+    }
+
+    /**
+     * Returns the native WeakSet implementation if it is available.
+     */
+    /* @internal */
+    export function tryGetNativeWeakSet() {
+        return NativeCollections.tryGetNativeWeakSet();
+    }
+
+    export const Map: MapConstructor = tryGetNativeMap() || (() => {
+        // NOTE: ts.createMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createMapShim === "function") {
+            return createMapShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
+    })();
+
+    export const Set: SetConstructor = tryGetNativeSet() || (() => {
+        // NOTE: ts.createSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createSetShim === "function") {
+            return createSetShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native Set implementation.");
+    })();
+
+    export const WeakMap: WeakMapConstructor = tryGetNativeWeakMap() || (() => {
+        // NOTE: ts.createWeakMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createWeakMapShim === "function") {
+            return createWeakMapShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native WeakMap implementation.");
+    })();
+
+    export const WeakSet: WeakSetConstructor = tryGetNativeWeakSet() || (() => {
+        // NOTE: ts.createWeakSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createWeakSetShim === "function") {
+            return createWeakSetShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native WeakSet implementation.");
+    })();
 }
\ No newline at end of file
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index b147e79348733..6ce2655a4ad8f 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -24,7 +24,7 @@ namespace ts {
 
     /** Create a new escaped identifier map. */
     export function createUnderscoreEscapedMap<T>(): UnderscoreEscapedMap<T> {
-        return new Map<T>() as UnderscoreEscapedMap<T>;
+        return new Map<string, T>() as UnderscoreEscapedMap<T>;
     }
 
     export function hasEntries(map: ReadonlyUnderscoreEscapedMap<any> | undefined): map is ReadonlyUnderscoreEscapedMap<any> {
diff --git a/src/shims/collectionShims.ts b/src/shims/collectionShims.ts
new file mode 100644
index 0000000000000..e54c6fa470494
--- /dev/null
+++ b/src/shims/collectionShims.ts
@@ -0,0 +1,490 @@
+/* @internal */
+namespace ts {
+    interface IteratorShim<T> {
+        next(): { value: T, done?: false } | { value: never, done: true };
+    }
+
+    interface MapShim<K, V> {
+        readonly size: number;
+        get(key: K): V | undefined;
+        set(key: K, value: V): this;
+        has(key: K): boolean;
+        delete(key: K): boolean;
+        clear(): void;
+        keys(): IteratorShim<K>;
+        values(): IteratorShim<V>;
+        entries(): IteratorShim<[K, V]>;
+        forEach(action: (value: V, key: K) => void): void;
+    }
+
+    interface SetShim<T> {
+        readonly size: number;
+        add(value: T): this;
+        delete(value: T): boolean;
+        has(value: T): boolean;
+        clear(): void;
+        keys(): IteratorShim<T>;
+        values(): IteratorShim<T>;
+        entries(): IteratorShim<[T, T]>;
+        forEach(action: (value: T, key: T) => void): void;
+    }
+
+    interface WeakMapShim<K extends object, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
+    }
+
+    interface WeakSetShim<T extends object> {
+        has(key: T): boolean;
+        add(key: T): this;
+        delete(key: T): boolean;
+    }
+
+    interface WeakMapData<K, V> {
+        objects?: ObjectMapEntry<K, V>;
+    }
+
+    interface MapData<K, V> {
+        size: number;
+        strings?: Record<string, MapEntry<K, V>>;
+        numbers?: MapEntry<K, V>[];
+        objects?: ObjectMapEntry<K, V>;
+        true?: MapEntry<K, V>;
+        false?: MapEntry<K, V>;
+        null?: MapEntry<K, V>;
+        undefined?: MapEntry<K, V>;
+
+        // Linked list references for iterators.
+        // See https://github.com/Microsoft/TypeScript/pull/27292
+        // for more information.
+
+        /**
+         * The first entry in the linked list.
+         * Note that this is only a stub that serves as starting point
+         * for iterators and doesn't contain a key and a value.
+         */
+        readonly first: MapEntry<K, V>;
+        last: MapEntry<K, V>;
+    }
+
+    interface MapEntry<K, V> {
+        readonly key?: K;
+        value?: V;
+
+        // Linked list references for iterators.
+        nextIterationEntry?: MapEntry<K, V>;
+        previousIterationEntry?: MapEntry<K, V>;
+
+        /**
+         * Specifies if iterators should skip the next entry.
+         * This will be set when an entry is deleted.
+         * See https://github.com/Microsoft/TypeScript/pull/27292 for more information.
+         */
+        skipNextIteration?: boolean;
+    }
+
+    interface ObjectMapEntry<K, V> extends MapEntry<K, V> {
+        // Linked list references for object-based keys
+        next?: ObjectMapEntry<K, V>;
+    }
+
+    function isObject(value: unknown): value is object {
+        // eslint-disable-next-line no-null/no-null
+        return typeof value === "object" && value !== null
+            || typeof value === "function";
+    }
+
+    function createDictionaryObject<T>(): Record<string, T> {
+        const map = Object.create(/*prototype*/ null); // eslint-disable-line no-null/no-null
+
+        // Using 'delete' on an object causes V8 to put the object in dictionary mode.
+        // This disables creation of hidden classes, which are expensive when an object is
+        // constantly changing shape.
+        map.__ = undefined;
+        delete map.__;
+        return map;
+    }
+
+    function tryAddIterator<T>(value: T, iterator: (this: T) => IteratorShim<any>) {
+        if (typeof Symbol === "function" && Symbol.iterator !== undefined) {
+            (value as any)[Symbol.iterator] = iterator;
+        }
+    }
+
+    function createIterator(name: string) {
+        class Iterator<K, V, U extends (K | V | [K, V])> {
+            private currentEntry?: MapEntry<K, V>;
+            private selector: (key: K, value: V) => U;
+
+            constructor(data: MapData<K, V>, selector: (key: K, value: V) => U) {
+                this.currentEntry = data.first;
+                this.selector = selector;
+            }
+
+            public next(): { value: U, done?: false } | { value: never, done: true } {
+                // Navigate to the next entry.
+                while (this.currentEntry) {
+                    const skipNext = !!this.currentEntry.skipNextIteration;
+                    this.currentEntry = this.currentEntry.nextIterationEntry;
+                    if (!skipNext) {
+                        break;
+                    }
+                }
+
+                if (this.currentEntry) {
+                    return { value: this.selector(this.currentEntry.key!, this.currentEntry.value!), done: false };
+                }
+                else {
+                    return { value: undefined as never, done: true };
+                }
+            }
+        }
+        tryAddIterator(Iterator.prototype, function() { return this; })
+        Object.defineProperty(Iterator, "name", {
+            ...Object.getOwnPropertyDescriptor(Iterator, "name"),
+            configurable: true,
+            value: name
+        });
+        return Iterator;
+    }
+
+    function hasEntry<K, V>(data: MapData<K, V>, key: K): boolean {
+        /* eslint-disable no-in-operator, no-null/no-null */
+        return typeof key === "string" ? !!data.strings && key in data.strings :
+            typeof key === "number" ? !!data.numbers && key in data.numbers :
+            typeof key === "boolean" ? key ? !!data.true : !!data.false :
+            key === null ? !!data.null :
+            key === undefined ? !!data.undefined :
+            !!getObjectEntry(data, key);
+        // eslint-enable no-in-operator, no-null/no-null
+    }
+
+    function getEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        /* eslint-disable no-null/no-null */
+        return typeof key === "string" ? data.strings && data.strings[key] :
+            typeof key === "number" ? data.numbers && data.numbers[key] :
+            typeof key === "boolean" ? key ? data.true : data.false :
+            key === undefined ? data.undefined :
+            key === null ? data.null :
+            getObjectEntry(data, key);
+        /* eslint-enable no-null/no-null */
+    }
+
+    function getObjectEntry<K, V>(data: WeakMapData<K, V>, key: K): ObjectMapEntry<K, V> | undefined {
+        for (let node = data.objects; node; node = node.next) {
+            if (node.key === key) {
+                return node;
+            }
+        }
+    }
+
+    function addOrUpdateEntry<K, V>(data: MapData<K, V>, key: K, value: V): MapEntry<K, V> | undefined {
+        let entry: MapEntry<K, V> | undefined;
+        if (typeof key === "string") {
+            if (!data.strings) data.strings = createDictionaryObject();
+            if (!data.strings[key]) {
+                entry = data.strings[key] = { key, value };
+            }
+            else {
+                data.strings[key].value = value;
+            }
+        }
+        else if (typeof key === "number") {
+            if (!data.numbers) data.numbers = [];
+            if (!data.numbers[key]) {
+                entry = data.numbers[key] = { key, value };
+            }
+            else {
+                data.numbers[key].value = value;
+            }
+        }
+        else {
+            /* eslint-disable no-null/no-null */
+            const prop = typeof key === "boolean" ? key ? "true" : "false" :
+                key === null ? "null" :
+                key === undefined ? "undefined" :
+                undefined;
+            /* eslint-enable no-null/no-null */
+            if (prop) {
+                if (!data[prop]) {
+                    entry = data[prop] = { key, value };
+                }
+                else {
+                    data[prop]!.value = value;
+                }
+            }
+            else {
+                entry = addOrUpdateObjectEntry(data, key, value);
+            }
+        }
+        if (entry) {
+            addToIteration(data, entry);
+            data.size++;
+        }
+        return entry;
+    }
+
+    function addOrUpdateObjectEntry<K, V>(data: WeakMapData<K, V>, key: K, value: V): ObjectMapEntry<K, V> | undefined {
+        if (!data.objects) return data.objects = { key, value, next: undefined };
+        const existing = getObjectEntry(data, key);
+        if (!existing) return data.objects = { key, value, next: data.objects };
+        existing.value = value;
+    }
+
+    function deleteEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        let entry: MapEntry<K, V> | undefined;
+        if (typeof key === "string") {
+            if (data.strings) {
+                entry = data.strings[key];
+                if (entry) {
+                    delete data.strings[key];
+                }
+            }
+        }
+        else if (typeof key === "number") {
+            if (data.numbers) {
+                entry = data.numbers[key];
+                if (entry) {
+                    delete data.numbers[key];
+                }
+            }
+        }
+        else {
+            /* eslint-disable no-null/no-null */
+            const prop = typeof key === "boolean" ? key ? "true" : "false" :
+                key === null ? "null" :
+                key === undefined ? "undefined" :
+                undefined;
+            /* eslint-enable no-null/no-null */
+            if (prop) {
+                entry = data[prop];
+                if (entry) {
+                    data[prop] = undefined;
+                }
+            }
+            else {
+                entry = deleteObjectEntry(data, key);
+            }
+        }
+        if (entry) {
+            removeFromIteration(data, entry);
+            data.size--;
+        }
+        return entry;
+    }
+
+    function deleteObjectEntry<K, V>(data: WeakMapData<K, V>, key: K): ObjectMapEntry<K, V> | undefined {
+        let prev: ObjectMapEntry<K, V> | undefined;
+        for (let node = data.objects; node; prev = node, node = node.next) {
+            if (node.key === key) {
+                if (prev) {
+                    prev.next = node.next;
+                }
+                else {
+                    data.objects = node.next;
+                }
+                node.next = undefined;
+                return node;
+            }
+        }
+    }
+
+    function clearEntries<K, V>(data: MapData<K, V>) {
+        if (data.strings) data.strings = undefined;
+        if (data.numbers) data.numbers = undefined;
+        if (data.true) data.true = undefined;
+        if (data.false) data.false = undefined;
+        if (data.null) data.null = undefined;
+        if (data.undefined) data.undefined = undefined;
+        clearObjectEntries(data);
+        removeAllFromIteration(data);
+        data.size = 0;
+    }
+
+    function clearObjectEntries<K, V>(data: WeakMapData<K, V>) {
+        if (data.objects) {
+            let node = data.objects;
+            data.objects = undefined;
+            while (node) {
+                const next = node.next!;
+                node.next = undefined;
+                node = next;
+            }
+        }
+    }
+
+    function addToIteration<K, V>(data: MapData<K, V>, newEntry: MapEntry<K, V>) {
+        // Adjust the references.
+        const previousLastEntry = data.last;
+        previousLastEntry.nextIterationEntry = newEntry;
+        newEntry.previousIterationEntry = previousLastEntry;
+        data.last = newEntry;
+    }
+
+    function removeFromIteration<K, V>(data: MapData<K, V>, entry: MapEntry<K, V>) {
+        // Adjust the linked list references of the neighbor entries.
+        const previousEntry = entry.previousIterationEntry!;
+        previousEntry.nextIterationEntry = entry.nextIterationEntry;
+        if (entry.nextIterationEntry) {
+            entry.nextIterationEntry.previousIterationEntry = previousEntry;
+        }
+
+        // When the deleted entry was the last one, we need to
+        // adjust the lastEntry reference.
+        if (data.last === entry) {
+            data.last = previousEntry;
+        }
+
+        // Adjust the forward reference of the deleted entry
+        // in case an iterator still references it. This allows us
+        // to throw away the entry, but when an active iterator
+        // (which points to the current entry) continues, it will
+        // navigate to the entry that originally came before the
+        // current one and skip it.
+        entry.previousIterationEntry = undefined;
+        entry.nextIterationEntry = previousEntry;
+        entry.skipNextIteration = true;
+    }
+
+    function removeAllFromIteration<K, V>(data: MapData<K, V>) {
+        // Reset the linked list. Note that we must adjust the forward
+        // references of the deleted entries to ensure iterators stuck
+        // in the middle of the list don't continue with deleted entries,
+        // but can continue with new entries added after the clear()
+        // operation.
+        const firstEntry = data.first;
+        let currentEntry = firstEntry.nextIterationEntry;
+        while (currentEntry) {
+            const nextEntry = currentEntry.nextIterationEntry;
+            currentEntry.previousIterationEntry = undefined;
+            currentEntry.nextIterationEntry = firstEntry;
+            currentEntry.skipNextIteration = true;
+            currentEntry = nextEntry;
+        }
+
+        firstEntry.nextIterationEntry = undefined;
+        data.last = firstEntry;
+    }
+
+    function forEachEntry<K, V>(data: MapData<K, V>, action: (value: V, key: K) => void) {
+        let currentEntry: MapEntry<K, V> | undefined = data.first;
+        while (currentEntry) {
+            const skipNext = !!currentEntry.skipNextIteration;
+            currentEntry = currentEntry.nextIterationEntry;
+            if (skipNext) {
+                continue;
+            }
+            if (currentEntry) {
+                action(currentEntry.value!, currentEntry.key!);
+            }
+        }
+    }
+
+    function createMapData<K, V>(): MapData<K, V> {
+        const entry: MapEntry<K, V> = {};
+        return {
+            first: entry,
+            last: entry,
+            size: 0
+        };
+    }
+
+    function createWeakMapData<K, V>(): WeakMapData<K, V> {
+        return {};
+    }
+
+    function pickKey<K, V>(key: K, _value: V) { return key; }
+    function pickValue<K, V>(_key: K, value: V) { return value; }
+    function pickEntry<K, V>(key: K, value: V) { return [key, value] as [K, V]; }
+
+    /* @internal */
+    export function createMapShim(): new <K, V>() => MapShim<K, V> {
+        const MapIterator = createIterator("MapIterator");
+        class Map<K, V> implements MapShim<K, V> {
+            private _mapData = createMapData<K, V>();
+            get size() { return this._mapData.size; }
+            get(key: K): V | undefined { return getEntry(this._mapData, key)?.value; }
+            set(key: K, value: V): this { return addOrUpdateEntry(this._mapData, key, value), this; }
+            has(key: K): boolean { return hasEntry(this._mapData, key); }
+            delete(key: K): boolean { return !!deleteEntry(this._mapData, key); }
+            clear(): void { clearEntries(this._mapData); }
+            keys(): IteratorShim<K> { return new MapIterator(this._mapData, pickKey); }
+            values(): IteratorShim<V> { return new MapIterator(this._mapData, pickValue); }
+            entries(): IteratorShim<[K, V]> { return new MapIterator(this._mapData, pickEntry); }
+            forEach(action: (value: V, key: K) => void): void { forEachEntry(this._mapData, action); }
+        }
+        tryAddIterator(Map.prototype, Map.prototype.entries);
+        return Map;
+    }
+
+    /* @internal */
+    export function createSetShim(): new <T>() => SetShim<T> {
+        const SetIterator = createIterator("SetIterator");
+        class Set<T> implements SetShim<T> {
+            private _mapData = createMapData<T, T>();
+            get size() { return this._mapData.size; }
+            add(value: T): this { return addOrUpdateEntry(this._mapData, value, value), this; }
+            has(value: T): boolean { return hasEntry(this._mapData, value); }
+            delete(value: T): boolean { return !!deleteEntry(this._mapData, value); }
+            clear(): void { clearEntries(this._mapData); }
+            keys(): IteratorShim<T> { return new SetIterator(this._mapData, pickKey); }
+            values(): IteratorShim<T> { return new SetIterator(this._mapData, pickValue); }
+            entries(): IteratorShim<[T, T]> { return new SetIterator(this._mapData, pickEntry); }
+            forEach(action: (value: T, key: T) => void): void { forEachEntry(this._mapData, action); }
+        }
+        tryAddIterator(Set.prototype, Set.prototype.values);
+        return Set;
+    }
+
+    // NOTE: Not a real WeakMap, this implementation will hold onto references until it is GC'ed. However, it's the best
+    // we can do without storing data on each value itself.
+    /* @internal */
+    export function createWeakMapShim(): new <K extends object, V>() => WeakMapShim<K, V> {
+        class WeakMap<K extends object, V> implements WeakMapShim<K, V> {
+            private _mapData = createWeakMapData<K, V>();
+            get(key: K): V | undefined {
+                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
+                return getObjectEntry(this._mapData, key)?.value;
+            }
+            set(key: K, value: V): this {
+                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
+                addOrUpdateObjectEntry(this._mapData, key, value);
+                return this;
+            }
+            has(key: K): boolean {
+                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
+                return !!getObjectEntry(this._mapData, key);
+            }
+            delete(key: K): boolean {
+                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
+                return !!deleteObjectEntry(this._mapData, key);
+            }
+        }
+        return WeakMap;
+    }
+
+    // NOTE: Not a real WeakSet, this implementation will hold onto references until it is GC'ed. However, it's the best
+    // we can do without storing data on each value itself.
+    /* @internal */
+    export function createWeakSetShim(): new <T extends object>() => WeakSetShim<T> {
+        class WeakSet<T extends object> implements WeakSetShim<T> {
+            private _mapData = createWeakMapData<T, T>();
+            add(value: T): this {
+                if (!isObject(value)) throw new TypeError("Invalid value used in weak set");
+                addOrUpdateObjectEntry(this._mapData, value, value);
+                return this;
+            }
+            has(value: T): boolean {
+                if (!isObject(value)) throw new TypeError("Invalid value used in weak set");
+                return !!getObjectEntry(this._mapData, value);
+            }
+            delete(value: T): boolean {
+                if (!isObject(value)) throw new TypeError("Invalid value used in weak set");
+                return !!deleteObjectEntry(this._mapData, value);
+            }
+        }
+        return WeakSet;
+    }
+}
diff --git a/src/shims/mapShim.ts b/src/shims/mapShim.ts
deleted file mode 100644
index 23391150941b7..0000000000000
--- a/src/shims/mapShim.ts
+++ /dev/null
@@ -1,220 +0,0 @@
-/* @internal */
-namespace ts {
-    interface IteratorShim<T> {
-        next(): { value: T, done?: false } | { value: never, done: true };
-    }
-    interface MapShim<T> {
-        readonly size: number;
-        get(key: string): T | undefined;
-        set(key: string, value: T): this;
-        has(key: string): boolean;
-        delete(key: string): boolean;
-        clear(): void;
-        keys(): IteratorShim<string>;
-        values(): IteratorShim<T>;
-        entries(): IteratorShim<[string, T]>;
-        forEach(action: (value: T, key: string) => void): void;
-    }
-    export function createMapShim(): new <T>() => MapShim<T> {
-        /** Create a MapLike with good performance. */
-        function createDictionaryObject<T>(): Record<string, T> {
-            const map = Object.create(/*prototype*/ null); // eslint-disable-line no-null/no-null
-
-            // Using 'delete' on an object causes V8 to put the object in dictionary mode.
-            // This disables creation of hidden classes, which are expensive when an object is
-            // constantly changing shape.
-            map.__ = undefined;
-            delete map.__;
-
-            return map;
-        }
-
-        interface MapEntry<T> {
-            readonly key?: string;
-            value?: T;
-
-            // Linked list references for iterators.
-            nextEntry?: MapEntry<T>;
-            previousEntry?: MapEntry<T>;
-
-            /**
-             * Specifies if iterators should skip the next entry.
-             * This will be set when an entry is deleted.
-             * See https://github.com/Microsoft/TypeScript/pull/27292 for more information.
-             */
-            skipNext?: boolean;
-        }
-
-        class MapIterator<T, U extends (string | T | [string, T])> {
-            private currentEntry?: MapEntry<T>;
-            private selector: (key: string, value: T) => U;
-
-            constructor(currentEntry: MapEntry<T>, selector: (key: string, value: T) => U) {
-                this.currentEntry = currentEntry;
-                this.selector = selector;
-            }
-
-            public next(): { value: U, done?: false } | { value: never, done: true } {
-                // Navigate to the next entry.
-                while (this.currentEntry) {
-                    const skipNext = !!this.currentEntry.skipNext;
-                    this.currentEntry = this.currentEntry.nextEntry;
-
-                    if (!skipNext) {
-                        break;
-                    }
-                }
-
-                if (this.currentEntry) {
-                    return { value: this.selector(this.currentEntry.key!, this.currentEntry.value!), done: false };
-                }
-                else {
-                    return { value: undefined as never, done: true };
-                }
-            }
-        }
-
-        return class <T> implements MapShim<T> {
-            private data = createDictionaryObject<MapEntry<T>>();
-            public size = 0;
-
-            // Linked list references for iterators.
-            // See https://github.com/Microsoft/TypeScript/pull/27292
-            // for more information.
-
-            /**
-             * The first entry in the linked list.
-             * Note that this is only a stub that serves as starting point
-             * for iterators and doesn't contain a key and a value.
-             */
-            private readonly firstEntry: MapEntry<T>;
-            private lastEntry: MapEntry<T>;
-
-            constructor() {
-                // Create a first (stub) map entry that will not contain a key
-                // and value but serves as starting point for iterators.
-                this.firstEntry = {};
-                // When the map is empty, the last entry is the same as the
-                // first one.
-                this.lastEntry = this.firstEntry;
-            }
-
-            get(key: string): T | undefined {
-                const entry = this.data[key] as MapEntry<T> | undefined;
-                return entry && entry.value!;
-            }
-
-            set(key: string, value: T): this {
-                if (!this.has(key)) {
-                    this.size++;
-
-                    // Create a new entry that will be appended at the
-                    // end of the linked list.
-                    const newEntry: MapEntry<T> = {
-                        key,
-                        value
-                    };
-                    this.data[key] = newEntry;
-
-                    // Adjust the references.
-                    const previousLastEntry = this.lastEntry;
-                    previousLastEntry.nextEntry = newEntry;
-                    newEntry.previousEntry = previousLastEntry;
-                    this.lastEntry = newEntry;
-                }
-                else {
-                    this.data[key].value = value;
-                }
-
-                return this;
-            }
-
-            has(key: string): boolean {
-                // eslint-disable-next-line no-in-operator
-                return key in this.data;
-            }
-
-            delete(key: string): boolean {
-                if (this.has(key)) {
-                    this.size--;
-                    const entry = this.data[key];
-                    delete this.data[key];
-
-                    // Adjust the linked list references of the neighbor entries.
-                    const previousEntry = entry.previousEntry!;
-                    previousEntry.nextEntry = entry.nextEntry;
-                    if (entry.nextEntry) {
-                        entry.nextEntry.previousEntry = previousEntry;
-                    }
-
-                    // When the deleted entry was the last one, we need to
-                    // adjust the lastEntry reference.
-                    if (this.lastEntry === entry) {
-                        this.lastEntry = previousEntry;
-                    }
-
-                    // Adjust the forward reference of the deleted entry
-                    // in case an iterator still references it. This allows us
-                    // to throw away the entry, but when an active iterator
-                    // (which points to the current entry) continues, it will
-                    // navigate to the entry that originally came before the
-                    // current one and skip it.
-                    entry.previousEntry = undefined;
-                    entry.nextEntry = previousEntry;
-                    entry.skipNext = true;
-
-                    return true;
-                }
-                return false;
-            }
-
-            clear(): void {
-                this.data = createDictionaryObject<MapEntry<T>>();
-                this.size = 0;
-
-                // Reset the linked list. Note that we must adjust the forward
-                // references of the deleted entries to ensure iterators stuck
-                // in the middle of the list don't continue with deleted entries,
-                // but can continue with new entries added after the clear()
-                // operation.
-                const firstEntry = this.firstEntry;
-                let currentEntry = firstEntry.nextEntry;
-                while (currentEntry) {
-                    const nextEntry = currentEntry.nextEntry;
-                    currentEntry.previousEntry = undefined;
-                    currentEntry.nextEntry = firstEntry;
-                    currentEntry.skipNext = true;
-
-                    currentEntry = nextEntry;
-                }
-                firstEntry.nextEntry = undefined;
-                this.lastEntry = firstEntry;
-            }
-
-            keys(): IteratorShim<string> {
-                return new MapIterator(this.firstEntry, key => key);
-            }
-
-            values(): IteratorShim<T> {
-                return new MapIterator(this.firstEntry, (_key, value) => value);
-            }
-
-            entries(): IteratorShim<[string, T]> {
-                return new MapIterator(this.firstEntry, (key, value) => [key, value] as [string, T]);
-            }
-
-            forEach(action: (value: T, key: string) => void): void {
-                const iterator = this.entries();
-                while (true) {
-                    const iterResult = iterator.next();
-                    if (iterResult.done) {
-                        break;
-                    }
-
-                    const [key, value] = iterResult.value;
-                    action(value, key);
-                }
-            }
-        };
-    }
-}
\ No newline at end of file
diff --git a/src/shims/tsconfig.json b/src/shims/tsconfig.json
index cb058762fd616..572ac1538a9fe 100644
--- a/src/shims/tsconfig.json
+++ b/src/shims/tsconfig.json
@@ -4,6 +4,6 @@
         "outFile": "../../built/local/shims.js"
     },
     "files": [
-        "mapShim.ts"
+        "collectionShims.ts"
     ]
 }
diff --git a/src/testRunner/unittests/createMapShim.ts b/src/testRunner/unittests/createMapShim.ts
index c49e1cc63ccc1..e335816ea72ee 100644
--- a/src/testRunner/unittests/createMapShim.ts
+++ b/src/testRunner/unittests/createMapShim.ts
@@ -1,63 +1,97 @@
 namespace ts {
     describe("unittests:: createMapShim", () => {
 
-        function testMapIterationAddedValues(map: Map<string>, useForEach: boolean): string {
+        const stringKeys = [
+            "1",
+            "3",
+            "2",
+            "4",
+            "0",
+            "999",
+            "A",
+            "B",
+            "C",
+            "Z",
+            "X",
+            "X1",
+            "X2",
+            "Y"
+        ];
+
+        const mixedKeys = [
+            true,
+            3,
+            { toString() { return "2"; } },
+            "4",
+            false,
+            null, // eslint-disable-line no-null/no-null
+            undefined,
+            "B",
+            { toString() { return "C"; } },
+            "Z",
+            "X",
+            { toString() { return "X1"; } },
+            "X2",
+            "Y"
+        ];
+
+        function testMapIterationAddedValues<K>(keys: K[], map: ESMap<K, string>, useForEach: boolean): string {
             let resultString = "";
 
-            map.set("1", "1");
-            map.set("3", "3");
-            map.set("2", "2");
-            map.set("4", "4");
+            map.set(keys[0], "1");
+            map.set(keys[1], "3");
+            map.set(keys[2], "2");
+            map.set(keys[3], "4");
 
             let addedThree = false;
-            const doForEach = (value: string, key: string) => {
+            const doForEach = (value: string, key: K) => {
                 resultString += `${key}:${value};`;
 
                 // Add a new key ("0") - the map should provide this
                 // one in the next iteration.
-                if (key === "1") {
-                    map.set("1", "X1");
-                    map.set("0", "X0");
-                    map.set("4", "X4");
+                if (key === keys[0]) {
+                    map.set(keys[0], "X1");
+                    map.set(keys[4], "X0");
+                    map.set(keys[3], "X4");
                 }
-                else if (key === "3") {
+                else if (key === keys[1]) {
                     if (!addedThree) {
                         addedThree = true;
 
                         // Remove and re-add key "3"; the map should
                         // visit it after "0".
-                        map.delete("3");
-                        map.set("3", "Y3");
+                        map.delete(keys[1]);
+                        map.set(keys[1], "Y3");
 
                         // Change the value of "2"; the map should provide
                         // it when visiting the key.
-                        map.set("2", "Y2");
+                        map.set(keys[2], "Y2");
                     }
                     else {
                         // Check that an entry added when we visit the
                         // currently last entry will still be visited.
-                        map.set("999", "999");
+                        map.set(keys[5], "999");
                     }
                 }
-                else if (key === "999") {
+                else if (key === keys[5]) {
                     // Ensure that clear() behaves correctly same as removing all keys.
-                    map.set("A", "A");
-                    map.set("B", "B");
-                    map.set("C", "C");
+                    map.set(keys[6], "A");
+                    map.set(keys[7], "B");
+                    map.set(keys[8], "C");
                 }
-                else if (key === "A") {
+                else if (key === keys[6]) {
                     map.clear();
-                    map.set("Z", "Z");
+                    map.set(keys[9], "Z");
                 }
-                else if (key === "Z") {
+                else if (key === keys[9]) {
                     // Check that the map behaves correctly when two items are
                     // added and removed immediately.
-                    map.set("X", "X");
-                    map.set("X1", "X1");
-                    map.set("X2", "X2");
-                    map.delete("X1");
-                    map.delete("X2");
-                    map.set("Y", "Y");
+                    map.set(keys[10], "X");
+                    map.set(keys[11], "X1");
+                    map.set(keys[12], "X2");
+                    map.delete(keys[11]);
+                    map.delete(keys[12]);
+                    map.set(keys[13], "Y");
                 }
             };
 
@@ -81,26 +115,49 @@ namespace ts {
             return resultString;
         }
 
-        it("iterates values in insertion order and handles changes", () => {
+        it("iterates values in insertion order and handles changes with string keys", () => {
             const expectedResult = "1:1;3:3;2:Y2;4:X4;0:X0;3:Y3;999:999;A:A;Z:Z;X:X;Y:Y;";
 
             // First, ensure the test actually has the same behavior as a native Map.
             let nativeMap = createMap<string>();
-            const nativeMapForEachResult = testMapIterationAddedValues(nativeMap, /* useForEach */ true);
+            const nativeMapForEachResult = testMapIterationAddedValues(stringKeys, nativeMap, /* useForEach */ true);
             assert.equal(nativeMapForEachResult, expectedResult, "nativeMap-forEach");
 
             nativeMap = createMap<string>();
-            const nativeMapIteratorResult = testMapIterationAddedValues(nativeMap, /* useForEach */ false);
+            const nativeMapIteratorResult = testMapIterationAddedValues(stringKeys, nativeMap, /* useForEach */ false);
+            assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
+
+            // Then, test the map shim.
+            const MapShim = createMapShim(); // tslint:disable-line variable-name
+            let localShimMap = new MapShim<string, string>();
+            const shimMapForEachResult = testMapIterationAddedValues(stringKeys, localShimMap, /* useForEach */ true);
+            assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
+
+            localShimMap = new MapShim<string, string>();
+            const shimMapIteratorResult = testMapIterationAddedValues(stringKeys, localShimMap, /* useForEach */ false);
+            assert.equal(shimMapIteratorResult, expectedResult, "shimMap-iterator");
+        });
+
+        it("iterates values in insertion order and handles changes with mixed-type keys", () => {
+            const expectedResult = "true:1;3:3;2:Y2;4:X4;false:X0;3:Y3;null:999;undefined:A;Z:Z;X:X;Y:Y;";
+
+            // First, ensure the test actually has the same behavior as a native Map.
+            let nativeMap = createMap<any, string>();
+            const nativeMapForEachResult = testMapIterationAddedValues(mixedKeys, nativeMap, /* useForEach */ true);
+            assert.equal(nativeMapForEachResult, expectedResult, "nativeMap-forEach");
+
+            nativeMap = createMap<any, string>();
+            const nativeMapIteratorResult = testMapIterationAddedValues(mixedKeys, nativeMap, /* useForEach */ false);
             assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
 
             // Then, test the map shim.
             const MapShim = createMapShim(); // tslint:disable-line variable-name
-            let localShimMap = new MapShim<string>();
-            const shimMapForEachResult = testMapIterationAddedValues(localShimMap, /* useForEach */ true);
+            let localShimMap = new MapShim<any, string>();
+            const shimMapForEachResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ true);
             assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
 
-            localShimMap = new MapShim<string>();
-            const shimMapIteratorResult = testMapIterationAddedValues(localShimMap, /* useForEach */ false);
+            localShimMap = new MapShim<any, string>();
+            const shimMapIteratorResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ false);
             assert.equal(shimMapIteratorResult, expectedResult, "shimMap-iterator");
         });
     });
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 30b789890b3e7..0d0cf535cfbc0 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -32,21 +32,51 @@ declare namespace ts {
         " __sortedArrayBrand": any;
     }
     /** ES6 Map interface, only read methods included. */
-    interface ReadonlyMap<T> {
-        get(key: string): T | undefined;
-        has(key: string): boolean;
-        forEach(action: (value: T, key: string) => void): void;
+    interface ReadonlyESMap<K, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        forEach(action: (value: V, key: K) => void): void;
         readonly size: number;
-        keys(): Iterator<string>;
-        values(): Iterator<T>;
-        entries(): Iterator<[string, T]>;
+        keys(): Iterator<K>;
+        values(): Iterator<V>;
+        entries(): Iterator<[K, V]>;
+    }
+    /** ES6 Map interface. */
+    interface ESMap<K, V> extends ReadonlyESMap<K, V> {
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
+        clear(): void;
+    }
+    /** ES6 Map interface, only read methods included. */
+    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
     }
     /** ES6 Map interface. */
-    interface Map<T> extends ReadonlyMap<T> {
-        set(key: string, value: T): this;
-        delete(key: string): boolean;
+    interface Map<T> extends ESMap<string, T>, ReadonlyMap<T> {
+    }
+    interface ReadonlySet<T> {
+        readonly size: number;
+        has(value: T): boolean;
+        forEach(action: (value: T, key: T) => void): void;
+        keys(): Iterator<T>;
+        values(): Iterator<T>;
+        entries(): Iterator<[T, T]>;
+    }
+    interface Set<T> extends ReadonlySet<T> {
+        add(value: T): this;
+        delete(value: T): boolean;
         clear(): void;
     }
+    interface WeakMap<K extends object, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
+    }
+    interface WeakSet<T extends object> {
+        has(key: T): boolean;
+        add(key: T): this;
+        delete(key: T): boolean;
+    }
     /** ES6 Iterator type. */
     interface Iterator<T> {
         next(): {
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index c3149e9b7d17e..0aa33e2b43537 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -32,21 +32,51 @@ declare namespace ts {
         " __sortedArrayBrand": any;
     }
     /** ES6 Map interface, only read methods included. */
-    interface ReadonlyMap<T> {
-        get(key: string): T | undefined;
-        has(key: string): boolean;
-        forEach(action: (value: T, key: string) => void): void;
+    interface ReadonlyESMap<K, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        forEach(action: (value: V, key: K) => void): void;
         readonly size: number;
-        keys(): Iterator<string>;
-        values(): Iterator<T>;
-        entries(): Iterator<[string, T]>;
+        keys(): Iterator<K>;
+        values(): Iterator<V>;
+        entries(): Iterator<[K, V]>;
+    }
+    /** ES6 Map interface. */
+    interface ESMap<K, V> extends ReadonlyESMap<K, V> {
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
+        clear(): void;
+    }
+    /** ES6 Map interface, only read methods included. */
+    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
     }
     /** ES6 Map interface. */
-    interface Map<T> extends ReadonlyMap<T> {
-        set(key: string, value: T): this;
-        delete(key: string): boolean;
+    interface Map<T> extends ESMap<string, T>, ReadonlyMap<T> {
+    }
+    interface ReadonlySet<T> {
+        readonly size: number;
+        has(value: T): boolean;
+        forEach(action: (value: T, key: T) => void): void;
+        keys(): Iterator<T>;
+        values(): Iterator<T>;
+        entries(): Iterator<[T, T]>;
+    }
+    interface Set<T> extends ReadonlySet<T> {
+        add(value: T): this;
+        delete(value: T): boolean;
         clear(): void;
     }
+    interface WeakMap<K extends object, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
+    }
+    interface WeakSet<T extends object> {
+        has(key: T): boolean;
+        add(key: T): this;
+        delete(key: T): boolean;
+    }
     /** ES6 Iterator type. */
     interface Iterator<T> {
         next(): {

From eb3c9f448b1c43ac7200d81e124299083d25bee8 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Tue, 16 Jun 2020 15:29:31 -0700
Subject: [PATCH 02/10] Update default Map interface

---
 src/compiler/binder.ts                        |   6 +-
 src/compiler/builder.ts                       |  34 ++---
 src/compiler/builderState.ts                  |  36 ++---
 src/compiler/checker.ts                       |  82 +++++------
 src/compiler/commandLineParser.ts             |  46 +++---
 src/compiler/core.ts                          | 135 +++++++++++-------
 src/compiler/corePublic.ts                    |  56 ++------
 src/compiler/emitter.ts                       |  10 +-
 src/compiler/factory/emitHelpers.ts           |   2 +-
 src/compiler/moduleNameResolver.ts            |  22 +--
 src/compiler/parser.ts                        |   6 +-
 src/compiler/performance.ts                   |   6 +-
 src/compiler/program.ts                       |  28 ++--
 src/compiler/resolutionCache.ts               |  22 +--
 src/compiler/scanner.ts                       |   2 +-
 src/compiler/sourcemap.ts                     |   2 +-
 src/compiler/sys.ts                           |   2 +-
 src/compiler/transformers/declarations.ts     |  12 +-
 src/compiler/transformers/es2015.ts           |   8 +-
 src/compiler/transformers/generators.ts       |   2 +-
 .../transformers/module/esnextAnd2015.ts      |   2 +-
 src/compiler/transformers/utilities.ts        |   4 +-
 src/compiler/tsbuildPublic.ts                 |  24 +---
 src/compiler/types.ts                         |  72 ++++------
 src/compiler/utilities.ts                     |  56 ++++----
 src/compiler/watchPublic.ts                   |   4 +-
 src/compiler/watchUtilities.ts                |   6 +-
 src/executeCommandLine/executeCommandLine.ts  |   2 +-
 src/harness/client.ts                         |   2 +-
 src/harness/fourslashImpl.ts                  |  14 +-
 src/harness/fourslashInterfaceImpl.ts         |   2 +-
 src/harness/harnessIO.ts                      |  10 +-
 src/harness/harnessLanguageService.ts         |   2 +-
 src/harness/loggedIO.ts                       |   2 +-
 src/harness/virtualFileSystemWithWatch.ts     |  58 ++++----
 src/jsTyping/jsTyping.ts                      |   6 +-
 src/server/editorServices.ts                  |  38 ++---
 src/server/project.ts                         |  48 +++----
 src/server/scriptInfo.ts                      |   4 +-
 src/server/session.ts                         |  10 +-
 src/server/typingsCache.ts                    |   4 +-
 src/server/utilities.ts                       |   2 +-
 src/services/codefixes/addMissingAsync.ts     |   4 +-
 src/services/codefixes/addMissingAwait.ts     |   6 +-
 .../codefixes/convertToAsyncFunction.ts       |  14 +-
 src/services/codefixes/convertToEs6Module.ts  |   6 +-
 .../codefixes/disableJsDiagnostics.ts         |   2 +-
 src/services/codefixes/importFixes.ts         |   2 +-
 src/services/completions.ts                   |   4 +-
 src/services/documentRegistry.ts              |   4 +-
 src/services/findAllReferences.ts             |  16 +--
 src/services/importTracker.ts                 |   8 +-
 src/services/navigationBar.ts                 |   4 +-
 src/services/patternMatcher.ts                |   8 +-
 src/services/refactorProvider.ts              |   2 +-
 src/services/refactors/extractSymbol.ts       |  16 +--
 src/services/services.ts                      |  14 +-
 src/services/shims.ts                         |   4 +-
 src/services/types.ts                         |  12 +-
 src/services/utilities.ts                     |   4 +-
 src/shims/collectionShims.ts                  |  61 ++++++--
 src/testRunner/parallel/worker.ts             |   4 +-
 .../unittests/config/commandLineParsing.ts    |   2 +-
 src/testRunner/unittests/createMapShim.ts     |   2 +-
 src/testRunner/unittests/moduleResolution.ts  |   4 +-
 src/testRunner/unittests/programApi.ts        |   2 +-
 .../unittests/reuseProgramStructure.ts        |   8 +-
 .../unittests/services/extract/helpers.ts     |   2 +-
 src/testRunner/unittests/tsbuild/helpers.ts   |   4 +-
 .../unittests/tsbuild/watchEnvironment.ts     |   2 +-
 src/testRunner/unittests/tsc/helpers.ts       |   4 +-
 .../tsserver/cachingFileSystemInformation.ts  |   4 +-
 src/testRunner/unittests/tsserver/helpers.ts  |   2 +-
 src/testRunner/unittests/tsserver/symLinks.ts |   2 +-
 .../unittests/tsserver/typingsInstaller.ts    |   2 +-
 src/tsserver/server.ts                        |   2 +-
 src/typingsInstaller/nodeTypingsInstaller.ts  |   4 +-
 src/typingsInstallerCore/typingsInstaller.ts  |  10 +-
 .../reference/api/tsserverlibrary.d.ts        |  46 ++----
 tests/baselines/reference/api/typescript.d.ts |  38 ++---
 80 files changed, 598 insertions(+), 628 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 7549759138967..a95582b53859a 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -15,7 +15,7 @@ namespace ts {
         referenced: boolean;
     }
 
-    export function getModuleInstanceState(node: ModuleDeclaration, visited?: Map<ModuleInstanceState | undefined>): ModuleInstanceState {
+    export function getModuleInstanceState(node: ModuleDeclaration, visited?: Map<string, ModuleInstanceState | undefined>): ModuleInstanceState {
         if (node.body && !node.body.parent) {
             // getModuleInstanceStateForAliasTarget needs to walk up the parent chain, so parent pointers must be set on this tree already
             setParent(node.body, node);
@@ -35,7 +35,7 @@ namespace ts {
         return result;
     }
 
-    function getModuleInstanceStateWorker(node: Node, visited: Map<ModuleInstanceState | undefined>): ModuleInstanceState {
+    function getModuleInstanceStateWorker(node: Node, visited: Map<string, ModuleInstanceState | undefined>): ModuleInstanceState {
         // A module is uninstantiated if it contains only
         switch (node.kind) {
             // 1. interface declarations, type alias declarations
@@ -107,7 +107,7 @@ namespace ts {
         return ModuleInstanceState.Instantiated;
     }
 
-    function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: Map<ModuleInstanceState | undefined>) {
+    function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: Map<string, ModuleInstanceState | undefined>) {
         const name = specifier.propertyName || specifier.name;
         let p: Node | undefined = specifier.parent;
         while (p) {
diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
index 16707941c63ac..488c89bea24ef 100644
--- a/src/compiler/builder.ts
+++ b/src/compiler/builder.ts
@@ -24,11 +24,11 @@ namespace ts {
         /**
          * Cache of bind and check diagnostics for files with their Path being the key
          */
-        semanticDiagnosticsPerFile?: ReadonlyMap<readonly ReusableDiagnostic[] | readonly Diagnostic[]> | undefined;
+        semanticDiagnosticsPerFile?: ReadonlyMap<string, readonly ReusableDiagnostic[] | readonly Diagnostic[]> | undefined;
         /**
          * The map has key by source file's path that has been changed
          */
-        changedFilesSet?: ReadonlyMap<true>;
+        changedFilesSet?: ReadonlyMap<string, true>;
         /**
          * Set of affected files being iterated
          */
@@ -41,7 +41,7 @@ namespace ts {
          * Map of file signatures, with key being file path, calculated while getting current changed file's affected files
          * These will be committed whenever the iteration through affected files of current changed file is complete
          */
-        currentAffectedFilesSignatures?: ReadonlyMap<string> | undefined;
+        currentAffectedFilesSignatures?: ReadonlyMap<string, string> | undefined;
         /**
          * Newly computed visible to outside referencedSet
          */
@@ -49,7 +49,7 @@ namespace ts {
         /**
          * True if the semantic diagnostics were copied from the old state
          */
-        semanticDiagnosticsFromOldState?: Map<true>;
+        semanticDiagnosticsFromOldState?: Map<string, true>;
         /**
          * program corresponding to this state
          */
@@ -65,7 +65,7 @@ namespace ts {
         /**
          * Files pending to be emitted kind.
          */
-        affectedFilesPendingEmitKind?: ReadonlyMap<BuilderFileEmit> | undefined;
+        affectedFilesPendingEmitKind?: ReadonlyMap<string, BuilderFileEmit> | undefined;
         /**
          * Current index to retrieve pending affected file
          */
@@ -89,11 +89,11 @@ namespace ts {
         /**
          * Cache of bind and check diagnostics for files with their Path being the key
          */
-        semanticDiagnosticsPerFile: Map<readonly Diagnostic[]> | undefined;
+        semanticDiagnosticsPerFile: Map<string, readonly Diagnostic[]> | undefined;
         /**
          * The map has key by source file's path that has been changed
          */
-        changedFilesSet: Map<true>;
+        changedFilesSet: Map<string, true>;
         /**
          * Set of affected files being iterated
          */
@@ -110,7 +110,7 @@ namespace ts {
          * Map of file signatures, with key being file path, calculated while getting current changed file's affected files
          * These will be committed whenever the iteration through affected files of current changed file is complete
          */
-        currentAffectedFilesSignatures: Map<string> | undefined;
+        currentAffectedFilesSignatures: Map<string, string> | undefined;
         /**
          * Newly computed visible to outside referencedSet
          */
@@ -118,7 +118,7 @@ namespace ts {
         /**
          * Already seen affected files
          */
-        seenAffectedFiles: Map<true> | undefined;
+        seenAffectedFiles: Map<string, true> | undefined;
         /**
          * whether this program has cleaned semantic diagnostics cache for lib files
          */
@@ -126,7 +126,7 @@ namespace ts {
         /**
          * True if the semantic diagnostics were copied from the old state
          */
-        semanticDiagnosticsFromOldState?: Map<true>;
+        semanticDiagnosticsFromOldState?: Map<string, true>;
         /**
          * program corresponding to this state
          */
@@ -142,7 +142,7 @@ namespace ts {
         /**
          * Files pending to be emitted kind.
          */
-        affectedFilesPendingEmitKind: Map<BuilderFileEmit> | undefined;
+        affectedFilesPendingEmitKind: Map<string, BuilderFileEmit> | undefined;
         /**
          * Current index to retrieve pending affected file
          */
@@ -154,16 +154,16 @@ namespace ts {
         /**
          * Already seen emitted files
          */
-        seenEmittedFiles: Map<BuilderFileEmit> | undefined;
+        seenEmittedFiles: Map<string, BuilderFileEmit> | undefined;
         /**
          * true if program has been emitted
          */
         programEmitComplete?: true;
     }
 
-    function hasSameKeys<T, U>(map1: ReadonlyMap<T> | undefined, map2: ReadonlyMap<U> | undefined): boolean {
+    function hasSameKeys<T, U>(map1: ReadonlyMap<string, T> | undefined, map2: ReadonlyMap<string, U> | undefined): boolean {
         // Has same size and every key is present in both maps
-        return map1 as ReadonlyMap<T | U> === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !forEachKey(map1, key => !map2.has(key));
+        return map1 as ReadonlyMap<string, T | U> === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !forEachKey(map1, key => !map2.has(key));
     }
 
     /**
@@ -555,7 +555,7 @@ namespace ts {
     /**
      * Iterate on files referencing referencedPath
      */
-    function forEachFilesReferencingPath(state: BuilderProgramState, referencedPath: Path, seenFileAndExportsOfFile: Map<true>, fn: (state: BuilderProgramState, filePath: Path) => boolean) {
+    function forEachFilesReferencingPath(state: BuilderProgramState, referencedPath: Path, seenFileAndExportsOfFile: Map<string, true>, fn: (state: BuilderProgramState, filePath: Path) => boolean) {
         return forEachEntry(state.referencedMap!, (referencesInFile, filePath) =>
             referencesInFile.has(referencedPath) && forEachFileAndExportsOfFile(state, filePath as Path, seenFileAndExportsOfFile, fn)
         );
@@ -564,7 +564,7 @@ namespace ts {
     /**
      * fn on file and iterate on anything that exports this file
      */
-    function forEachFileAndExportsOfFile(state: BuilderProgramState, filePath: Path, seenFileAndExportsOfFile: Map<true>, fn: (state: BuilderProgramState, filePath: Path) => boolean): boolean {
+    function forEachFileAndExportsOfFile(state: BuilderProgramState, filePath: Path, seenFileAndExportsOfFile: Map<string, true>, fn: (state: BuilderProgramState, filePath: Path) => boolean): boolean {
         if (!addToSeen(seenFileAndExportsOfFile, filePath)) {
             return false;
         }
@@ -1142,7 +1142,7 @@ namespace ts {
         }
     }
 
-    function getMapOfReferencedSet(mapLike: MapLike<readonly string[]> | undefined, toPath: (path: string) => Path): ReadonlyMap<BuilderState.ReferencedSet> | undefined {
+    function getMapOfReferencedSet(mapLike: MapLike<readonly string[]> | undefined, toPath: (path: string) => Path): ReadonlyMap<string, BuilderState.ReferencedSet> | undefined {
         if (!mapLike) return undefined;
         const map = createMap<BuilderState.ReferencedSet>();
         // Copies keys/values from template. Note that for..in will not throw if
diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index 315e67bdbb2d5..beea442101eab 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -15,42 +15,42 @@ namespace ts {
         /**
          * Information of the file eg. its version, signature etc
          */
-        fileInfos: ReadonlyMap<BuilderState.FileInfo>;
+        fileInfos: ReadonlyMap<string, BuilderState.FileInfo>;
         /**
          * Contains the map of ReferencedSet=Referenced files of the file if module emit is enabled
          * Otherwise undefined
          * Thus non undefined value indicates, module emit
          */
-        readonly referencedMap?: ReadonlyMap<BuilderState.ReferencedSet> | undefined;
+        readonly referencedMap?: ReadonlyMap<string, BuilderState.ReferencedSet> | undefined;
         /**
          * Contains the map of exported modules ReferencedSet=exported module files from the file if module emit is enabled
          * Otherwise undefined
          */
-        readonly exportedModulesMap?: ReadonlyMap<BuilderState.ReferencedSet> | undefined;
+        readonly exportedModulesMap?: ReadonlyMap<string, BuilderState.ReferencedSet> | undefined;
     }
 
     export interface BuilderState {
         /**
          * Information of the file eg. its version, signature etc
          */
-        fileInfos: Map<BuilderState.FileInfo>;
+        fileInfos: Map<string, BuilderState.FileInfo>;
         /**
          * Contains the map of ReferencedSet=Referenced files of the file if module emit is enabled
          * Otherwise undefined
          * Thus non undefined value indicates, module emit
          */
-        readonly referencedMap: ReadonlyMap<BuilderState.ReferencedSet> | undefined;
+        readonly referencedMap: ReadonlyMap<string, BuilderState.ReferencedSet> | undefined;
         /**
          * Contains the map of exported modules ReferencedSet=exported module files from the file if module emit is enabled
          * Otherwise undefined
          */
-        readonly exportedModulesMap: Map<BuilderState.ReferencedSet> | undefined;
+        readonly exportedModulesMap: Map<string, BuilderState.ReferencedSet> | undefined;
         /**
          * Map of files that have already called update signature.
          * That means hence forth these files are assumed to have
          * no change in their signature for this version of the program
          */
-        hasCalledUpdateShapeSignature: Map<true>;
+        hasCalledUpdateShapeSignature: Map<string, true>;
         /**
          * Cache of all files excluding default library file for the current program
          */
@@ -73,7 +73,7 @@ namespace ts {
         /**
          * Referenced files with values for the keys as referenced file's path to be true
          */
-        export type ReferencedSet = ReadonlyMap<true>;
+        export type ReferencedSet = ReadonlyMap<string, true>;
         /**
          * Compute the hash to store the shape of the file
          */
@@ -83,7 +83,7 @@ namespace ts {
          * Exported modules to from declaration emit being computed.
          * This can contain false in the affected file path to specify that there are no exported module(types from other modules) for this file
          */
-        export type ComputingExportedModulesMap = Map<ReferencedSet | false>;
+        export type ComputingExportedModulesMap = Map<string, ReferencedSet | false>;
 
         /**
          * Get the referencedFile from the imported module symbol
@@ -113,8 +113,8 @@ namespace ts {
         /**
          * Gets the referenced files for a file from the program with values for the keys as referenced file's path to be true
          */
-        function getReferencedFiles(program: Program, sourceFile: SourceFile, getCanonicalFileName: GetCanonicalFileName): Map<true> | undefined {
-            let referencedFiles: Map<true> | undefined;
+        function getReferencedFiles(program: Program, sourceFile: SourceFile, getCanonicalFileName: GetCanonicalFileName): Map<string, true> | undefined {
+            let referencedFiles: Map<string, true> | undefined;
 
             // We need to use a set here since the code can contain the same import twice,
             // but that will only be one dependency.
@@ -195,7 +195,7 @@ namespace ts {
         /**
          * Returns true if oldState is reusable, that is the emitKind = module/non module has not changed
          */
-        export function canReuseOldState(newReferencedMap: ReadonlyMap<ReferencedSet> | undefined, oldState: Readonly<ReusableBuilderState> | undefined) {
+        export function canReuseOldState(newReferencedMap: ReadonlyMap<string, ReferencedSet> | undefined, oldState: Readonly<ReusableBuilderState> | undefined) {
             return oldState && !oldState.referencedMap === !newReferencedMap;
         }
 
@@ -265,7 +265,7 @@ namespace ts {
         /**
          * Gets the files affected by the path from the program
          */
-        export function getFilesAffectedBy(state: BuilderState, programOfThisState: Program, path: Path, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, cacheToUpdateSignature?: Map<string>, exportedModulesMapCache?: ComputingExportedModulesMap): readonly SourceFile[] {
+        export function getFilesAffectedBy(state: BuilderState, programOfThisState: Program, path: Path, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, cacheToUpdateSignature?: Map<string, string>, exportedModulesMapCache?: ComputingExportedModulesMap): readonly SourceFile[] {
             // Since the operation could be cancelled, the signatures are always stored in the cache
             // They will be committed once it is safe to use them
             // eg when calling this api from tsserver, if there is no cancellation of the operation
@@ -292,7 +292,7 @@ namespace ts {
          * Updates the signatures from the cache into state's fileinfo signatures
          * This should be called whenever it is safe to commit the state of the builder
          */
-        export function updateSignaturesFromCache(state: BuilderState, signatureCache: Map<string>) {
+        export function updateSignaturesFromCache(state: BuilderState, signatureCache: Map<string, string>) {
             signatureCache.forEach((signature, path) => updateSignatureOfFile(state, signature, path as Path));
         }
 
@@ -304,7 +304,7 @@ namespace ts {
         /**
          * Returns if the shape of the signature has changed since last emit
          */
-        export function updateShapeSignature(state: Readonly<BuilderState>, programOfThisState: Program, sourceFile: SourceFile, cacheToUpdateSignature: Map<string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, exportedModulesMapCache?: ComputingExportedModulesMap) {
+        export function updateShapeSignature(state: Readonly<BuilderState>, programOfThisState: Program, sourceFile: SourceFile, cacheToUpdateSignature: Map<string, string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, exportedModulesMapCache?: ComputingExportedModulesMap) {
             Debug.assert(!!sourceFile);
             Debug.assert(!exportedModulesMapCache || !!state.exportedModulesMap, "Compute visible to outside map only if visibleToOutsideReferencedMap present in the state");
 
@@ -365,7 +365,7 @@ namespace ts {
                 return;
             }
 
-            let exportedModules: Map<true> | undefined;
+            let exportedModules: Map<string, true> | undefined;
             exportedModulesFromDeclarationEmit.forEach(symbol => addExportedModule(getReferencedFileFromImportedModuleSymbol(symbol)));
             exportedModulesMapCache.set(sourceFile.resolvedPath, exportedModules || false);
 
@@ -528,7 +528,7 @@ namespace ts {
         /**
          * When program emits modular code, gets the files affected by the sourceFile whose shape has changed
          */
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state: BuilderState, programOfThisState: Program, sourceFileWithUpdatedShape: SourceFile, cacheToUpdateSignature: Map<string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash | undefined, exportedModulesMapCache: ComputingExportedModulesMap | undefined) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state: BuilderState, programOfThisState: Program, sourceFileWithUpdatedShape: SourceFile, cacheToUpdateSignature: Map<string, string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash | undefined, exportedModulesMapCache: ComputingExportedModulesMap | undefined) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -563,7 +563,7 @@ namespace ts {
         }
     }
 
-    export function cloneMapOrUndefined<T>(map: ReadonlyMap<T> | undefined) {
+    export function cloneMapOrUndefined<T>(map: ReadonlyMap<string, T> | undefined) {
         return map ? cloneMap(map) : undefined;
     }
 }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2134e7f9b2992..ea212dea29e7a 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -134,7 +134,7 @@ namespace ts {
         EmptyObjectFacts = All,
     }
 
-    const typeofEQFacts: ReadonlyMap<TypeFacts> = createMapFromTemplate({
+    const typeofEQFacts: ReadonlyMap<string, TypeFacts> = createMapFromTemplate({
         string: TypeFacts.TypeofEQString,
         number: TypeFacts.TypeofEQNumber,
         bigint: TypeFacts.TypeofEQBigInt,
@@ -145,7 +145,7 @@ namespace ts {
         function: TypeFacts.TypeofEQFunction
     });
 
-    const typeofNEFacts: ReadonlyMap<TypeFacts> = createMapFromTemplate({
+    const typeofNEFacts: ReadonlyMap<string, TypeFacts> = createMapFromTemplate({
         string: TypeFacts.TypeofNEString,
         number: TypeFacts.TypeofNENumber,
         bigint: TypeFacts.TypeofNEBigInt,
@@ -277,7 +277,7 @@ namespace ts {
     }
 
     export function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker {
-        const getPackagesSet: () => Map<true> = memoize(() => {
+        const getPackagesSet: () => Map<string, true> = memoize(() => {
             const set = createMap<true>();
             host.getSourceFiles().forEach(sf => {
                 if (!sf.resolvedModules) return;
@@ -825,10 +825,10 @@ namespace ts {
             readonly firstFile: SourceFile;
             readonly secondFile: SourceFile;
             /** Key is symbol name. */
-            readonly conflictingSymbols: Map<DuplicateInfoForSymbol>;
+            readonly conflictingSymbols: Map<string, DuplicateInfoForSymbol>;
         }
         /** Key is "/path/to/a.ts|/path/to/b.ts". */
-        let amalgamatedDuplicates: Map<DuplicateInfoForFiles> | undefined;
+        let amalgamatedDuplicates: Map<string, DuplicateInfoForFiles> | undefined;
         const reverseMappedCache = createMap<Type | undefined>();
         let inInferTypeForHomomorphicMappedType = false;
         let ambientModulesCache: Symbol[] | undefined;
@@ -838,7 +838,7 @@ namespace ts {
          * This is only used if there is no exact match.
          */
         let patternAmbientModules: PatternAmbientModule[];
-        let patternAmbientModuleAugmentations: Map<Symbol> | undefined;
+        let patternAmbientModuleAugmentations: Map<string, Symbol> | undefined;
 
         let globalObjectType: ObjectType;
         let globalFunctionType: ObjectType;
@@ -906,7 +906,7 @@ namespace ts {
         const mergedSymbols: Symbol[] = [];
         const symbolLinks: SymbolLinks[] = [];
         const nodeLinks: NodeLinks[] = [];
-        const flowLoopCaches: Map<Type>[] = [];
+        const flowLoopCaches: Map<string, Type>[] = [];
         const flowLoopNodes: FlowNode[] = [];
         const flowLoopKeys: string[] = [];
         const flowLoopTypes: Type[][] = [];
@@ -922,7 +922,7 @@ namespace ts {
         const diagnostics = createDiagnosticCollection();
         const suggestionDiagnostics = createDiagnosticCollection();
 
-        const typeofTypesByName: ReadonlyMap<Type> = createMapFromTemplate<Type>({
+        const typeofTypesByName: ReadonlyMap<string, Type> = createMapFromTemplate<Type>({
             string: stringType,
             number: numberType,
             bigint: bigintType,
@@ -3752,7 +3752,7 @@ namespace ts {
             return rightMeaning === SymbolFlags.Value ? SymbolFlags.Value : SymbolFlags.Namespace;
         }
 
-        function getAccessibleSymbolChain(symbol: Symbol | undefined, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, useOnlyExternalAliasing: boolean, visitedSymbolTablesMap: Map<SymbolTable[]> = createMap()): Symbol[] | undefined {
+        function getAccessibleSymbolChain(symbol: Symbol | undefined, enclosingDeclaration: Node | undefined, meaning: SymbolFlags, useOnlyExternalAliasing: boolean, visitedSymbolTablesMap: Map<string, SymbolTable[]> = createMap()): Symbol[] | undefined {
             if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) {
                 return undefined;
             }
@@ -5876,8 +5876,8 @@ namespace ts {
                 // we're trying to emit from later on)
                 const enclosingDeclaration = context.enclosingDeclaration!;
                 let results: Statement[] = [];
-                const visitedSymbols: Map<true> = createMap();
-                let deferredPrivates: Map<Symbol> | undefined;
+                const visitedSymbols: Map<string, true> = createMap();
+                let deferredPrivates: Map<string, Symbol> | undefined;
                 const oldcontext = context;
                 context = {
                     ...oldcontext,
@@ -7189,16 +7189,16 @@ namespace ts {
 
             // State
             encounteredError: boolean;
-            visitedTypes: Map<true> | undefined;
-            symbolDepth: Map<number> | undefined;
+            visitedTypes: Map<string, true> | undefined;
+            symbolDepth: Map<string, number> | undefined;
             inferTypeParameters: TypeParameter[] | undefined;
             approximateLength: number;
             truncating?: boolean;
-            typeParameterSymbolList?: Map<true>;
-            typeParameterNames?: Map<Identifier>;
-            typeParameterNamesByText?: Map<true>;
-            usedSymbolNames?: Map<true>;
-            remappedSymbolNames?: Map<string>;
+            typeParameterSymbolList?: Map<string, true>;
+            typeParameterNames?: Map<string, Identifier>;
+            typeParameterNamesByText?: Map<string, true>;
+            usedSymbolNames?: Map<string, true>;
+            remappedSymbolNames?: Map<string, string>;
         }
 
         function isDefaultBindingContext(location: Node) {
@@ -7394,7 +7394,7 @@ namespace ts {
                 exportSymbol = getTargetOfExportSpecifier(<ExportSpecifier>node.parent, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
             let result: Node[] | undefined;
-            let visited: Map<true> | undefined;
+            let visited: Map<string, true> | undefined;
             if (exportSymbol) {
                 visited = createMap();
                 visited.set("" + getSymbolId(exportSymbol), true);
@@ -10817,7 +10817,7 @@ namespace ts {
 
         function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: __String): Symbol | undefined {
             let singleProp: Symbol | undefined;
-            let propSet: Map<Symbol> | undefined;
+            let propSet: Map<string, Symbol> | undefined;
             let indexTypes: Type[] | undefined;
             const isUnion = containingType.flags & TypeFlags.Union;
             // Flags we want to propagate to the result if they exist in all source symbols
@@ -12768,7 +12768,7 @@ namespace ts {
             return links.resolvedType;
         }
 
-        function addTypeToIntersection(typeSet: Map<Type>, includes: TypeFlags, type: Type) {
+        function addTypeToIntersection(typeSet: Map<string, Type>, includes: TypeFlags, type: Type) {
             const flags = type.flags;
             if (flags & TypeFlags.Intersection) {
                 return addTypesToIntersection(typeSet, includes, (<IntersectionType>type).types);
@@ -12798,7 +12798,7 @@ namespace ts {
 
         // Add the given types to the given type set. Order is preserved, freshness is removed from literal
         // types, duplicates are removed, and nested types of the given kind are flattened into the set.
-        function addTypesToIntersection(typeSet: Map<Type>, includes: TypeFlags, types: readonly Type[]) {
+        function addTypesToIntersection(typeSet: Map<string, Type>, includes: TypeFlags, types: readonly Type[]) {
             for (const type of types) {
                 includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type));
             }
@@ -12915,7 +12915,7 @@ namespace ts {
         // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
         // for intersections of types with signatures can be deterministic.
         function getIntersectionType(types: readonly Type[], aliasSymbol?: Symbol, aliasTypeArguments?: readonly Type[]): Type {
-            const typeMembershipMap: Map<Type> = createMap();
+            const typeMembershipMap: Map<string, Type> = createMap();
             const includes = addTypesToIntersection(typeMembershipMap, 0, types);
             const typeSet: Type[] = arrayFrom(typeMembershipMap.values());
             // An intersection type is considered empty if it contains
@@ -14895,7 +14895,7 @@ namespace ts {
         function checkTypeRelatedToAndOptionallyElaborate(
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             errorNode: Node | undefined,
             expr: Expression | undefined,
             headMessage: DiagnosticMessage | undefined,
@@ -14917,7 +14917,7 @@ namespace ts {
             node: Expression | undefined,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             headMessage: DiagnosticMessage | undefined,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
@@ -14954,7 +14954,7 @@ namespace ts {
             node: Expression,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             headMessage: DiagnosticMessage | undefined,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
@@ -14983,7 +14983,7 @@ namespace ts {
             node: ArrowFunction,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
         ): boolean {
@@ -15070,7 +15070,7 @@ namespace ts {
             iterator: ElaborationIterator,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
         ) {
@@ -15184,7 +15184,7 @@ namespace ts {
             node: JsxAttributes,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
         ) {
@@ -15285,7 +15285,7 @@ namespace ts {
             node: ArrayLiteralExpression,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
         ) {
@@ -15338,7 +15338,7 @@ namespace ts {
             node: ObjectLiteralExpression,
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
             errorOutputContainer: { errors?: Diagnostic[], skipLogging?: boolean } | undefined
         ) {
@@ -15629,7 +15629,7 @@ namespace ts {
             return true;
         }
 
-        function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>, errorReporter?: ErrorReporter) {
+        function isSimpleTypeRelatedTo(source: Type, target: Type, relation: Map<string, RelationComparisonResult>, errorReporter?: ErrorReporter) {
             const s = source.flags;
             const t = target.flags;
             if (t & TypeFlags.AnyOrUnknown || s & TypeFlags.Never || source === wildcardType) return true;
@@ -15666,7 +15666,7 @@ namespace ts {
             return false;
         }
 
-        function isTypeRelatedTo(source: Type, target: Type, relation: Map<RelationComparisonResult>) {
+        function isTypeRelatedTo(source: Type, target: Type, relation: Map<string, RelationComparisonResult>) {
             if (isFreshLiteralType(source)) {
                 source = (<FreshableType>source).regularType;
             }
@@ -15729,7 +15729,7 @@ namespace ts {
         function checkTypeRelatedTo(
             source: Type,
             target: Type,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             errorNode: Node | undefined,
             headMessage?: DiagnosticMessage,
             containingMessageChain?: () => DiagnosticMessageChain | undefined,
@@ -17782,7 +17782,7 @@ namespace ts {
          * To improve caching, the relation key for two generic types uses the target's id plus ids of the type parameters.
          * For other cases, the types ids are used.
          */
-        function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: Map<RelationComparisonResult>) {
+        function getRelationKey(source: Type, target: Type, intersectionState: IntersectionState, relation: Map<string, RelationComparisonResult>) {
             if (relation === identityRelation && source.id > target.id) {
                 const temp = source;
                 source = target;
@@ -18919,7 +18919,7 @@ namespace ts {
 
         function inferTypes(inferences: InferenceInfo[], originalSource: Type, originalTarget: Type, priority: InferencePriority = 0, contravariant = false) {
             let symbolOrTypeStack: (Symbol | Type)[];
-            let visited: Map<number>;
+            let visited: Map<string, number>;
             let bivariant = false;
             let propagationType: Type;
             let inferencePriority = InferencePriority.MaxValue;
@@ -25568,7 +25568,7 @@ namespace ts {
         function checkApplicableSignatureForJsxOpeningLikeElement(
             node: JsxOpeningLikeElement,
             signature: Signature,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             checkMode: CheckMode,
             reportErrors: boolean,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
@@ -25668,7 +25668,7 @@ namespace ts {
             node: CallLikeExpression,
             args: readonly Expression[],
             signature: Signature,
-            relation: Map<RelationComparisonResult>,
+            relation: Map<string, RelationComparisonResult>,
             checkMode: CheckMode,
             reportErrors: boolean,
             containingMessageChain: (() => DiagnosticMessageChain | undefined) | undefined,
@@ -26184,7 +26184,7 @@ namespace ts {
 
             return getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray);
 
-            function chooseOverload(candidates: Signature[], relation: Map<RelationComparisonResult>, signatureHelpTrailingComma = false) {
+            function chooseOverload(candidates: Signature[], relation: Map<string, RelationComparisonResult>, signatureHelpTrailingComma = false) {
                 candidatesForArgumentError = undefined;
                 candidateForArgumentArityError = undefined;
                 candidateForTypeArgumentError = undefined;
@@ -31925,7 +31925,7 @@ namespace ts {
             return !(getMergedSymbol(typeParameter.symbol).isReferenced! & SymbolFlags.TypeParameter) && !isIdentifierThatStartsWithUnderscore(typeParameter.name);
         }
 
-        function addToGroup<K, V>(map: Map<[K, V[]]>, key: K, value: V, getKey: (key: K) => number | string): void {
+        function addToGroup<K, V>(map: Map<string, [K, V[]]>, key: K, value: V, getKey: (key: K) => number | string): void {
             const keyString = String(getKey(key));
             const group = map.get(keyString);
             if (group) {
@@ -36817,7 +36817,7 @@ namespace ts {
             // this variable and functions that use it are deliberately moved here from the outer scope
             // to avoid scope pollution
             const resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives();
-            let fileToDirective: Map<string>;
+            let fileToDirective: Map<string, string>;
             if (resolvedTypeReferenceDirectives) {
                 // populate reverse mapping: file path -> type reference directive that was resolved to this file
                 fileToDirective = createMap<string>();
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index a43e6244fcbf0..c6d310f3c68bb 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -1090,8 +1090,8 @@ namespace ts {
 
     /* @internal */
     export interface OptionsNameMap {
-        optionsNameMap: Map<CommandLineOption>;
-        shortOptionNames: Map<string>;
+        optionsNameMap: Map<string, CommandLineOption>;
+        shortOptionNames: Map<string, string>;
     }
 
     /*@internal*/
@@ -1469,7 +1469,7 @@ namespace ts {
         configFileName: string,
         optionsToExtend: CompilerOptions,
         host: ParseConfigFileHost,
-        extendedConfigCache?: Map<ExtendedConfigCacheEntry>,
+        extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>,
         watchOptionsToExtend?: WatchOptions,
         extraFileExtensions?: readonly FileExtensionInfo[],
     ): ParsedCommandLine | undefined {
@@ -1562,15 +1562,15 @@ namespace ts {
         optionTypeMismatchDiagnostic: Diagnostics.Watch_option_0_requires_a_value_of_type_1
     };
 
-    let commandLineCompilerOptionsMapCache: Map<CommandLineOption>;
+    let commandLineCompilerOptionsMapCache: Map<string, CommandLineOption>;
     function getCommandLineCompilerOptionsMap() {
         return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(optionDeclarations));
     }
-    let commandLineWatchOptionsMapCache: Map<CommandLineOption>;
+    let commandLineWatchOptionsMapCache: Map<string, CommandLineOption>;
     function getCommandLineWatchOptionsMap() {
         return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(optionsForWatch));
     }
-    let commandLineTypeAcquisitionMapCache: Map<CommandLineOption>;
+    let commandLineTypeAcquisitionMapCache: Map<string, CommandLineOption>;
     function getCommandLineTypeAcquisitionMap() {
         return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(typeAcquisitionDeclarations));
     }
@@ -1703,13 +1703,13 @@ namespace ts {
 
         return convertPropertyValueToJson(sourceFile.statements[0].expression, knownRootOptions);
 
-        function isRootOptionMap(knownOptions: Map<CommandLineOption> | undefined) {
+        function isRootOptionMap(knownOptions: Map<string, CommandLineOption> | undefined) {
             return knownRootOptions && (knownRootOptions as TsConfigOnlyOption).elementOptions === knownOptions;
         }
 
         function convertObjectLiteralExpressionToJson(
             node: ObjectLiteralExpression,
-            knownOptions: Map<CommandLineOption> | undefined,
+            knownOptions: Map<string, CommandLineOption> | undefined,
             extraKeyDiagnostics: DidYouMeanOptionsDiagnostics | undefined,
             parentOption: string | undefined
         ): any {
@@ -1964,7 +1964,7 @@ namespace ts {
         return config;
     }
 
-    function optionMapToObject(optionMap: Map<CompilerOptionsValue>): object {
+    function optionMapToObject(optionMap: Map<string, CompilerOptionsValue>): object {
         return {
             ...arrayFrom(optionMap.entries()).reduce((prev, cur) => ({ ...prev, [cur[0]]: cur[1] }), {}),
         };
@@ -1994,7 +1994,7 @@ namespace ts {
         return _ => true;
     }
 
-    function getCustomTypeMapOfCommandLineOption(optionDefinition: CommandLineOption): Map<string | number> | undefined {
+    function getCustomTypeMapOfCommandLineOption(optionDefinition: CommandLineOption): Map<string, string | number> | undefined {
         if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") {
             // this is of a type CommandLineOptionOfPrimitiveType
             return undefined;
@@ -2007,7 +2007,7 @@ namespace ts {
         }
     }
 
-    function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: Map<string | number>): string | undefined {
+    function getNameOfCompilerOptionValue(value: CompilerOptionsValue, customTypeMap: Map<string, string | number>): string | undefined {
         // There is a typeMap associated with this command-line option so use it to map value back to its name
         return forEachEntry(customTypeMap, (mapValue, key) => {
             if (mapValue === value) {
@@ -2019,7 +2019,7 @@ namespace ts {
     function serializeCompilerOptions(
         options: CompilerOptions,
         pathOptions?: { configFilePath: string, useCaseSensitiveFileNames: boolean }
-    ): Map<CompilerOptionsValue> {
+    ): Map<string, CompilerOptionsValue> {
         return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions);
     }
 
@@ -2031,7 +2031,7 @@ namespace ts {
         options: OptionsBase,
         { optionsNameMap }: OptionsNameMap,
         pathOptions?: { configFilePath: string, useCaseSensitiveFileNames: boolean }
-    ): Map<CompilerOptionsValue> {
+    ): Map<string, CompilerOptionsValue> {
         const result = createMap<CompilerOptionsValue>();
         const getCanonicalFileName = pathOptions && createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames);
 
@@ -2220,7 +2220,7 @@ namespace ts {
      * @param basePath A root directory to resolve relative path entries in the config
      *    file to. e.g. outDir
      */
-    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine {
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine {
         return parseJsonConfigFileContentWorker(json, /*sourceFile*/ undefined, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
     }
 
@@ -2231,7 +2231,7 @@ namespace ts {
      * @param basePath A root directory to resolve relative path entries in the config
      *    file to. e.g. outDir
      */
-    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine {
+    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine {
         return parseJsonConfigFileContentWorker(/*json*/ undefined, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache);
     }
 
@@ -2271,7 +2271,7 @@ namespace ts {
         configFileName?: string,
         resolutionStack: Path[] = [],
         extraFileExtensions: readonly FileExtensionInfo[] = [],
-        extendedConfigCache?: Map<ExtendedConfigCacheEntry>
+        extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>
     ): ParsedCommandLine {
         Debug.assert((json === undefined && sourceFile !== undefined) || (json !== undefined && sourceFile === undefined));
         const errors: Diagnostic[] = [];
@@ -2456,7 +2456,7 @@ namespace ts {
         configFileName: string | undefined,
         resolutionStack: string[],
         errors: Push<Diagnostic>,
-        extendedConfigCache?: Map<ExtendedConfigCacheEntry>
+        extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>
     ): ParsedTsconfig {
         basePath = normalizeSlashes(basePath);
         const resolvedPath = getNormalizedAbsolutePath(configFileName || "", basePath);
@@ -2645,7 +2645,7 @@ namespace ts {
         basePath: string,
         resolutionStack: string[],
         errors: Push<Diagnostic>,
-        extendedConfigCache?: Map<ExtendedConfigCacheEntry>
+        extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>
     ): ParsedTsconfig | undefined {
         const path = host.useCaseSensitiveFileNames ? extendedConfigPath : toFileNameLowerCase(extendedConfigPath);
         let value: ExtendedConfigCacheEntry | undefined;
@@ -2750,11 +2750,11 @@ namespace ts {
         return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, /*defaultOptions*/ undefined, watchOptionsDidYouMeanDiagnostics, errors);
     }
 
-    function convertOptionsFromJson(optionsNameMap: Map<CommandLineOption>, jsonOptions: any, basePath: string,
+    function convertOptionsFromJson(optionsNameMap: Map<string, CommandLineOption>, jsonOptions: any, basePath: string,
         defaultOptions: undefined, diagnostics: DidYouMeanOptionsDiagnostics, errors: Push<Diagnostic>): WatchOptions | undefined;
-    function convertOptionsFromJson(optionsNameMap: Map<CommandLineOption>, jsonOptions: any, basePath: string,
+    function convertOptionsFromJson(optionsNameMap: Map<string, CommandLineOption>, jsonOptions: any, basePath: string,
         defaultOptions: CompilerOptions | TypeAcquisition, diagnostics: DidYouMeanOptionsDiagnostics, errors: Push<Diagnostic>): CompilerOptions | TypeAcquisition;
-    function convertOptionsFromJson(optionsNameMap: Map<CommandLineOption>, jsonOptions: any, basePath: string,
+    function convertOptionsFromJson(optionsNameMap: Map<string, CommandLineOption>, jsonOptions: any, basePath: string,
         defaultOptions: CompilerOptions | TypeAcquisition | WatchOptions | undefined, diagnostics: DidYouMeanOptionsDiagnostics, errors: Push<Diagnostic>) {
 
         if (!jsonOptions) {
@@ -3174,7 +3174,7 @@ namespace ts {
      * @param extensionPriority The priority of the extension.
      * @param context The expansion context.
      */
-    function hasFileWithHigherPriorityExtension(file: string, literalFiles: Map<string>, wildcardFiles: Map<string>, extensions: readonly string[], keyMapper: (value: string) => string) {
+    function hasFileWithHigherPriorityExtension(file: string, literalFiles: Map<string, string>, wildcardFiles: Map<string, string>, extensions: readonly string[], keyMapper: (value: string) => string) {
         const extensionPriority = getExtensionPriority(file, extensions);
         const adjustedExtensionPriority = adjustExtensionPriority(extensionPriority, extensions);
         for (let i = ExtensionPriority.Highest; i < adjustedExtensionPriority; i++) {
@@ -3196,7 +3196,7 @@ namespace ts {
      * @param extensionPriority The priority of the extension.
      * @param context The expansion context.
      */
-    function removeWildcardFilesWithLowerPriorityExtension(file: string, wildcardFiles: Map<string>, extensions: readonly string[], keyMapper: (value: string) => string) {
+    function removeWildcardFilesWithLowerPriorityExtension(file: string, wildcardFiles: Map<string, string>, extensions: readonly string[], keyMapper: (value: string) => string) {
         const extensionPriority = getExtensionPriority(file, extensions);
         const nextExtensionPriority = getNextLowestExtensionPriority(extensionPriority, extensions);
         for (let i = nextExtensionPriority; i < extensions.length; i++) {
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 092d95df86276..27976899cfe8c 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1,30 +1,54 @@
-
 /* @internal */
 namespace ts {
+    export const Map: MapConstructor = tryGetNativeMap() || (() => {
+        // NOTE: ts.createMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createMapShim === "function") {
+            return createMapShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
+    })();
+
+    export const Set: SetConstructor = tryGetNativeSet() || (() => {
+        // NOTE: ts.createSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createSetShim === "function") {
+            return createSetShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native Set implementation.");
+    })();
+
+    export const WeakMap: WeakMapConstructor = tryGetNativeWeakMap() || (() => {
+        // NOTE: ts.createWeakMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createWeakMapShim === "function") {
+            return createWeakMapShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native WeakMap implementation.");
+    })();
+
+    export const WeakSet: WeakSetConstructor = tryGetNativeWeakSet() || (() => {
+        // NOTE: ts.createWeakSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        if (typeof createWeakSetShim === "function") {
+            return createWeakSetShim();
+        }
+        throw new Error("TypeScript requires an environment that provides a compatible native WeakSet implementation.");
+    })();
 
     export const emptyArray: never[] = [] as never[];
 
     /** Create a new map. */
-    export function createMap<T>(): Map<T>;
-    export function createMap<K, V>(): ESMap<K, V>;
-    export function createMap<K, V>(): ESMap<K, V> {
+    export function createMap<T>(): Map<string, T>;
+    export function createMap<K, V>(): Map<K, V>;
+    export function createMap<K, V>(): Map<K, V> {
         return new Map<K, V>();
     }
 
     /** Create a new map from an array of entries. */
-    export function createMapFromEntries<T>(entries: readonly [string, T][]): Map<T>;
-    export function createMapFromEntries<K, V>(entries: readonly [K, V][]): ESMap<K, V>;
-    export function createMapFromEntries<K, V>(entries: readonly [K, V][]): ESMap<K, V> {
-        const map = createMap<K, V>();
-        for (const [key, value] of entries) {
-            map.set(key, value);
-        }
-        return map;
+    export function createMapFromEntries<K, V>(entries: readonly [K, V][]): Map<K, V> {
+        return new Map(entries);
     }
 
     /** Create a new map from a template object is provided, the map will copy entries from it. */
-    export function createMapFromTemplate<T>(template: MapLike<T>): Map<T> {
-        const map: Map<T> = new Map<string, T>();
+    export function createMapFromTemplate<T>(template: MapLike<T>): Map<string, T> {
+        const map: Map<string, T> = new Map<string, T>();
 
         // Copies keys/values from template. Note that for..in will not throw if
         // template is undefined, and instead will just exit the loop.
@@ -42,11 +66,7 @@ namespace ts {
     }
 
     export function createSetFromValues<T>(values: readonly T[]): Set<T> {
-        const set = createSet<T>();
-        for (const value of values) {
-            set.add(value);
-        }
-        return set;
+        return new Set(values);
     }
 
     export function length(array: readonly any[] | undefined): number {
@@ -136,9 +156,9 @@ namespace ts {
         };
     }
 
-    export function zipToMap<T>(keys: readonly string[], values: readonly T[]): Map<T> {
+    export function zipToMap<K, V>(keys: readonly K[], values: readonly V[]): Map<K, V> {
         Debug.assert(keys.length === values.length);
-        const map = createMap<T>();
+        const map = createMap<K, V>();
         for (let i = 0; i < keys.length; ++i) {
             map.set(keys[i], values[i]);
         }
@@ -530,14 +550,24 @@ namespace ts {
         };
     }
 
-    export function mapDefinedMap<T, U>(map: ReadonlyMap<T>, mapValue: (value: T, key: string) => U | undefined, mapKey: (key: string) => string = identity): Map<U> {
-        const result = createMap<U>();
+    export function mapDefinedEntries<K1, V1, K2, V2>(map: ReadonlyMap<K1, V1>, f: (key: K1, value: V1) => readonly [K2, V2] | undefined): Map<K2, V2>;
+    export function mapDefinedEntries<K1, V1, K2, V2>(map: ReadonlyMap<K1, V1> | undefined, f: (key: K1, value: V1) => readonly [K2 | undefined, V2 | undefined] | undefined): Map<K2, V2> | undefined;
+    export function mapDefinedEntries<K1, V1, K2, V2>(map: ReadonlyMap<K1, V1> | undefined, f: (key: K1, value: V1) => readonly [K2 | undefined, V2 | undefined] | undefined): Map<K2, V2> | undefined {
+        if (!map) {
+            return undefined;
+        }
+
+        const result = createMap<K2, V2>();
         map.forEach((value, key) => {
-            const mapped = mapValue(value, key);
-            if (mapped !== undefined) {
-                result.set(mapKey(key), mapped);
+            const entry = f(key, value);
+            if (entry !== undefined) {
+                const [newKey, newValue] = entry;
+                if (newKey !== undefined && newValue !== undefined) {
+                    result.set(newKey, newValue);
+                }
             }
         });
+
         return result;
     }
 
@@ -603,20 +633,21 @@ namespace ts {
         return result;
     }
 
-    export function mapEntries<T, U>(map: ReadonlyMap<T>, f: (key: string, value: T) => [string, U]): Map<U>;
-    export function mapEntries<T, U>(map: ReadonlyMap<T> | undefined, f: (key: string, value: T) => [string, U]): Map<U> | undefined;
-    export function mapEntries<T, U>(map: ReadonlyMap<T> | undefined, f: (key: string, value: T) => [string, U]): Map<U> | undefined {
+    export function mapEntries<K1, V1, K2, V2>(map: ReadonlyMap<K1, V1>, f: (key: K1, value: V1) => readonly [K2, V2]): Map<K2, V2>;
+    export function mapEntries<K1, V1, K2, V2>(map: ReadonlyMap<K1, V1> | undefined, f: (key: K1, value: V1) => readonly [K2, V2]): Map<K2, V2> | undefined;
+    export function mapEntries<K1, V1, K2, V2>(map: ReadonlyMap<K1, V1> | undefined, f: (key: K1, value: V1) => readonly [K2, V2]): Map<K2, V2> | undefined {
         if (!map) {
             return undefined;
         }
 
-        const result = createMap<U>();
+        const result = createMap<K2, V2>();
         map.forEach((value, key) => {
             const [newKey, newValue] = f(key, value);
             result.set(newKey, newValue);
         });
         return result;
     }
+
     export function some<T>(array: readonly T[] | undefined): array is readonly T[];
     export function some<T>(array: readonly T[] | undefined, predicate: (value: T) => boolean): boolean;
     export function some<T>(array: readonly T[] | undefined, predicate?: (value: T) => boolean): boolean {
@@ -1276,10 +1307,12 @@ namespace ts {
      * the same key with the given 'makeKey' function, then the element with the higher
      * index in the array will be the one associated with the produced key.
      */
-    export function arrayToMap<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<T>;
-    export function arrayToMap<T, U>(array: readonly T[], makeKey: (value: T) => string | undefined, makeValue: (value: T) => U): Map<U>;
-    export function arrayToMap<T, U>(array: readonly T[], makeKey: (value: T) => string | undefined, makeValue: (value: T) => T | U = identity): Map<T | U> {
-        const result = createMap<T | U>();
+    export function arrayToMap<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<string, T>;
+    export function arrayToMap<T, U>(array: readonly T[], makeKey: (value: T) => string | undefined, makeValue: (value: T) => U): Map<string, U>;
+    export function arrayToMap<K, V>(array: readonly V[], makeKey: (value: V) => K | undefined): Map<K, V>;
+    export function arrayToMap<K, V1, V2>(array: readonly V1[], makeKey: (value: V1) => K | undefined, makeValue: (value: V1) => V2): Map<K, V2>;
+    export function arrayToMap<K, V1, V2>(array: readonly V1[], makeKey: (value: V1) => K | undefined, makeValue: (value: V1) => V1 | V2 = identity): Map<K, V1 | V2> {
+        const result = createMap<K, V1 | V2>();
         for (const value of array) {
             const key = makeKey(value);
             if (key !== undefined) result.set(key, makeValue(value));
@@ -1297,10 +1330,10 @@ namespace ts {
         return result;
     }
 
-    export function arrayToMultiMap<T>(values: readonly T[], makeKey: (value: T) => string): MultiMap<T>;
-    export function arrayToMultiMap<T, U>(values: readonly T[], makeKey: (value: T) => string, makeValue: (value: T) => U): MultiMap<U>;
-    export function arrayToMultiMap<T, U>(values: readonly T[], makeKey: (value: T) => string, makeValue: (value: T) => T | U = identity): MultiMap<T | U> {
-        const result = createMultiMap<T | U>();
+    export function arrayToMultiMap<K, V>(values: readonly V[], makeKey: (value: V) => K): MultiMap<K, V>;
+    export function arrayToMultiMap<K, V, U>(values: readonly V[], makeKey: (value: V) => K, makeValue: (value: V) => U): MultiMap<K, U>;
+    export function arrayToMultiMap<K, V, U>(values: readonly V[], makeKey: (value: V) => K, makeValue: (value: V) => V | U = identity): MultiMap<K, V | U> {
+        const result = createMultiMap<K, V | U>();
         for (const value of values) {
             result.add(makeKey(value), makeValue(value));
         }
@@ -1357,35 +1390,29 @@ namespace ts {
         return fn ? fn.bind(obj) : undefined;
     }
 
-    export function mapMap<T, U>(map: Map<T>, f: (t: T, key: string) => [string, U]): Map<U>;
-    export function mapMap<T, U>(map: UnderscoreEscapedMap<T>, f: (t: T, key: __String) => [string, U]): Map<U>;
-    export function mapMap<T, U>(map: Map<T> | UnderscoreEscapedMap<T>, f: ((t: T, key: string) => [string, U]) | ((t: T, key: __String) => [string, U])): Map<U> {
-        const result = createMap<U>();
-        map.forEach((t: T, key: string & __String) => result.set(...(f(t, key))));
-        return result;
-    }
-
-    export interface MultiMap<T> extends Map<T[]> {
+    export interface MultiMap<K, V> extends Map<K, V[]> {
         /**
          * Adds the value to an array of values associated with the key, and returns the array.
          * Creates the array if it does not already exist.
          */
-        add(key: string, value: T): T[];
+        add(key: K, value: V): V[];
         /**
          * Removes a value from an array of values associated with the key.
          * Does not preserve the order of those values.
          * Does nothing if `key` is not in `map`, or `value` is not in `map[key]`.
          */
-        remove(key: string, value: T): void;
+        remove(key: K, value: V): void;
     }
 
-    export function createMultiMap<T>(): MultiMap<T> {
-        const map = createMap<T[]>() as MultiMap<T>;
+    export function createMultiMap<V>(): MultiMap<string, V>;
+    export function createMultiMap<K, V>(): MultiMap<K, V>;
+    export function createMultiMap<K, V>(): MultiMap<K, V> {
+        const map = createMap<K, V[]>() as MultiMap<K, V>;
         map.add = multiMapAdd;
         map.remove = multiMapRemove;
         return map;
     }
-    function multiMapAdd<T>(this: MultiMap<T>, key: string, value: T) {
+    function multiMapAdd<K, V>(this: MultiMap<K, V>, key: K, value: V) {
         let values = this.get(key);
         if (values) {
             values.push(value);
@@ -1395,7 +1422,7 @@ namespace ts {
         }
         return values;
     }
-    function multiMapRemove<T>(this: MultiMap<T>, key: string, value: T) {
+    function multiMapRemove<K, V>(this: MultiMap<K, V>, key: K, value: V) {
         const values = this.get(key);
         if (values) {
             unorderedRemoveItem(values, value);
@@ -1420,7 +1447,7 @@ namespace ts {
     }
 
     export function createUnderscoreEscapedMultiMap<T>(): UnderscoreEscapedMultiMap<T> {
-        return createMultiMap<T>() as UnderscoreEscapedMultiMap<T>;
+        return createMultiMap() as UnderscoreEscapedMultiMap<T>;
     }
 
     /**
diff --git a/src/compiler/corePublic.ts b/src/compiler/corePublic.ts
index 3d0b77fe2dc30..a9869a82e7693 100644
--- a/src/compiler/corePublic.ts
+++ b/src/compiler/corePublic.ts
@@ -23,35 +23,27 @@ namespace ts {
     }
 
     /** ES6 Map interface, only read methods included. */
-    export interface ReadonlyESMap<K, V> {
+    export interface ReadonlyMap<K, V> {
+        readonly size: number;
         get(key: K): V | undefined;
         has(key: K): boolean;
-        forEach(action: (value: V, key: K) => void): void;
-        readonly size: number;
         keys(): Iterator<K>;
         values(): Iterator<V>;
         entries(): Iterator<[K, V]>;
+        forEach(action: (value: V, key: K) => void): void;
     }
 
     /** ES6 Map interface. */
-    export interface ESMap<K, V> extends ReadonlyESMap<K, V> {
+    export interface Map<K, V> extends ReadonlyMap<K, V> {
         set(key: K, value: V): this;
         delete(key: K): boolean;
         clear(): void;
     }
 
-    /** ES6 Map interface, only read methods included. */
-    export interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
-    }
-
-    /** ES6 Map interface. */
-    export interface Map<T> extends ESMap<string, T>, ReadonlyMap<T> {
-    }
-
     /* @internal */
     export interface MapConstructor {
         // eslint-disable-next-line @typescript-eslint/prefer-function-type
-        new <K, V>(): ESMap<K, V>;
+        new <K, V>(iterable?: readonly (readonly [K, V])[] | ReadonlyMap<K, V>): Map<K, V>;
     }
 
     export interface ReadonlySet<T> {
@@ -72,7 +64,7 @@ namespace ts {
     /* @internal */
     export interface SetConstructor {
         // eslint-disable-next-line @typescript-eslint/prefer-function-type
-        new <T>(): Set<T>;
+        new <T>(iterable?: readonly T[] | ReadonlySet<T>): Set<T>;
     }
 
     export interface WeakMap<K extends object, V> {
@@ -133,13 +125,13 @@ namespace ts {
         export function tryGetNativeMap(): MapConstructor | undefined {
             // Internet Explorer's Map doesn't support iteration, so don't use it.
             // eslint-disable-next-line no-in-operator
-            return typeof Map !== "undefined" && "entries" in Map.prototype ? Map : undefined;
+            return typeof Map !== "undefined" && "entries" in Map.prototype && new Map([[0, 0]]).size === 1 ? Map : undefined;
         }
 
         export function tryGetNativeSet(): SetConstructor | undefined {
             // Internet Explorer's Set doesn't support iteration, so don't use it.
             // eslint-disable-next-line no-in-operator
-            return typeof Set !== "undefined" && "entries" in Set.prototype ? Set : undefined;
+            return typeof Set !== "undefined" && "entries" in Set.prototype && new Set([0]).size === 1 ? Set : undefined;
         }
 
         export function tryGetNativeWeakMap(): WeakMapConstructor | undefined {
@@ -182,36 +174,4 @@ namespace ts {
     export function tryGetNativeWeakSet() {
         return NativeCollections.tryGetNativeWeakSet();
     }
-
-    export const Map: MapConstructor = tryGetNativeMap() || (() => {
-        // NOTE: ts.createMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createMapShim === "function") {
-            return createMapShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
-    })();
-
-    export const Set: SetConstructor = tryGetNativeSet() || (() => {
-        // NOTE: ts.createSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createSetShim === "function") {
-            return createSetShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native Set implementation.");
-    })();
-
-    export const WeakMap: WeakMapConstructor = tryGetNativeWeakMap() || (() => {
-        // NOTE: ts.createWeakMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createWeakMapShim === "function") {
-            return createWeakMapShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native WeakMap implementation.");
-    })();
-
-    export const WeakSet: WeakSetConstructor = tryGetNativeWeakSet() || (() => {
-        // NOTE: ts.createWeakSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createWeakSetShim === "function") {
-            return createWeakSetShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native WeakSet implementation.");
-    })();
 }
\ No newline at end of file
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index c9829f914fbc2..1243440e45810 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -839,11 +839,11 @@ namespace ts {
         let currentSourceFile: SourceFile | undefined;
         let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
         let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
-        let generatedNames: Map<true>; // Set of names generated by the NameGenerator.
+        let generatedNames: Map<string, true>; // Set of names generated by the NameGenerator.
         let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.
         let tempFlags: TempFlags; // TempFlags for the current name generation scope.
-        let reservedNamesStack: Map<true>[]; // Stack of TempFlags reserved in enclosing name generation scopes.
-        let reservedNames: Map<true>; // TempFlags to reserve in nested name generation scopes.
+        let reservedNamesStack: Map<string, true>[]; // Stack of TempFlags reserved in enclosing name generation scopes.
+        let reservedNames: Map<string, true>; // TempFlags to reserve in nested name generation scopes.
         let preserveSourceNewlines = printerOptions.preserveSourceNewlines; // Can be overridden inside nodes with the `IgnoreSourceNewlines` emit flag.
 
         let writer: EmitTextWriter;
@@ -3718,7 +3718,7 @@ namespace ts {
          * Emits any prologue directives at the start of a Statement list, returning the
          * number of prologue directives written to the output.
          */
-        function emitPrologueDirectives(statements: readonly Node[], sourceFile?: SourceFile, seenPrologueDirectives?: Map<true>, recordBundleFileSection?: true): number {
+        function emitPrologueDirectives(statements: readonly Node[], sourceFile?: SourceFile, seenPrologueDirectives?: Map<string, true>, recordBundleFileSection?: true): number {
             let needsToSetSourceFile = !!sourceFile;
             for (let i = 0; i < statements.length; i++) {
                 const statement = statements[i];
@@ -3747,7 +3747,7 @@ namespace ts {
             return statements.length;
         }
 
-        function emitUnparsedPrologues(prologues: readonly UnparsedPrologue[], seenPrologueDirectives: Map<true>) {
+        function emitUnparsedPrologues(prologues: readonly UnparsedPrologue[], seenPrologueDirectives: Map<string, true>) {
             for (const prologue of prologues) {
                 if (!seenPrologueDirectives.has(prologue.data)) {
                     writeLine();
diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts
index 9a76e759a2671..e59c06f151647 100644
--- a/src/compiler/factory/emitHelpers.ts
+++ b/src/compiler/factory/emitHelpers.ts
@@ -841,7 +841,7 @@ namespace ts {
             };`
     };
 
-    let allUnscopedEmitHelpers: ReadonlyMap<UnscopedEmitHelper> | undefined;
+    let allUnscopedEmitHelpers: ReadonlyMap<string, UnscopedEmitHelper> | undefined;
 
     export function getAllUnscopedEmitHelpers() {
         return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = arrayToMap([
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
index 82e39ecfad460..61f6ccd8332b7 100644
--- a/src/compiler/moduleNameResolver.ts
+++ b/src/compiler/moduleNameResolver.ts
@@ -442,8 +442,8 @@ namespace ts {
      * This assumes that any module id will have the same resolution for sibling files located in the same folder.
      */
     export interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
-        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<ResolvedModuleWithFailedLookupLocations>;
-        /*@internal*/ directoryToModuleNameMap: CacheWithRedirects<Map<ResolvedModuleWithFailedLookupLocations>>;
+        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<string, ResolvedModuleWithFailedLookupLocations>;
+        /*@internal*/ directoryToModuleNameMap: CacheWithRedirects<Map<string, ResolvedModuleWithFailedLookupLocations>>;
     }
 
     /**
@@ -472,18 +472,18 @@ namespace ts {
 
     /*@internal*/
     export interface CacheWithRedirects<T> {
-        ownMap: Map<T>;
-        redirectsMap: Map<Map<T>>;
-        getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<T>;
+        ownMap: Map<string, T>;
+        redirectsMap: Map<string, Map<string, T>>;
+        getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<string, T>;
         clear(): void;
         setOwnOptions(newOptions: CompilerOptions): void;
-        setOwnMap(newOwnMap: Map<T>): void;
+        setOwnMap(newOwnMap: Map<string, T>): void;
     }
 
     /*@internal*/
     export function createCacheWithRedirects<T>(options?: CompilerOptions): CacheWithRedirects<T> {
-        let ownMap: Map<T> = createMap();
-        const redirectsMap: Map<Map<T>> = createMap();
+        let ownMap: Map<string, T> = createMap();
+        const redirectsMap: Map<string, Map<string, T>> = createMap();
         return {
             ownMap,
             redirectsMap,
@@ -497,7 +497,7 @@ namespace ts {
             options = newOptions;
         }
 
-        function setOwnMap(newOwnMap: Map<T>) {
+        function setOwnMap(newOwnMap: Map<string, T>) {
             ownMap = newOwnMap;
         }
 
@@ -523,7 +523,7 @@ namespace ts {
 
     /*@internal*/
     export function createModuleResolutionCacheWithMaps(
-        directoryToModuleNameMap: CacheWithRedirects<Map<ResolvedModuleWithFailedLookupLocations>>,
+        directoryToModuleNameMap: CacheWithRedirects<Map<string, ResolvedModuleWithFailedLookupLocations>>,
         moduleNameToDirectoryMap: CacheWithRedirects<PerModuleNameCache>,
         currentDirectory: string,
         getCanonicalFileName: GetCanonicalFileName): ModuleResolutionCache {
@@ -532,7 +532,7 @@ namespace ts {
 
         function getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference) {
             const path = toPath(directoryName, currentDirectory, getCanonicalFileName);
-            return getOrCreateCache<Map<ResolvedModuleWithFailedLookupLocations>>(directoryToModuleNameMap, redirectedReference, path, createMap);
+            return getOrCreateCache<Map<string, ResolvedModuleWithFailedLookupLocations>>(directoryToModuleNameMap, redirectedReference, path, createMap);
         }
 
         function getOrCreateCacheForModuleName(nonRelativeModuleName: string, redirectedReference?: ResolvedProjectReference): PerModuleNameCache {
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index df8c34e12f880..ecff0dfa88bd1 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -749,13 +749,13 @@ namespace ts {
 
         let currentToken: SyntaxKind;
         let nodeCount: number;
-        let identifiers: Map<string>;
-        let privateIdentifiers: Map<string>;
+        let identifiers: Map<string, string>;
+        let privateIdentifiers: Map<string, string>;
         let identifierCount: number;
 
         let parsingContext: ParsingContext;
 
-        let notParenthesizedArrow: Map<true> | undefined;
+        let notParenthesizedArrow: Map<string, true> | undefined;
 
         // Flags that dictate what parsing context we're in.  For example:
         // Whether or not we are in strict parsing mode.  All that changes in strict parsing mode is
diff --git a/src/compiler/performance.ts b/src/compiler/performance.ts
index 4a7f5c99278b2..3da794c638b16 100644
--- a/src/compiler/performance.ts
+++ b/src/compiler/performance.ts
@@ -8,9 +8,9 @@ namespace ts.performance {
 
     let enabled = false;
     let profilerStart = 0;
-    let counts: Map<number>;
-    let marks: Map<number>;
-    let measures: Map<number>;
+    let counts: Map<string, number>;
+    let marks: Map<string, number>;
+    let measures: Map<string, number>;
 
     export interface Timer {
         enter(): void;
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 63873b9ac5d95..66741c6079e9b 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -126,7 +126,7 @@ namespace ts {
             }
         }
 
-        let outputFingerprints: Map<OutputFingerprint>;
+        let outputFingerprints: Map<string, OutputFingerprint>;
         function writeFileWorker(fileName: string, data: string, writeByteOrderMark: boolean) {
             if (!isWatchSet(options) || !system.createHash || !system.getModifiedTime) {
                 system.writeFile(fileName, data, writeByteOrderMark);
@@ -533,7 +533,7 @@ namespace ts {
     export const inferredTypesContainingFile = "__inferred type names__.ts";
 
     interface DiagnosticCache<T extends Diagnostic> {
-        perFile?: Map<readonly T[]>;
+        perFile?: Map<string, readonly T[]>;
         allDiagnostics?: readonly T[];
     }
 
@@ -702,14 +702,14 @@ namespace ts {
         let processingDefaultLibFiles: SourceFile[] | undefined;
         let processingOtherFiles: SourceFile[] | undefined;
         let files: SourceFile[];
-        let symlinks: ReadonlyMap<string> | undefined;
+        let symlinks: ReadonlyMap<string, string> | undefined;
         let commonSourceDirectory: string;
         let diagnosticsProducingTypeChecker: TypeChecker;
         let noDiagnosticsTypeChecker: TypeChecker;
         let classifiableNames: UnderscoreEscapedMap<true>;
         const ambientModuleNameToUnmodifiedFileName = createMap<string>();
         // Todo:: Use this to report why file was included in --extendedDiagnostics
-        let refFileMap: MultiMap<ts.RefFile> | undefined;
+        let refFileMap: MultiMap<string, ts.RefFile> | undefined;
 
         const cachedBindAndCheckDiagnosticsForFile: DiagnosticCache<Diagnostic> = {};
         const cachedDeclarationDiagnosticsForFile: DiagnosticCache<DiagnosticWithLocation> = {};
@@ -803,9 +803,9 @@ namespace ts {
 
         // A parallel array to projectReferences storing the results of reading in the referenced tsconfig files
         let resolvedProjectReferences: readonly (ResolvedProjectReference | undefined)[] | undefined;
-        let projectReferenceRedirects: Map<ResolvedProjectReference | false> | undefined;
-        let mapFromFileToProjectReferenceRedirects: Map<Path> | undefined;
-        let mapFromToProjectReferenceRedirectSource: Map<SourceOfProjectReferenceRedirect> | undefined;
+        let projectReferenceRedirects: Map<string, ResolvedProjectReference | false> | undefined;
+        let mapFromFileToProjectReferenceRedirects: Map<string, Path> | undefined;
+        let mapFromToProjectReferenceRedirectSource: Map<string, SourceOfProjectReferenceRedirect> | undefined;
 
         const useSourceOfProjectReferenceRedirect = !!host.useSourceOfProjectReferenceRedirect?.() &&
             !options.disableSourceOfProjectReferenceRedirect;
@@ -2892,7 +2892,7 @@ namespace ts {
         function checkSourceFilesBelongToPath(sourceFiles: readonly SourceFile[], rootDirectory: string): boolean {
             let allFilesBelongToPath = true;
             const absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-            let rootPaths: Map<true> | undefined;
+            let rootPaths: Map<string, true> | undefined;
 
             for (const sourceFile of sourceFiles) {
                 if (!sourceFile.isDeclarationFile) {
@@ -3214,7 +3214,7 @@ namespace ts {
             }
 
             // Verify that all the emit files are unique and don't overwrite input files
-            function verifyEmitFilePath(emitFileName: string | undefined, emitFilesSeen: Map<true>) {
+            function verifyEmitFilePath(emitFileName: string | undefined, emitFilesSeen: Map<string, true>) {
                 if (emitFileName) {
                     const emitFilePath = toPath(emitFileName);
                     // Report error if the output overwrites input file
@@ -3262,7 +3262,7 @@ namespace ts {
             return createFileDiagnostic(refFile, pos, end - pos, message, ...args);
         }
 
-        function addProgramDiagnosticAtRefPath(file: SourceFile, rootPaths: Map<true>, message: DiagnosticMessage, ...args: (string | number | undefined)[]) {
+        function addProgramDiagnosticAtRefPath(file: SourceFile, rootPaths: Map<string, true>, message: DiagnosticMessage, ...args: (string | number | undefined)[]) {
             const refPaths = refFileMap && refFileMap.get(file.path);
             const refPathToReportErrorOn = forEach(refPaths, refPath => rootPaths.has(refPath.file) ? refPath : undefined) ||
                 elementAt(refPaths, 0);
@@ -3455,7 +3455,7 @@ namespace ts {
             return comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === Comparison.EqualTo;
         }
 
-        function getProbableSymlinks(): ReadonlyMap<string> {
+        function getProbableSymlinks(): ReadonlyMap<string, string> {
             if (host.getSymlinks) {
                 return host.getSymlinks();
             }
@@ -3481,9 +3481,9 @@ namespace ts {
     }
 
     function updateHostForUseSourceOfProjectReferenceRedirect(host: HostForUseSourceOfProjectReferenceRedirect) {
-        let mapOfDeclarationDirectories: Map<true> | undefined;
-        let symlinkedDirectories: Map<SymlinkedDirectory | false> | undefined;
-        let symlinkedFiles: Map<string> | undefined;
+        let mapOfDeclarationDirectories: Map<string, true> | undefined;
+        let symlinkedDirectories: Map<string, SymlinkedDirectory | false> | undefined;
+        let symlinkedFiles: Map<string, string> | undefined;
 
         const originalFileExists = host.compilerHost.fileExists;
         const originalDirectoryExists = host.compilerHost.directoryExists;
diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts
index 547a8f4c9d243..d97cc49c48b69 100644
--- a/src/compiler/resolutionCache.ts
+++ b/src/compiler/resolutionCache.ts
@@ -13,7 +13,7 @@ namespace ts {
         invalidateResolutionOfFile(filePath: Path): void;
         removeResolutionsOfFile(filePath: Path): void;
         removeResolutionsFromProjectReferenceRedirects(filePath: Path): void;
-        setFilesWithInvalidatedNonRelativeUnresolvedImports(filesWithUnresolvedImports: Map<readonly string[]>): void;
+        setFilesWithInvalidatedNonRelativeUnresolvedImports(filesWithUnresolvedImports: Map<string, readonly string[]>): void;
         createHasInvalidatedResolution(forceAllFilesAsInvalidated?: boolean): HasInvalidatedResolution;
         hasChangedAutomaticTypeDirectiveNames(): boolean;
 
@@ -143,8 +143,8 @@ namespace ts {
 
     export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootDirForResolution: string | undefined, logChangesWhenResolvingModule: boolean): ResolutionCache {
         let filesWithChangedSetOfUnresolvedImports: Path[] | undefined;
-        let filesWithInvalidatedResolutions: Map<true> | undefined;
-        let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<readonly string[]> | undefined;
+        let filesWithInvalidatedResolutions: Map<string, true> | undefined;
+        let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<string, readonly string[]> | undefined;
         const nonRelativeExternalModuleResolutions = createMultiMap<ResolutionWithFailedLookupLocations>();
 
         const resolutionsWithFailedLookups: ResolutionWithFailedLookupLocations[] = [];
@@ -161,8 +161,8 @@ namespace ts {
         // The resolvedModuleNames and resolvedTypeReferenceDirectives are the cache of resolutions per file.
         // The key in the map is source file's path.
         // The values are Map of resolutions with key being name lookedup.
-        const resolvedModuleNames = createMap<Map<CachedResolvedModuleWithFailedLookupLocations>>();
-        const perDirectoryResolvedModuleNames: CacheWithRedirects<Map<CachedResolvedModuleWithFailedLookupLocations>> = createCacheWithRedirects();
+        const resolvedModuleNames = createMap<Map<string, CachedResolvedModuleWithFailedLookupLocations>>();
+        const perDirectoryResolvedModuleNames: CacheWithRedirects<Map<string, CachedResolvedModuleWithFailedLookupLocations>> = createCacheWithRedirects();
         const nonRelativeModuleNameCache: CacheWithRedirects<PerModuleNameCache> = createCacheWithRedirects();
         const moduleResolutionCache = createModuleResolutionCacheWithMaps(
             perDirectoryResolvedModuleNames,
@@ -171,8 +171,8 @@ namespace ts {
             resolutionHost.getCanonicalFileName
         );
 
-        const resolvedTypeReferenceDirectives = createMap<Map<CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
-        const perDirectoryResolvedTypeReferenceDirectives: CacheWithRedirects<Map<CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>> = createCacheWithRedirects();
+        const resolvedTypeReferenceDirectives = createMap<Map<string, CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
+        const perDirectoryResolvedTypeReferenceDirectives: CacheWithRedirects<Map<string, CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>> = createCacheWithRedirects();
 
         /**
          * These are the extensions that failed lookup files will have by default,
@@ -334,8 +334,8 @@ namespace ts {
             names: readonly string[];
             containingFile: string;
             redirectedReference: ResolvedProjectReference | undefined;
-            cache: Map<Map<T>>;
-            perDirectoryCacheWithRedirects: CacheWithRedirects<Map<T>>;
+            cache: Map<string, Map<string, T>>;
+            perDirectoryCacheWithRedirects: CacheWithRedirects<Map<string, T>>;
             loader: (name: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference) => T;
             getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;
             shouldRetryResolution: (t: T) => boolean;
@@ -684,7 +684,7 @@ namespace ts {
         }
 
         function removeResolutionsOfFileFromCache<T extends ResolutionWithFailedLookupLocations, R extends ResolutionWithResolvedFileName>(
-            cache: Map<Map<T>>,
+            cache: Map<string, Map<string, T>>,
             filePath: Path,
             getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>,
         ) {
@@ -741,7 +741,7 @@ namespace ts {
             }
         }
 
-        function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap: ReadonlyMap<readonly string[]>) {
+        function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap: ReadonlyMap<string, readonly string[]>) {
             Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined);
             filesWithInvalidatedNonRelativeUnresolvedImports = filesMap;
         }
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index b578db78ae1f5..ab2a37032ced2 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -330,7 +330,7 @@ namespace ts {
                 lookupInUnicodeMap(code, unicodeES3IdentifierPart);
     }
 
-    function makeReverseMap(source: Map<number>): string[] {
+    function makeReverseMap(source: Map<string, number>): string[] {
         const result: string[] = [];
         source.forEach((value, name) => {
             result[value] = name;
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index 5fae21601a388..8cac9cde667cf 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -16,7 +16,7 @@ namespace ts {
         let sourcesContent: (string | null)[] | undefined;
 
         const names: string[] = [];
-        let nameToNameIndexMap: Map<number> | undefined;
+        let nameToNameIndexMap: Map<string, number> | undefined;
         let mappings = "";
 
         // Last recorded and encoded mappings
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 725d2330d214a..0132af7223bda 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -538,7 +538,7 @@ namespace ts {
             };
         }
 
-        type InvokeMap = Map<string[] | true>;
+        type InvokeMap = Map<string, string[] | true>;
         function invokeCallbacks(dirPath: Path, fileName: string): void;
         function invokeCallbacks(dirPath: Path, invokeMap: InvokeMap, fileNames: string[] | undefined): void;
         function invokeCallbacks(dirPath: Path, fileNameOrInvokeMap: string | InvokeMap, fileNames?: string[]) {
diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
index ba4c01beb8ba8..d9a7c8e1f6fc9 100644
--- a/src/compiler/transformers/declarations.ts
+++ b/src/compiler/transformers/declarations.ts
@@ -58,9 +58,9 @@ namespace ts {
         let needsScopeFixMarker = false;
         let resultHasScopeMarker = false;
         let enclosingDeclaration: Node;
-        let necessaryTypeReferences: Map<true> | undefined;
+        let necessaryTypeReferences: Map<string, true> | undefined;
         let lateMarkedStatements: LateVisibilityPaintedStatement[] | undefined;
-        let lateStatementReplacementMap: Map<VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;
+        let lateStatementReplacementMap: Map<string, VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;
         let suppressNewDiagnosticContexts: boolean;
         let exportedModulesFromDeclarationEmit: Symbol[] | undefined;
 
@@ -81,8 +81,8 @@ namespace ts {
         let errorNameNode: DeclarationName | undefined;
 
         let currentSourceFile: SourceFile;
-        let refs: Map<SourceFile>;
-        let libs: Map<boolean>;
+        let refs: Map<string, SourceFile>;
+        let libs: Map<string, boolean>;
         let emittedImports: readonly AnyImportSyntax[] | undefined; // must be declared in container so it can be `undefined` while transformer's first pass
         const resolver = context.getEmitResolver();
         const options = context.getCompilerOptions();
@@ -402,7 +402,7 @@ namespace ts {
             }
         }
 
-        function collectReferences(sourceFile: SourceFile | UnparsedSource, ret: Map<SourceFile>) {
+        function collectReferences(sourceFile: SourceFile | UnparsedSource, ret: Map<string, SourceFile>) {
             if (noResolve || (!isUnparsedSource(sourceFile) && isSourceFileJS(sourceFile))) return ret;
             forEach(sourceFile.referencedFiles, f => {
                 const elem = host.getSourceFileFromReference(sourceFile, f);
@@ -413,7 +413,7 @@ namespace ts {
             return ret;
         }
 
-        function collectLibs(sourceFile: SourceFile | UnparsedSource, ret: Map<boolean>) {
+        function collectLibs(sourceFile: SourceFile | UnparsedSource, ret: Map<string, boolean>) {
             forEach(sourceFile.libReferenceDirectives, ref => {
                 const lib = host.getLibFileFromReference(ref);
                 if (lib) {
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index dc4078caa2433..f9d94f3ee5976 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -72,15 +72,15 @@ namespace ts {
          * set of labels that occurred inside the converted loop
          * used to determine if labeled jump can be emitted as is or it should be dispatched to calling code
          */
-        labels?: Map<boolean>;
+        labels?: Map<string, boolean>;
         /*
          * collection of labeled jumps that transfer control outside the converted loop.
          * maps store association 'label -> labelMarker' where
          * - label - value of label as it appear in code
          * - label marker - return value that should be interpreted by calling code as 'jump to <label>'
          */
-        labeledNonLocalBreaks?: Map<string>;
-        labeledNonLocalContinues?: Map<string>;
+        labeledNonLocalBreaks?: Map<string, string>;
+        labeledNonLocalContinues?: Map<string, string>;
 
         /*
          * set of non-labeled jumps that transfer control outside the converted loop
@@ -3291,7 +3291,7 @@ namespace ts {
             }
         }
 
-        function processLabeledJumps(table: Map<string>, isBreak: boolean, loopResultName: Identifier, outerLoop: ConvertedLoopState | undefined, caseClauses: CaseClause[]): void {
+        function processLabeledJumps(table: Map<string, string>, isBreak: boolean, loopResultName: Identifier, outerLoop: ConvertedLoopState | undefined, caseClauses: CaseClause[]): void {
             if (!table) {
                 return;
             }
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index c73037656a77c..7b0f8419b0b59 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.ts
@@ -244,7 +244,7 @@ namespace ts {
         const previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
 
-        let renamedCatchVariables: Map<boolean>;
+        let renamedCatchVariables: Map<string, boolean>;
         let renamedCatchVariableDeclarations: Identifier[];
 
         let inGeneratorFunctionBody: boolean;
diff --git a/src/compiler/transformers/module/esnextAnd2015.ts b/src/compiler/transformers/module/esnextAnd2015.ts
index 242143fb33968..1b87011064204 100644
--- a/src/compiler/transformers/module/esnextAnd2015.ts
+++ b/src/compiler/transformers/module/esnextAnd2015.ts
@@ -13,7 +13,7 @@ namespace ts {
         context.enableEmitNotification(SyntaxKind.SourceFile);
         context.enableSubstitution(SyntaxKind.Identifier);
 
-        let helperNameSubstitutions: Map<Identifier> | undefined;
+        let helperNameSubstitutions: Map<string, Identifier> | undefined;
         return chainBundle(context, transformSourceFile);
 
         function transformSourceFile(node: SourceFile) {
diff --git a/src/compiler/transformers/utilities.ts b/src/compiler/transformers/utilities.ts
index fd897848e767c..14a6c2601717a 100644
--- a/src/compiler/transformers/utilities.ts
+++ b/src/compiler/transformers/utilities.ts
@@ -8,7 +8,7 @@ namespace ts {
     export interface ExternalModuleInfo {
         externalImports: (ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration)[]; // imports of other external modules
         externalHelpersImportDeclaration: ImportDeclaration | undefined; // import of external helpers
-        exportSpecifiers: Map<ExportSpecifier[]>; // export specifiers by name
+        exportSpecifiers: Map<string, ExportSpecifier[]>; // export specifiers by name
         exportedBindings: Identifier[][]; // exported names of local declarations
         exportedNames: Identifier[] | undefined; // all exported names local to module
         exportEquals: ExportAssignment | undefined; // an export= declaration if one was present
@@ -217,7 +217,7 @@ namespace ts {
         }
     }
 
-    function collectExportedVariableInfo(decl: VariableDeclaration | BindingElement, uniqueExports: Map<boolean>, exportedNames: Identifier[] | undefined) {
+    function collectExportedVariableInfo(decl: VariableDeclaration | BindingElement, uniqueExports: Map<string, boolean>, exportedNames: Identifier[] | undefined) {
         if (isBindingPattern(decl.name)) {
             for (const element of decl.name.elements) {
                 if (!isOmittedExpression(element)) {
diff --git a/src/compiler/tsbuildPublic.ts b/src/compiler/tsbuildPublic.ts
index ac926215b2edc..fab6453ce73e3 100644
--- a/src/compiler/tsbuildPublic.ts
+++ b/src/compiler/tsbuildPublic.ts
@@ -51,17 +51,7 @@ namespace ts {
 
     /*@internal*/
     export type ResolvedConfigFilePath = ResolvedConfigFileName & Path;
-    interface FileMap<T, U extends Path = Path> extends Map<T> {
-        get(key: U): T | undefined;
-        has(key: U): boolean;
-        forEach(action: (value: T, key: U) => void): void;
-        readonly size: number;
-        keys(): Iterator<U>;
-        values(): Iterator<T>;
-        entries(): Iterator<[U, T]>;
-        set(key: U, value: T): this;
-        delete(key: U): boolean;
-        clear(): void;
+    interface FileMap<T, U extends Path = Path> extends Map<U, T> {
     }
     type ConfigFileMap<T> = FileMap<T, ResolvedConfigFilePath>;
     function createConfigFileMap<T>(): ConfigFileMap<T> {
@@ -78,8 +68,8 @@ namespace ts {
         return existingValue || newValue!;
     }
 
-    function getOrCreateValueMapFromConfigFileMap<T>(configFileMap: ConfigFileMap<Map<T>>, resolved: ResolvedConfigFilePath): Map<T> {
-        return getOrCreateValueFromConfigFileMap<Map<T>>(configFileMap, resolved, createMap);
+    function getOrCreateValueMapFromConfigFileMap<T>(configFileMap: ConfigFileMap<Map<string, T>>, resolved: ResolvedConfigFilePath): Map<string, T> {
+        return getOrCreateValueFromConfigFileMap<Map<string, T>>(configFileMap, resolved, createMap);
     }
 
     function newer(date1: Date, date2: Date): Date {
@@ -238,12 +228,12 @@ namespace ts {
         readonly rootNames: readonly string[];
         readonly baseWatchOptions: WatchOptions | undefined;
 
-        readonly resolvedConfigFilePaths: Map<ResolvedConfigFilePath>;
+        readonly resolvedConfigFilePaths: Map<string, ResolvedConfigFilePath>;
         readonly configFileCache: ConfigFileMap<ConfigFileCacheEntry>;
         /** Map from config file name to up-to-date status */
         readonly projectStatus: ConfigFileMap<UpToDateStatus>;
         readonly buildInfoChecked: ConfigFileMap<true>;
-        readonly extendedConfigCache: Map<ExtendedConfigCacheEntry>;
+        readonly extendedConfigCache: Map<string, ExtendedConfigCacheEntry>;
 
         readonly builderPrograms: ConfigFileMap<T>;
         readonly diagnostics: ConfigFileMap<readonly Diagnostic[]>;
@@ -265,8 +255,8 @@ namespace ts {
 
         // Watch state
         readonly watch: boolean;
-        readonly allWatchedWildcardDirectories: ConfigFileMap<Map<WildcardDirectoryWatcher>>;
-        readonly allWatchedInputFiles: ConfigFileMap<Map<FileWatcher>>;
+        readonly allWatchedWildcardDirectories: ConfigFileMap<Map<string, WildcardDirectoryWatcher>>;
+        readonly allWatchedInputFiles: ConfigFileMap<Map<string, FileWatcher>>;
         readonly allWatchedConfigFiles: ConfigFileMap<FileWatcher>;
 
         timerToBuildInvalidatedProject: any;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index d6c06ebec5ff0..c2a0afd9346c9 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3397,7 +3397,7 @@ namespace ts {
 
         // this map is used by transpiler to supply alternative names for dependencies (i.e. in case of bundling)
         /* @internal */
-        renamedDependencies?: ReadonlyMap<string>;
+        renamedDependencies?: ReadonlyMap<string, string>;
 
         /**
          * lib.d.ts should have a reference comment like
@@ -3423,7 +3423,7 @@ namespace ts {
         // JS identifier-declarations that are intended to merge with globals
         /* @internal */ jsGlobalAugmentations?: SymbolTable;
 
-        /* @internal */ identifiers: Map<string>; // Map from a string to an interned string
+        /* @internal */ identifiers: Map<string, string>; // Map from a string to an interned string
         /* @internal */ nodeCount: number;
         /* @internal */ identifierCount: number;
         /* @internal */ symbolCount: number;
@@ -3451,8 +3451,8 @@ namespace ts {
         // Stores a mapping 'external module reference text' -> 'resolved file name' | undefined
         // It is used to resolve module names in the checker.
         // Content of this field should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead
-        /* @internal */ resolvedModules?: Map<ResolvedModuleFull | undefined>;
-        /* @internal */ resolvedTypeReferenceDirectiveNames: Map<ResolvedTypeReferenceDirective | undefined>;
+        /* @internal */ resolvedModules?: Map<string, ResolvedModuleFull | undefined>;
+        /* @internal */ resolvedTypeReferenceDirectiveNames: Map<string, ResolvedTypeReferenceDirective | undefined>;
         /* @internal */ imports: readonly StringLiteralLike[];
         // Identifier only if `declare global`
         /* @internal */ moduleAugmentations: readonly (StringLiteral | Identifier)[];
@@ -3682,9 +3682,9 @@ namespace ts {
         /* @internal */
         getMissingFilePaths(): readonly Path[];
         /* @internal */
-        getRefFileMap(): MultiMap<RefFile> | undefined;
+        getRefFileMap(): MultiMap<string, RefFile> | undefined;
         /* @internal */
-        getFilesByNameMap(): Map<SourceFile | false | undefined>;
+        getFilesByNameMap(): Map<string, SourceFile | false | undefined>;
 
         /**
          * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
@@ -3734,7 +3734,7 @@ namespace ts {
         getRelationCacheSizes(): { assignable: number, identity: number, subtype: number, strictSubtype: number };
 
         /* @internal */ getFileProcessingDiagnostics(): DiagnosticCollection;
-        /* @internal */ getResolvedTypeReferenceDirectives(): Map<ResolvedTypeReferenceDirective | undefined>;
+        /* @internal */ getResolvedTypeReferenceDirectives(): Map<string, ResolvedTypeReferenceDirective | undefined>;
         isSourceFileFromExternalLibrary(file: SourceFile): boolean;
         isSourceFileDefaultLibrary(file: SourceFile): boolean;
 
@@ -3745,9 +3745,9 @@ namespace ts {
         /* @internal */ getLibFileFromReference(ref: FileReference): SourceFile | undefined;
 
         /** Given a source file, get the name of the package it was imported from. */
-        /* @internal */ sourceFileToPackageName: Map<string>;
+        /* @internal */ sourceFileToPackageName: Map<string, string>;
         /** Set of all source files that some other source file redirects to. */
-        /* @internal */ redirectTargetsMap: MultiMap<string>;
+        /* @internal */ redirectTargetsMap: MultiMap<string, string>;
         /** Is the file emitted file */
         /* @internal */ isEmittedFile(file: string): boolean;
 
@@ -3762,7 +3762,7 @@ namespace ts {
         /*@internal*/ isSourceOfProjectReferenceRedirect(fileName: string): boolean;
         /*@internal*/ getProgramBuildInfo?(): ProgramBuildInfo | undefined;
         /*@internal*/ emitBuildInfo(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult;
-        /*@internal*/ getProbableSymlinks(): ReadonlyMap<string>;
+        /*@internal*/ getProbableSymlinks(): ReadonlyMap<string, string>;
         /**
          * This implementation handles file exists to be true if file is source of project reference redirect when program is created using useSourceOfProjectReferenceRedirect
          */
@@ -3774,7 +3774,7 @@ namespace ts {
     }
 
     /* @internal */
-    export type RedirectTargetsMap = ReadonlyMap<readonly string[]>;
+    export type RedirectTargetsMap = ReadonlyMap<string, readonly string[]>;
 
     export interface ResolvedProjectReference {
         commandLine: ParsedCommandLine;
@@ -3870,7 +3870,7 @@ namespace ts {
 
         getSourceFiles(): readonly SourceFile[];
         getSourceFile(fileName: string): SourceFile | undefined;
-        getResolvedTypeReferenceDirectives(): ReadonlyMap<ResolvedTypeReferenceDirective | undefined>;
+        getResolvedTypeReferenceDirectives(): ReadonlyMap<string, ResolvedTypeReferenceDirective | undefined>;
         getProjectReferenceRedirect(fileName: string): string | undefined;
         isSourceOfProjectReferenceRedirect(fileName: string): boolean;
 
@@ -4590,7 +4590,7 @@ namespace ts {
         /* @internal */ isReferenced?: SymbolFlags; // True if the symbol is referenced elsewhere. Keeps track of the meaning of a reference in case a symbol is both a type parameter and parameter.
         /* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
         /* @internal */ isAssigned?: boolean;   // True if the symbol is a parameter with assignments
-        /* @internal */ assignmentDeclarationMembers?: Map<Declaration>; // detected late-bound assignment declarations associated with the symbol
+        /* @internal */ assignmentDeclarationMembers?: Map<string, Declaration>; // detected late-bound assignment declarations associated with the symbol
     }
 
     /* @internal */
@@ -4603,8 +4603,8 @@ namespace ts {
         declaredType?: Type;                        // Type of class, interface, enum, type alias, or type parameter
         typeParameters?: TypeParameter[];           // Type parameters of type alias (undefined if non-generic)
         outerTypeParameters?: TypeParameter[];      // Outer type parameters of anonymous object type
-        instantiations?: Map<Type>;                 // Instantiations of generic type alias (undefined if non-generic)
-        inferredClassSymbol?: Map<TransientSymbol>; // Symbol of an inferred ES5 constructor function
+        instantiations?: Map<string, Type>;                 // Instantiations of generic type alias (undefined if non-generic)
+        inferredClassSymbol?: Map<string, TransientSymbol>; // Symbol of an inferred ES5 constructor function
         mapper?: TypeMapper;                        // Type mapper for instantiation alias
         referenced?: boolean;                       // True if alias symbol has been referenced as a value that can be emitted
         constEnumReferenced?: boolean;              // True if alias symbol resolves to a const enum and is referenced as a value ('referenced' will be false)
@@ -4623,9 +4623,9 @@ namespace ts {
         enumKind?: EnumKind;                        // Enum declaration classification
         originatingImport?: ImportDeclaration | ImportCall; // Import declaration which produced the symbol, present if the symbol is marked as uncallable but had call signatures in `resolveESModuleSymbol`
         lateSymbol?: Symbol;                // Late-bound symbol for a computed property
-        specifierCache?: Map<string>;     // For symbols corresponding to external modules, a cache of incoming path -> module specifier name mappings
+        specifierCache?: Map<string, string>;     // For symbols corresponding to external modules, a cache of incoming path -> module specifier name mappings
         extendedContainers?: Symbol[];      // Containers (other than the parent) which this symbol is aliased in
-        extendedContainersByFile?: Map<Symbol[]>;      // Containers (other than the parent) which this symbol is aliased in
+        extendedContainersByFile?: Map<string, Symbol[]>;      // Containers (other than the parent) which this symbol is aliased in
         variances?: VarianceFlags[];             // Alias symbol type argument variance cache
         deferralConstituents?: Type[];      // Calculated list of constituents for a deferred type
         deferralParent?: Type;              // Source union/intersection of a deferred type
@@ -4717,21 +4717,11 @@ namespace ts {
     export type __String = (string & { __escapedIdentifier: void }) | (void & { __escapedIdentifier: void }) | InternalSymbolName;
 
     /** ReadonlyMap where keys are `__String`s. */
-    export interface ReadonlyUnderscoreEscapedMap<T> {
-        get(key: __String): T | undefined;
-        has(key: __String): boolean;
-        forEach(action: (value: T, key: __String) => void): void;
-        readonly size: number;
-        keys(): Iterator<__String>;
-        values(): Iterator<T>;
-        entries(): Iterator<[__String, T]>;
+    export interface ReadonlyUnderscoreEscapedMap<T> extends ReadonlyMap<__String, T> {
     }
 
     /** Map where keys are `__String`s. */
-    export interface UnderscoreEscapedMap<T> extends ReadonlyUnderscoreEscapedMap<T> {
-        set(key: __String, value: T): this;
-        delete(key: __String): boolean;
-        clear(): void;
+    export interface UnderscoreEscapedMap<T> extends Map<__String, T>, ReadonlyUnderscoreEscapedMap<T> {
     }
 
     /** SymbolTable based on ES6 Map interface. */
@@ -4791,10 +4781,10 @@ namespace ts {
         switchTypes?: Type[];             // Cached array of switch case expression types
         jsxNamespace?: Symbol | false;          // Resolved jsx namespace symbol for this node
         contextFreeType?: Type;          // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive
-        deferredNodes?: Map<Node>; // Set of nodes whose checking has been deferred
+        deferredNodes?: Map<string, Node>; // Set of nodes whose checking has been deferred
         capturedBlockScopeBindings?: Symbol[]; // Block-scoped bindings captured beneath this part of an IterationStatement
         outerTypeParameters?: TypeParameter[];  // Outer type parameters of anonymous object type
-        instantiations?: Map<Type>;         // Instantiations of generic type alias (undefined if non-generic)
+        instantiations?: Map<string, Type>;         // Instantiations of generic type alias (undefined if non-generic)
         isExhaustive?: boolean;           // Is node an exhaustive switch statement
         skipDirectInference?: true;         // Flag set by the API `getContextualType` call on a node when `Completions` is passed to force the checker to skip making inferences to a node's type
         declarationRequiresScopeChange?: boolean;   // Set by `useOuterVariableScopeInParameter` in checker when downlevel emit would change the name resolution scope inside of a parameter.
@@ -5094,7 +5084,7 @@ namespace ts {
     // Generic class and interface types
     export interface GenericType extends InterfaceType, TypeReference {
         /* @internal */
-        instantiations: Map<TypeReference>;  // Generic instantiation cache
+        instantiations: Map<string, TypeReference>;  // Generic instantiation cache
         /* @internal */
         variances?: VarianceFlags[];  // Variance of each type parameter
     }
@@ -5271,7 +5261,7 @@ namespace ts {
         isDistributive: boolean;
         inferTypeParameters?: TypeParameter[];
         outerTypeParameters?: TypeParameter[];
-        instantiations?: Map<Type>;
+        instantiations?: Map<string, Type>;
         aliasSymbol?: Symbol;
         aliasTypeArguments?: Type[];
     }
@@ -5366,7 +5356,7 @@ namespace ts {
         /* @internal */
         isolatedSignatureType?: ObjectType; // A manufactured type that just contains the signature for purposes of signature comparison
         /* @internal */
-        instantiations?: Map<Signature>;    // Generic signature instantiation cache
+        instantiations?: Map<string, Signature>;    // Generic signature instantiation cache
     }
 
     export const enum IndexKind {
@@ -5886,7 +5876,7 @@ namespace ts {
     /* @internal */
     export interface CommandLineOptionBase {
         name: string;
-        type: "string" | "number" | "boolean" | "object" | "list" | Map<number | string>;    // a value of a primitive type, or an object literal mapping named values to actual values
+        type: "string" | "number" | "boolean" | "object" | "list" | Map<string, number | string>;    // a value of a primitive type, or an object literal mapping named values to actual values
         isFilePath?: boolean;                                   // True if option value is a path or fileName
         shortName?: string;                                     // A short mnemonic for convenience - for instance, 'h' can be used in place of 'help'
         description?: DiagnosticMessage;                        // The message describing what the command line switch does
@@ -5911,7 +5901,7 @@ namespace ts {
 
     /* @internal */
     export interface CommandLineOptionOfCustomType extends CommandLineOptionBase {
-        type: Map<number | string>;  // an object literal mapping named values to actual values
+        type: Map<string, number | string>;  // an object literal mapping named values to actual values
     }
 
     /* @internal */
@@ -5924,7 +5914,7 @@ namespace ts {
     /* @internal */
     export interface TsConfigOnlyOption extends CommandLineOptionBase {
         type: "object";
-        elementOptions?: Map<CommandLineOption>;
+        elementOptions?: Map<string, CommandLineOption>;
         extraKeyDiagnostics?: DidYouMeanOptionsDiagnostics;
     }
 
@@ -6213,7 +6203,7 @@ namespace ts {
 
         // TODO: later handle this in better way in builder host instead once the api for tsbuild finalizes and doesn't use compilerHost as base
         /*@internal*/createDirectory?(directory: string): void;
-        /*@internal*/getSymlinks?(): ReadonlyMap<string>;
+        /*@internal*/getSymlinks?(): ReadonlyMap<string, string>;
     }
 
     /** true if --out otherwise source file name */
@@ -7726,7 +7716,7 @@ namespace ts {
         fileExists(path: string): boolean;
         getCurrentDirectory(): string;
         readFile?(path: string): string | undefined;
-        getProbableSymlinks?(files: readonly SourceFile[]): ReadonlyMap<string>;
+        getProbableSymlinks?(files: readonly SourceFile[]): ReadonlyMap<string, string>;
         getGlobalTypingsCacheLocation?(): string | undefined;
 
         getSourceFiles(): readonly SourceFile[];
@@ -7990,7 +7980,7 @@ namespace ts {
     export type PragmaPseudoMapEntry = {[K in keyof PragmaPseudoMap]: {name: K, args: PragmaPseudoMap[K]}}[keyof PragmaPseudoMap];
 
     /* @internal */
-    export interface ReadonlyPragmaMap extends ReadonlyMap<PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]> {
+    export interface ReadonlyPragmaMap extends ReadonlyMap<string, PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]> {
         get<TKey extends keyof PragmaPseudoMap>(key: TKey): PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][];
         forEach(action: <TKey extends keyof PragmaPseudoMap>(value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][], key: TKey) => void): void;
     }
@@ -8001,7 +7991,7 @@ namespace ts {
      * in multiple places
      */
     /* @internal */
-    export interface PragmaMap extends Map<PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]>, ReadonlyPragmaMap {
+    export interface PragmaMap extends Map<string, PragmaPseudoMap[keyof PragmaPseudoMap] | PragmaPseudoMap[keyof PragmaPseudoMap][]>, ReadonlyPragmaMap {
         set<TKey extends keyof PragmaPseudoMap>(key: TKey, value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][]): this;
         get<TKey extends keyof PragmaPseudoMap>(key: TKey): PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][];
         forEach(action: <TKey extends keyof PragmaPseudoMap>(value: PragmaPseudoMap[TKey] | PragmaPseudoMap[TKey][], key: TKey) => void): void;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 6ce2655a4ad8f..20d288efd14d0 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1,7 +1,7 @@
 /* @internal */
 namespace ts {
     export const resolvingEmptyArray: never[] = [] as never[];
-    export const emptyMap = createMap<never>() as ReadonlyMap<never> & ReadonlyPragmaMap;
+    export const emptyMap = createMap<never, never>() as ReadonlyMap<never, never> & ReadonlyPragmaMap;
     export const emptyUnderscoreEscapedMap: ReadonlyUnderscoreEscapedMap<never> = emptyMap as ReadonlyUnderscoreEscapedMap<never>;
 
     export const externalHelpersModuleNameText = "tslib";
@@ -132,13 +132,11 @@ namespace ts {
      * Calls `callback` for each entry in the map, returning the first truthy result.
      * Use `map.forEach` instead for normal iteration.
      */
-    export function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T>, callback: (value: T, key: __String) => U | undefined): U | undefined;
-    export function forEachEntry<T, U>(map: ReadonlyMap<T>, callback: (value: T, key: string) => U | undefined): U | undefined;
-    export function forEachEntry<T, U>(map: ReadonlyUnderscoreEscapedMap<T> | ReadonlyMap<T>, callback: (value: T, key: (string & __String)) => U | undefined): U | undefined {
+    export function forEachEntry<K, V, U>(map: ReadonlyMap<K, V>, callback: (value: V, key: K) => U | undefined): U | undefined {
         const iterator = map.entries();
         for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
             const [key, value] = iterResult.value;
-            const result = callback(value, key as (string & __String));
+            const result = callback(value, key);
             if (result) {
                 return result;
             }
@@ -147,12 +145,10 @@ namespace ts {
     }
 
     /** `forEachEntry` for just keys. */
-    export function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<{}>, callback: (key: __String) => T | undefined): T | undefined;
-    export function forEachKey<T>(map: ReadonlyMap<{}>, callback: (key: string) => T | undefined): T | undefined;
-    export function forEachKey<T>(map: ReadonlyUnderscoreEscapedMap<{}> | ReadonlyMap<{}>, callback: (key: string & __String) => T | undefined): T | undefined {
+    export function forEachKey<K, T>(map: ReadonlyMap<K, unknown>, callback: (key: K) => T | undefined): T | undefined {
         const iterator = map.keys();
         for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
-            const result = callback(iterResult.value as string & __String);
+            const result = callback(iterResult.value);
             if (result) {
                 return result;
             }
@@ -161,11 +157,9 @@ namespace ts {
     }
 
     /** Copy entries from `source` to `target`. */
-    export function copyEntries<T>(source: ReadonlyUnderscoreEscapedMap<T>, target: UnderscoreEscapedMap<T>): void;
-    export function copyEntries<T>(source: ReadonlyMap<T>, target: Map<T>): void;
-    export function copyEntries<T, U extends UnderscoreEscapedMap<T> | Map<T>>(source: U, target: U): void {
-        (source as Map<T>).forEach((value, key) => {
-            (target as Map<T>).set(key, value);
+    export function copyEntries<K, V>(source: ReadonlyMap<K, V>, target: Map<K, V>): void {
+        source.forEach((value, key) => {
+            target.set(key, value);
         });
     }
 
@@ -174,19 +168,19 @@ namespace ts {
      *
      * @param array the array of input elements.
      */
-    export function arrayToSet(array: readonly string[]): Map<true>;
-    export function arrayToSet<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<true>;
+    export function arrayToSet(array: readonly string[]): Map<string, true>;
+    export function arrayToSet<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<string, true>;
     export function arrayToSet<T>(array: readonly T[], makeKey: (value: T) => __String | undefined): UnderscoreEscapedMap<true>;
-    export function arrayToSet(array: readonly any[], makeKey?: (value: any) => string | __String | undefined): Map<true> | UnderscoreEscapedMap<true> {
+    export function arrayToSet(array: readonly any[], makeKey?: (value: any) => string | __String | undefined): Map<string, true> | UnderscoreEscapedMap<true> {
         return arrayToMap<any, true>(array, makeKey || (s => s), returnTrue);
     }
 
     export function cloneMap(map: SymbolTable): SymbolTable;
-    export function cloneMap<T>(map: ReadonlyMap<T>): Map<T>;
     export function cloneMap<T>(map: ReadonlyUnderscoreEscapedMap<T>): UnderscoreEscapedMap<T>;
-    export function cloneMap<T>(map: ReadonlyMap<T> | ReadonlyUnderscoreEscapedMap<T> | SymbolTable): Map<T> | UnderscoreEscapedMap<T> | SymbolTable {
-        const clone = createMap<T>();
-        copyEntries(map as Map<T>, clone);
+    export function cloneMap<K, V>(map: ReadonlyMap<K, V>): Map<K, V>;
+    export function cloneMap<K, V>(map: ReadonlyMap<K, V>): Map<K, V> {
+        const clone = createMap<K, V>();
+        copyEntries(map, clone);
         return clone;
     }
 
@@ -256,7 +250,7 @@ namespace ts {
     export function hasChangesInResolutions<T>(
         names: readonly string[],
         newResolutions: readonly T[],
-        oldResolutions: ReadonlyMap<T> | undefined,
+        oldResolutions: ReadonlyMap<string, T> | undefined,
         comparer: (oldResolution: T, newResolution: T) => boolean): boolean {
         Debug.assert(names.length === newResolutions.length);
 
@@ -5264,7 +5258,7 @@ namespace ts {
     /**
      * clears already present map by calling onDeleteExistingValue callback before deleting that key/value
      */
-    export function clearMap<T>(map: { forEach: Map<T>["forEach"]; clear: Map<T>["clear"]; }, onDeleteValue: (valueInMap: T, key: string) => void) {
+    export function clearMap<T>(map: { forEach: Map<string, T>["forEach"]; clear: Map<string, T>["clear"]; }, onDeleteValue: (valueInMap: T, key: string) => void) {
         // Remove all
         map.forEach(onDeleteValue);
         map.clear();
@@ -5286,8 +5280,8 @@ namespace ts {
      * Mutates the map with newMap such that keys in map will be same as newMap.
      */
     export function mutateMapSkippingNewValues<T, U>(
-        map: Map<T>,
-        newMap: ReadonlyMap<U>,
+        map: Map<string, T>,
+        newMap: ReadonlyMap<string, U>,
         options: MutateMapSkippingNewValuesOptions<T, U>
     ) {
         const { onDeleteValue, onExistingValue } = options;
@@ -5313,7 +5307,7 @@ namespace ts {
     /**
      * Mutates the map with newMap such that keys in map will be same as newMap.
      */
-    export function mutateMap<T, U>(map: Map<T>, newMap: ReadonlyMap<U>, options: MutateMapOptions<T, U>) {
+    export function mutateMap<T, U>(map: Map<string, T>, newMap: ReadonlyMap<string, U>, options: MutateMapOptions<T, U>) {
         // Needs update
         mutateMapSkippingNewValues(map, newMap, options);
 
@@ -5383,9 +5377,9 @@ namespace ts {
     }
 
     /** Add a value to a set, and return true if it wasn't already present. */
-    export function addToSeen(seen: Map<true>, key: string | number): boolean;
-    export function addToSeen<T>(seen: Map<T>, key: string | number, value: T): boolean;
-    export function addToSeen<T>(seen: Map<T>, key: string | number, value: T = true as any): boolean {
+    export function addToSeen(seen: Map<string, true>, key: string | number): boolean;
+    export function addToSeen<T>(seen: Map<string, T>, key: string | number, value: T): boolean;
+    export function addToSeen<T>(seen: Map<string, T>, key: string | number, value: T = true as any): boolean {
         key = String(key);
         if (seen.has(key)) {
             return false;
@@ -5940,7 +5934,7 @@ namespace ts {
         return true;
     }
 
-    export function discoverProbableSymlinks(files: readonly SourceFile[], getCanonicalFileName: GetCanonicalFileName, cwd: string): ReadonlyMap<string> {
+    export function discoverProbableSymlinks(files: readonly SourceFile[], getCanonicalFileName: GetCanonicalFileName, cwd: string): ReadonlyMap<string, string> {
         const result = createMap<string>();
         const symlinks = flatten<readonly [string, string]>(mapDefined(files, sf =>
             sf.resolvedModules && compact(arrayFrom(mapIterator(sf.resolvedModules.values(), res =>
@@ -6651,7 +6645,7 @@ namespace ts {
         return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && equalOwnProperties(a as MapLike<unknown>, b as MapLike<unknown>, isJsonEqual);
     }
 
-    export function getOrUpdate<T>(map: Map<T>, key: string, getDefault: () => T): T {
+    export function getOrUpdate<T>(map: Map<string, T>, key: string, getDefault: () => T): T {
         const got = map.get(key);
         if (got === undefined) {
             const value = getDefault();
diff --git a/src/compiler/watchPublic.ts b/src/compiler/watchPublic.ts
index 3bdf80db631f4..4083b0fa90673 100644
--- a/src/compiler/watchPublic.ts
+++ b/src/compiler/watchPublic.ts
@@ -246,8 +246,8 @@ namespace ts {
 
         let builderProgram: T;
         let reloadLevel: ConfigFileProgramReloadLevel;                      // level to indicate if the program needs to be reloaded from config file/just filenames etc
-        let missingFilesMap: Map<FileWatcher>;                              // Map of file watchers for the missing files
-        let watchedWildcardDirectories: Map<WildcardDirectoryWatcher>;      // map of watchers for the wild card directories in the config file
+        let missingFilesMap: Map<string, FileWatcher>;                              // Map of file watchers for the missing files
+        let watchedWildcardDirectories: Map<string, WildcardDirectoryWatcher>;      // map of watchers for the wild card directories in the config file
         let timerToUpdateProgram: any;                                      // timer callback to recompile the program
         let timerToInvalidateFailedLookupResolutions: any;                  // timer callback to invalidate resolutions for changes in failed lookup locations
 
diff --git a/src/compiler/watchUtilities.ts b/src/compiler/watchUtilities.ts
index 9f609d5a179ed..cb5508718c9d0 100644
--- a/src/compiler/watchUtilities.ts
+++ b/src/compiler/watchUtilities.ts
@@ -262,7 +262,7 @@ namespace ts {
      */
     export function updateMissingFilePathsWatch(
         program: Program,
-        missingFileWatches: Map<FileWatcher>,
+        missingFileWatches: Map<string, FileWatcher>,
         createMissingFileWatch: (missingFilePath: Path) => FileWatcher,
     ) {
         const missingFilePaths = program.getMissingFilePaths();
@@ -293,8 +293,8 @@ namespace ts {
      * as wildcard directories wont change unless reloading config file
      */
     export function updateWatchingWildcardDirectories(
-        existingWatchedForWildcards: Map<WildcardDirectoryWatcher>,
-        wildcardDirectories: Map<WatchDirectoryFlags>,
+        existingWatchedForWildcards: Map<string, WildcardDirectoryWatcher>,
+        wildcardDirectories: Map<string, WatchDirectoryFlags>,
         watchDirectory: (directory: string, flags: WatchDirectoryFlags) => FileWatcher
     ) {
         mutateMap(
diff --git a/src/executeCommandLine/executeCommandLine.ts b/src/executeCommandLine/executeCommandLine.ts
index 96cf7e5f04452..e2e802f1afedc 100644
--- a/src/executeCommandLine/executeCommandLine.ts
+++ b/src/executeCommandLine/executeCommandLine.ts
@@ -100,7 +100,7 @@ namespace ts {
             if (option.name === "lib") {
                 description = getDiagnosticText(option.description);
                 const element = (<CommandLineOptionOfListType>option).element;
-                const typeMap = <Map<number | string>>element.type;
+                const typeMap = <Map<string, number | string>>element.type;
                 optionsDescriptionMap.set(description, arrayFrom(typeMap.keys()).map(key => `'${key}'`));
             }
             else {
diff --git a/src/harness/client.ts b/src/harness/client.ts
index 381177bdf23e4..eb9d02acc8f7b 100644
--- a/src/harness/client.ts
+++ b/src/harness/client.ts
@@ -35,7 +35,7 @@ namespace ts.server {
 
     export class SessionClient implements LanguageService {
         private sequence = 0;
-        private lineMaps: Map<number[]> = createMap<number[]>();
+        private lineMaps: Map<string, number[]> = createMap<number[]>();
         private messages: string[] = [];
         private lastRenameEntry: RenameEntry | undefined;
 
diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts
index 9af23f66d2381..cd093f7c06403 100644
--- a/src/harness/fourslashImpl.ts
+++ b/src/harness/fourslashImpl.ts
@@ -29,7 +29,7 @@ namespace FourSlash {
         symlinks: vfs.FileSet | undefined;
 
         // A mapping from marker names to name/position pairs
-        markerPositions: ts.Map<Marker>;
+        markerPositions: ts.Map<string, Marker>;
 
         markers: Marker[];
 
@@ -42,7 +42,7 @@ namespace FourSlash {
          * is a range with `text in range` "selected".
          */
         ranges: Range[];
-        rangesByText?: ts.MultiMap<Range>;
+        rangesByText?: ts.MultiMap<string, Range>;
     }
 
     export interface Marker {
@@ -2343,7 +2343,7 @@ namespace FourSlash {
             return this.getRanges().filter(r => r.fileName === fileName);
         }
 
-        public rangesByText(): ts.Map<Range[]> {
+        public rangesByText(): ts.Map<string, Range[]> {
             if (this.testData.rangesByText) return this.testData.rangesByText;
             const result = ts.createMultiMap<Range>();
             this.testData.rangesByText = result;
@@ -3423,7 +3423,7 @@ namespace FourSlash {
             return text;
         }
 
-        private formatCallHierarchyItem(file: FourSlashFile, callHierarchyItem: ts.CallHierarchyItem, direction: CallHierarchyItemDirection, seen: ts.Map<boolean>, prefix: string, trailingPrefix: string = prefix) {
+        private formatCallHierarchyItem(file: FourSlashFile, callHierarchyItem: ts.CallHierarchyItem, direction: CallHierarchyItemDirection, seen: ts.Map<string, boolean>, prefix: string, trailingPrefix: string = prefix) {
             const key = `${callHierarchyItem.file}|${JSON.stringify(callHierarchyItem.span)}|${direction}`;
             const alreadySeen = seen.has(key);
             seen.set(key, true);
@@ -3947,7 +3947,7 @@ namespace FourSlash {
         throw new Error(errorMessage);
     }
 
-    function recordObjectMarker(fileName: string, location: LocationInformation, text: string, markerMap: ts.Map<Marker>, markers: Marker[]): Marker | undefined {
+    function recordObjectMarker(fileName: string, location: LocationInformation, text: string, markerMap: ts.Map<string, Marker>, markers: Marker[]): Marker | undefined {
         let markerValue: any;
         try {
             // Attempt to parse the marker value as JSON
@@ -3978,7 +3978,7 @@ namespace FourSlash {
         return marker;
     }
 
-    function recordMarker(fileName: string, location: LocationInformation, name: string, markerMap: ts.Map<Marker>, markers: Marker[]): Marker | undefined {
+    function recordMarker(fileName: string, location: LocationInformation, name: string, markerMap: ts.Map<string, Marker>, markers: Marker[]): Marker | undefined {
         const marker: Marker = {
             fileName,
             position: location.position
@@ -3997,7 +3997,7 @@ namespace FourSlash {
         }
     }
 
-    function parseFileContent(content: string, fileName: string, markerMap: ts.Map<Marker>, markers: Marker[], ranges: Range[]): FourSlashFile {
+    function parseFileContent(content: string, fileName: string, markerMap: ts.Map<string, Marker>, markers: Marker[], ranges: Range[]): FourSlashFile {
         content = chompLeadingSpace(content);
 
         // Any slash-star comment with a character not in this string is not a marker.
diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts
index a2785bef3d712..0b57326e883d5 100644
--- a/src/harness/fourslashInterfaceImpl.ts
+++ b/src/harness/fourslashInterfaceImpl.ts
@@ -27,7 +27,7 @@ namespace FourSlashInterface {
             return this.ranges().map(r => ts.createTextSpan(r.pos, r.end - r.pos));
         }
 
-        public rangesByText(): ts.Map<FourSlash.Range[]> {
+        public rangesByText(): ts.Map<string, FourSlash.Range[]> {
             return this.state.rangesByText();
         }
 
diff --git a/src/harness/harnessIO.ts b/src/harness/harnessIO.ts
index 9f4cef69de26b..b07ecba859e50 100644
--- a/src/harness/harnessIO.ts
+++ b/src/harness/harnessIO.ts
@@ -244,7 +244,7 @@ namespace Harness {
         export const es2015DefaultLibFileName = "lib.es2015.d.ts";
 
         // Cache of lib files from "built/local"
-        let libFileNameSourceFileMap: ts.Map<ts.SourceFile> | undefined;
+        let libFileNameSourceFileMap: ts.Map<string, ts.SourceFile> | undefined;
 
         export function getDefaultLibrarySourceFile(fileName = defaultLibFileName): ts.SourceFile | undefined {
             if (!isDefaultLibraryFile(fileName)) {
@@ -314,7 +314,7 @@ namespace Harness {
             { name: "fullEmitPaths", type: "boolean" }
         ];
 
-        let optionsIndex: ts.Map<ts.CommandLineOption>;
+        let optionsIndex: ts.Map<string, ts.CommandLineOption>;
         function getCommandLineOption(name: string): ts.CommandLineOption | undefined {
             if (!optionsIndex) {
                 optionsIndex = ts.createMap<ts.CommandLineOption>();
@@ -959,7 +959,7 @@ namespace Harness {
             }
         }
 
-        function checkDuplicatedFileName(resultName: string, dupeCase: ts.Map<number>): string {
+        function checkDuplicatedFileName(resultName: string, dupeCase: ts.Map<string, number>): string {
             resultName = sanitizeTestFilePath(resultName);
             if (dupeCase.has(resultName)) {
                 // A different baseline filename should be manufactured if the names differ only in case, for windows compat
@@ -1067,9 +1067,9 @@ namespace Harness {
         }
     }
 
-    let booleanVaryByStarSettingValues: ts.Map<string | number> | undefined;
+    let booleanVaryByStarSettingValues: ts.Map<string, string | number> | undefined;
 
-    function getVaryByStarSettingValues(varyBy: string): ts.ReadonlyMap<string | number> | undefined {
+    function getVaryByStarSettingValues(varyBy: string): ts.ReadonlyMap<string, string | number> | undefined {
         const option = ts.forEach(ts.optionDeclarations, decl => ts.equateStringsCaseInsensitive(decl.name, varyBy) ? decl : undefined);
         if (option) {
             if (typeof option.type === "object") {
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index fbaf9ba545d0a..30045d0912ff7 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -126,7 +126,7 @@ namespace Harness.LanguageService {
 
     export abstract class LanguageServiceAdapterHost {
         public readonly sys = new fakes.System(new vfs.FileSystem(/*ignoreCase*/ true, { cwd: virtualFileSystemRoot }));
-        public typesRegistry: ts.Map<void> | undefined;
+        public typesRegistry: ts.Map<string, void> | undefined;
         private scriptInfos: collections.SortedMap<string, ScriptInfo>;
 
         constructor(protected cancellationToken = DefaultHostCancellationToken.instance,
diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts
index 240af2e879d38..fa2c1235d71c5 100644
--- a/src/harness/loggedIO.ts
+++ b/src/harness/loggedIO.ts
@@ -83,7 +83,7 @@ namespace Playback {
 
     let recordLog: IoLog | undefined;
     let replayLog: IoLog | undefined;
-    let replayFilesRead: ts.Map<IoLogFile> | undefined;
+    let replayFilesRead: ts.Map<string, IoLogFile> | undefined;
     let recordLogFileNameBase = "";
 
     interface Memoized<T> {
diff --git a/src/harness/virtualFileSystemWithWatch.ts b/src/harness/virtualFileSystemWithWatch.ts
index 28e7dd1cd85b7..e9a2adc1148b2 100644
--- a/src/harness/virtualFileSystemWithWatch.ts
+++ b/src/harness/virtualFileSystemWithWatch.ts
@@ -36,7 +36,7 @@ interface Array<T> { length: number; [n: number]: T; }`
         currentDirectory?: string;
         newLine?: string;
         windowsStyleRoot?: string;
-        environmentVariables?: Map<string>;
+        environmentVariables?: Map<string, string>;
         runWithoutRecursiveWatches?: boolean;
         runWithFallbackPolling?: boolean;
     }
@@ -122,12 +122,12 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
     }
 
-    function createWatcher<T>(map: MultiMap<T>, path: string, callback: T): FileWatcher {
+    function createWatcher<T>(map: MultiMap<string, T>, path: string, callback: T): FileWatcher {
         map.add(path, callback);
         return { close: () => map.remove(path, callback) };
     }
 
-    function getDiffInKeys<T>(map: Map<T>, expectedKeys: readonly string[]) {
+    function getDiffInKeys<T>(map: Map<string, T>, expectedKeys: readonly string[]) {
         if (map.size === expectedKeys.length) {
             return "";
         }
@@ -154,19 +154,19 @@ interface Array<T> { length: number; [n: number]: T; }`
         return `\n\nNotInActual: ${notInActual}\nDuplicates: ${duplicates}\nInActualButNotInExpected: ${inActualNotExpected}`;
     }
 
-    export function verifyMapSize(caption: string, map: Map<any>, expectedKeys: readonly string[]) {
+    export function verifyMapSize(caption: string, map: Map<string, any>, expectedKeys: readonly string[]) {
         assert.equal(map.size, expectedKeys.length, `${caption}: incorrect size of map: Actual keys: ${arrayFrom(map.keys())} Expected: ${expectedKeys}${getDiffInKeys(map, expectedKeys)}`);
     }
 
-    export type MapValueTester<T, U> = [Map<U[]> | undefined, (value: T) => U];
+    export type MapValueTester<T, U> = [Map<string, U[]> | undefined, (value: T) => U];
 
-    export function checkMap<T, U = undefined>(caption: string, actual: MultiMap<T>, expectedKeys: ReadonlyMap<number>, valueTester?: MapValueTester<T,U>): void;
-    export function checkMap<T, U = undefined>(caption: string, actual: MultiMap<T>, expectedKeys: readonly string[], eachKeyCount: number, valueTester?: MapValueTester<T, U>): void;
-    export function checkMap<T>(caption: string, actual: Map<T> | MultiMap<T>, expectedKeys: readonly string[], eachKeyCount: undefined): void;
+    export function checkMap<T, U = undefined>(caption: string, actual: MultiMap<string, T>, expectedKeys: ReadonlyMap<string, number>, valueTester?: MapValueTester<T,U>): void;
+    export function checkMap<T, U = undefined>(caption: string, actual: MultiMap<string, T>, expectedKeys: readonly string[], eachKeyCount: number, valueTester?: MapValueTester<T, U>): void;
+    export function checkMap<T>(caption: string, actual: Map<string, T> | MultiMap<string, T>, expectedKeys: readonly string[], eachKeyCount: undefined): void;
     export function checkMap<T, U = undefined>(
         caption: string,
-        actual: Map<T> | MultiMap<T>,
-        expectedKeysMapOrArray: ReadonlyMap<number> | readonly string[],
+        actual: Map<string, T> | MultiMap<string, T>,
+        expectedKeysMapOrArray: ReadonlyMap<string, number> | readonly string[],
         eachKeyCountOrValueTester?: number | MapValueTester<T, U>,
         valueTester?: MapValueTester<T, U>) {
         const expectedKeys = isArray(expectedKeysMapOrArray) ? arrayToMap(expectedKeysMapOrArray, s => s, () => eachKeyCountOrValueTester as number) : expectedKeysMapOrArray;
@@ -179,10 +179,10 @@ interface Array<T> { length: number; [n: number]: T; }`
             assert.isTrue(actual.has(name), `${caption}: expected to contain ${name}, actual keys: ${arrayFrom(actual.keys())}`);
             // Check key information only if eachKeyCount is provided
             if (!isArray(expectedKeysMapOrArray) || eachKeyCountOrValueTester !== undefined) {
-                assert.equal((actual as MultiMap<T>).get(name)!.length, count, `${caption}: Expected to be have ${count} entries for ${name}. Actual entry: ${JSON.stringify(actual.get(name))}`);
+                assert.equal((actual as MultiMap<string, T>).get(name)!.length, count, `${caption}: Expected to be have ${count} entries for ${name}. Actual entry: ${JSON.stringify(actual.get(name))}`);
                 if (expectedValues) {
                     assert.deepEqual(
-                        (actual as MultiMap<T>).get(name)!.map(valueMapper),
+                        (actual as MultiMap<string, T>).get(name)!.map(valueMapper),
                         expectedValues.get(name),
                         `${caption}:: expected values mismatch for ${name}`
                     );
@@ -203,9 +203,9 @@ interface Array<T> { length: number; [n: number]: T; }`
         fileName: string;
         pollingInterval: PollingInterval;
     }
-    export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: ReadonlyMap<number>, expectedDetails?: Map<WatchFileDetails[]>): void;
-    export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: readonly string[], eachFileWatchCount: number, expectedDetails?: Map<WatchFileDetails[]>): void;
-    export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: ReadonlyMap<number> | readonly string[], eachFileWatchCountOrExpectedDetails?: number | Map<WatchFileDetails[]>, expectedDetails?: Map<WatchFileDetails[]>) {
+    export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: ReadonlyMap<string, number>, expectedDetails?: Map<string, WatchFileDetails[]>): void;
+    export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: readonly string[], eachFileWatchCount: number, expectedDetails?: Map<string, WatchFileDetails[]>): void;
+    export function checkWatchedFilesDetailed(host: TestServerHost, expectedFiles: ReadonlyMap<string, number> | readonly string[], eachFileWatchCountOrExpectedDetails?: number | Map<string, WatchFileDetails[]>, expectedDetails?: Map<string, WatchFileDetails[]>) {
         if (!isNumber(eachFileWatchCountOrExpectedDetails)) expectedDetails = eachFileWatchCountOrExpectedDetails;
         if (isArray(expectedFiles)) {
             checkMap(
@@ -235,9 +235,9 @@ interface Array<T> { length: number; [n: number]: T; }`
         fallbackPollingInterval: PollingInterval;
         fallbackOptions: WatchOptions | undefined;
     }
-    export function checkWatchedDirectoriesDetailed(host: TestServerHost, expectedDirectories: ReadonlyMap<number>, recursive: boolean, expectedDetails?: Map<WatchDirectoryDetails[]>): void;
-    export function checkWatchedDirectoriesDetailed(host: TestServerHost, expectedDirectories: readonly string[], eachDirectoryWatchCount: number, recursive: boolean, expectedDetails?: Map<WatchDirectoryDetails[]>): void;
-    export function checkWatchedDirectoriesDetailed(host: TestServerHost, expectedDirectories: ReadonlyMap<number> | readonly string[], recursiveOrEachDirectoryWatchCount: boolean | number, recursiveOrExpectedDetails?: boolean | Map<WatchDirectoryDetails[]>, expectedDetails?: Map<WatchDirectoryDetails[]>) {
+    export function checkWatchedDirectoriesDetailed(host: TestServerHost, expectedDirectories: ReadonlyMap<string, number>, recursive: boolean, expectedDetails?: Map<string, WatchDirectoryDetails[]>): void;
+    export function checkWatchedDirectoriesDetailed(host: TestServerHost, expectedDirectories: readonly string[], eachDirectoryWatchCount: number, recursive: boolean, expectedDetails?: Map<string, WatchDirectoryDetails[]>): void;
+    export function checkWatchedDirectoriesDetailed(host: TestServerHost, expectedDirectories: ReadonlyMap<string, number> | readonly string[], recursiveOrEachDirectoryWatchCount: boolean | number, recursiveOrExpectedDetails?: boolean | Map<string, WatchDirectoryDetails[]>, expectedDetails?: Map<string, WatchDirectoryDetails[]>) {
         if (typeof recursiveOrExpectedDetails !== "boolean") expectedDetails = recursiveOrExpectedDetails;
         if (isArray(expectedDirectories)) {
             checkMap(
@@ -368,7 +368,7 @@ interface Array<T> { length: number; [n: number]: T; }`
         fileOrFolderorSymLinkList: readonly FileOrFolderOrSymLink[];
         newLine?: string;
         useWindowsStylePaths?: boolean;
-        environmentVariables?: Map<string>;
+        environmentVariables?: Map<string, string>;
     }
 
     export class TestServerHost implements server.ServerHost, FormatDiagnosticsHost, ModuleResolutionHost {
@@ -376,7 +376,7 @@ interface Array<T> { length: number; [n: number]: T; }`
 
         private readonly output: string[] = [];
 
-        private fs: Map<FSEntry> = createMap<FSEntry>();
+        private fs: Map<string, FSEntry> = createMap<FSEntry>();
         private time = timeIncrements;
         getCanonicalFileName: (s: string) => string;
         private toPath: (f: string) => Path;
@@ -391,7 +391,7 @@ interface Array<T> { length: number; [n: number]: T; }`
         public readonly useCaseSensitiveFileNames: boolean;
         public readonly newLine: string;
         public readonly windowsStyleRoot?: string;
-        private readonly environmentVariables?: Map<string>;
+        private readonly environmentVariables?: Map<string, string>;
         private readonly executingFilePath: string;
         private readonly currentDirectory: string;
         public require: ((initialPath: string, moduleName: string) => RequireResult) | undefined;
@@ -750,7 +750,7 @@ interface Array<T> { length: number; [n: number]: T; }`
             invokeWatcherCallbacks(this.watchedFiles.get(this.toPath(fileFullPath)), ({ cb, fileName }) => cb(useFileNameInCallback ? fileName : fileFullPath, eventKind));
         }
 
-        private fsWatchCallback(map: MultiMap<TestFsWatcher>, fullPath: string, eventName: "rename" | "change", entryFullPath?: string) {
+        private fsWatchCallback(map: MultiMap<string, TestFsWatcher>, fullPath: string, eventName: "rename" | "change", entryFullPath?: string) {
             invokeWatcherCallbacks(map.get(this.toPath(fullPath)), ({ cb }) => cb(eventName, entryFullPath ? this.getRelativePathToDirectory(fullPath, entryFullPath) : ""));
         }
 
@@ -1042,8 +1042,8 @@ interface Array<T> { length: number; [n: number]: T; }`
             this.clearOutput();
         }
 
-        snap(): Map<FSEntry> {
-            const result = new Map<FSEntry>();
+        snap(): Map<string, FSEntry> {
+            const result = new Map<string, FSEntry>();
             this.fs.forEach((value, key) => {
                 const cloneValue = clone(value);
                 if (isFsFolder(cloneValue)) {
@@ -1055,8 +1055,8 @@ interface Array<T> { length: number; [n: number]: T; }`
             return result;
         }
 
-        writtenFiles?: Map<number>;
-        diff(baseline: string[], base: Map<FSEntry> = new Map()) {
+        writtenFiles?: Map<string, number>;
+        diff(baseline: string[], base: Map<string, FSEntry> = new Map()) {
             this.fs.forEach(newFsEntry => {
                 diffFsEntry(baseline, base.get(newFsEntry.path), newFsEntry, this.writtenFiles);
             });
@@ -1115,7 +1115,7 @@ interface Array<T> { length: number; [n: number]: T; }`
     function diffFsSymLink(baseline: string[], fsEntry: FsSymLink) {
         baseline.push(`//// [${fsEntry.fullPath}] symlink(${fsEntry.symLink})`);
     }
-    function diffFsEntry(baseline: string[], oldFsEntry: FSEntry | undefined, newFsEntry: FSEntry | undefined, writtenFiles: Map<any> | undefined): void {
+    function diffFsEntry(baseline: string[], oldFsEntry: FSEntry | undefined, newFsEntry: FSEntry | undefined, writtenFiles: Map<string, any> | undefined): void {
         const file = newFsEntry && newFsEntry.fullPath;
         if (isFsFile(oldFsEntry)) {
             if (isFsFile(newFsEntry)) {
@@ -1192,7 +1192,7 @@ interface Array<T> { length: number; [n: number]: T; }`
         };
     }
 
-    function serializeMultiMap<T, U>(baseline: string[], caption: string, multiMap: MultiMap<T>, valueMapper: (value: T) => U) {
+    function serializeMultiMap<T, U>(baseline: string[], caption: string, multiMap: MultiMap<string, T>, valueMapper: (value: T) => U) {
         baseline.push(`${caption}::`);
         multiMap.forEach((values, key) => {
             baseline.push(`${key}:`);
@@ -1208,7 +1208,7 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
     }
 
-    export type TestServerHostTrackingWrittenFiles = TestServerHost & { writtenFiles: Map<number>; };
+    export type TestServerHostTrackingWrittenFiles = TestServerHost & { writtenFiles: Map<string, number>; };
 
     export function changeToHostTrackingWrittenFiles(inputHost: TestServerHost) {
         const host = inputHost as TestServerHostTrackingWrittenFiles;
diff --git a/src/jsTyping/jsTyping.ts b/src/jsTyping/jsTyping.ts
index 70efac4aee1e5..e1cb9ebfd5584 100644
--- a/src/jsTyping/jsTyping.ts
+++ b/src/jsTyping/jsTyping.ts
@@ -77,7 +77,7 @@ namespace ts.JsTyping {
     /**
      * A map of loose file names to library names that we are confident require typings
      */
-    export type SafeList = ReadonlyMap<string>;
+    export type SafeList = ReadonlyMap<string, string>;
 
     export function loadSafeList(host: TypingResolutionHost, safeListPath: Path): SafeList {
         const result = readConfigFile(safeListPath, path => host.readFile(path));
@@ -107,10 +107,10 @@ namespace ts.JsTyping {
         fileNames: string[],
         projectRootPath: Path,
         safeList: SafeList,
-        packageNameToTypingLocation: ReadonlyMap<CachedTyping>,
+        packageNameToTypingLocation: ReadonlyMap<string, CachedTyping>,
         typeAcquisition: TypeAcquisition,
         unresolvedImports: readonly string[],
-        typesRegistry: ReadonlyMap<MapLike<string>>):
+        typesRegistry: ReadonlyMap<string, MapLike<string>>):
         { cachedTypingPaths: string[], newTypingNames: string[], filesToWatch: string[] } {
 
         if (!typeAcquisition || !typeAcquisition.enable) {
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 730d8c0d5fa47..85528a9bf3e6c 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -163,11 +163,11 @@ namespace ts.server {
         [name: string]: { match: RegExp, exclude?: (string | number)[][], types?: string[] };
     }
 
-    function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions: CommandLineOption[]): Map<Map<number>> {
-        const map: Map<Map<number>> = createMap<Map<number>>();
+    function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions: CommandLineOption[]): Map<string, Map<string, number>> {
+        const map: Map<string, Map<string, number>> = createMap<Map<string, number>>();
         for (const option of commandLineOptions) {
             if (typeof option.type === "object") {
-                const optionMap = <Map<number>>option.type;
+                const optionMap = <Map<string, number>>option.type;
                 // verify that map contains only numbers
                 optionMap.forEach(value => {
                     Debug.assert(typeof value === "number");
@@ -379,7 +379,7 @@ namespace ts.server {
          * It is false when the open file that would still be impacted by existence of
          *   this config file but it is not the root of inferred project
          */
-        openFilesImpactedByConfigFile: Map<boolean>;
+        openFilesImpactedByConfigFile: Map<string, boolean>;
         /**
          * The file watcher watching the config file because there is open script info that is root of
          * inferred project and will be impacted by change in the status of the config file
@@ -592,11 +592,11 @@ namespace ts.server {
          * Map to the real path of the infos
          */
         /* @internal */
-        readonly realpathToScriptInfos: MultiMap<ScriptInfo> | undefined;
+        readonly realpathToScriptInfos: MultiMap<string, ScriptInfo> | undefined;
         /**
          * maps external project file name to list of config files that were the part of this project
          */
-        private readonly externalProjectToConfiguredProjectMap: Map<NormalizedPath[]> = createMap<NormalizedPath[]>();
+        private readonly externalProjectToConfiguredProjectMap: Map<string, NormalizedPath[]> = createMap<NormalizedPath[]>();
 
         /**
          * external projects (configuration and list of root files is not controlled by tsserver)
@@ -626,7 +626,7 @@ namespace ts.server {
         /**
          * Project size for configured or external projects
          */
-        private readonly projectToSizeMap: Map<number> = createMap<number>();
+        private readonly projectToSizeMap: Map<string, number> = createMap<number>();
         /**
          * This is a map of config file paths existence that doesnt need query to disk
          * - The entry can be present because there is inferred project that needs to watch addition of config file to directory
@@ -662,7 +662,7 @@ namespace ts.server {
         public readonly globalPlugins: readonly string[];
         public readonly pluginProbeLocations: readonly string[];
         public readonly allowLocalPluginLoads: boolean;
-        private currentPluginConfigOverrides: Map<any> | undefined;
+        private currentPluginConfigOverrides: Map<string, any> | undefined;
 
         public readonly typesMapLocation: string | undefined;
 
@@ -1119,7 +1119,7 @@ namespace ts.server {
             }
         }
 
-        private delayUpdateSourceInfoProjects(sourceInfos: Map<true> | undefined) {
+        private delayUpdateSourceInfoProjects(sourceInfos: Map<string, true> | undefined) {
             if (sourceInfos) {
                 sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path as Path));
             }
@@ -2296,8 +2296,8 @@ namespace ts.server {
          * Note that this does not return projects in info.containingProjects
          */
         /*@internal*/
-        getSymlinkedProjects(info: ScriptInfo): MultiMap<Project> | undefined {
-            let projects: MultiMap<Project> | undefined;
+        getSymlinkedProjects(info: ScriptInfo): MultiMap<string, Project> | undefined {
+            let projects: MultiMap<string, Project> | undefined;
             if (this.realpathToScriptInfos) {
                 const realpath = info.getRealpathIfDifferent();
                 if (realpath) {
@@ -2592,7 +2592,7 @@ namespace ts.server {
             return documentPositionMapper;
         }
 
-        private addSourceInfoToSourceMap(sourceFileName: string | undefined, project: Project, sourceInfos?: Map<true>) {
+        private addSourceInfoToSourceMap(sourceFileName: string | undefined, project: Project, sourceInfos?: Map<string, true>) {
             if (sourceFileName) {
                 // Attach as source
                 const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient(sourceFileName, project.currentDirectory, project.directoryStructureHost)!;
@@ -2761,7 +2761,7 @@ namespace ts.server {
          * If the there is no existing project it just opens the configured project for the config file
          * reloadForInfo provides a way to filter out files to reload configured project for
          */
-        private reloadConfiguredProjectForFiles<T>(openFiles: Map<T>, delayReload: boolean, shouldReloadProjectFor: (openFileValue: T) => boolean, reason: string) {
+        private reloadConfiguredProjectForFiles<T>(openFiles: Map<string, T>, delayReload: boolean, shouldReloadProjectFor: (openFileValue: T) => boolean, reason: string) {
             const updatedProjects = createMap<true>();
             // try to reload config file for all open files
             openFiles.forEach((openFileValue, path) => {
@@ -3075,10 +3075,10 @@ namespace ts.server {
         }
 
         /*@internal*/
-        loadAncestorProjectTree(forProjects?: ReadonlyMap<true>) {
-            forProjects = forProjects || mapDefinedMap(
+        loadAncestorProjectTree(forProjects?: ReadonlyMap<string, true>) {
+            forProjects = forProjects || mapDefinedEntries(
                 this.configuredProjects,
-                project => !project.isInitialLoadPending() || undefined
+                (key, project) => !project.isInitialLoadPending() ? [key, true] : undefined
             );
 
             const seenProjects = createMap<true>();
@@ -3099,7 +3099,7 @@ namespace ts.server {
             }
         }
 
-        private ensureProjectChildren(project: ConfiguredProject, seenProjects: Map<true>) {
+        private ensureProjectChildren(project: ConfiguredProject, seenProjects: Map<string, true>) {
             if (!addToSeen(seenProjects, project.canonicalConfigFilePath)) return;
             // Update the project
             updateProjectIfDirty(project);
@@ -3204,7 +3204,7 @@ namespace ts.server {
                 if (!info.isScriptOpen() && info.isOrphan()) {
                     // Otherwise if there is any source info that is alive, this alive too
                     if (!info.sourceMapFilePath) return;
-                    let sourceInfos: Map<true> | undefined;
+                    let sourceInfos: Map<string, true> | undefined;
                     if (isString(info.sourceMapFilePath)) {
                         const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
                         sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
@@ -3224,7 +3224,7 @@ namespace ts.server {
                 // Retain this script info
                 toRemoveScriptInfos.delete(info.path);
                 if (info.sourceMapFilePath) {
-                    let sourceInfos: Map<true> | undefined;
+                    let sourceInfos: Map<string, true> | undefined;
                     if (isString(info.sourceMapFilePath)) {
                         // And map file info and source infos
                         toRemoveScriptInfos.delete(info.sourceMapFilePath);
diff --git a/src/server/project.ts b/src/server/project.ts
index 79b887cf067d2..82821be6de9ec 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -113,7 +113,7 @@ namespace ts.server {
         generatedFilePath: Path;
         watcher: FileWatcher;
     }
-    type GeneratedFileWatcherMap = GeneratedFileWatcher | Map<GeneratedFileWatcher>;
+    type GeneratedFileWatcherMap = GeneratedFileWatcher | Map<string, GeneratedFileWatcher>;
     function isGeneratedFileWatcher(watch: GeneratedFileWatcherMap): watch is GeneratedFileWatcher {
         return (watch as GeneratedFileWatcher).generatedFilePath !== undefined;
     }
@@ -129,12 +129,12 @@ namespace ts.server {
         private rootFilesMap = createMap<ProjectRootFile>();
         private program: Program | undefined;
         private externalFiles: SortedReadonlyArray<string> | undefined;
-        private missingFilesMap: Map<FileWatcher> | undefined;
+        private missingFilesMap: Map<string, FileWatcher> | undefined;
         private generatedFilesMap: GeneratedFileWatcherMap | undefined;
         private plugins: PluginModuleWithName[] = [];
 
         /*@internal*/
-        private packageJsonFilesMap: Map<FileWatcher> | undefined;
+        private packageJsonFilesMap: Map<string, FileWatcher> | undefined;
 
         /*@internal*/
         /**
@@ -169,11 +169,11 @@ namespace ts.server {
         /**
          * Set of files names that were updated since the last call to getChangesSinceVersion.
          */
-        private updatedFileNames: Map<true> | undefined;
+        private updatedFileNames: Map<string, true> | undefined;
         /**
          * Set of files that was returned from the last call to getChangesSinceVersion.
          */
-        private lastReportedFileNames: Map<boolean> | undefined;
+        private lastReportedFileNames: Map<string, boolean> | undefined;
         /**
          * Last version that was reported.
          */
@@ -200,7 +200,7 @@ namespace ts.server {
         typingFiles: SortedReadonlyArray<string> = emptyArray;
 
         /*@internal*/
-        originalConfiguredProjects: Map<true> | undefined;
+        originalConfiguredProjects: Map<string, true> | undefined;
 
         /*@internal*/
         getResolvedProjectReferenceToRedirect(_fileName: string): ResolvedProjectReference | undefined {
@@ -246,9 +246,9 @@ namespace ts.server {
         /*@internal*/
         private importSuggestionsCache = Completions.createImportSuggestionsForFileCache();
         /*@internal*/
-        private dirtyFilesForSuggestions: Map<true> | undefined;
+        private dirtyFilesForSuggestions: Map<string, true> | undefined;
         /*@internal*/
-        private symlinks: ReadonlyMap<string> | undefined;
+        private symlinks: ReadonlyMap<string, string> | undefined;
 
         /*@internal*/
         constructor(
@@ -322,7 +322,7 @@ namespace ts.server {
         }
 
         /*@internal*/
-        getProbableSymlinks(files: readonly SourceFile[]): ReadonlyMap<string> {
+        getProbableSymlinks(files: readonly SourceFile[]): ReadonlyMap<string, string> {
             return this.symlinks || (this.symlinks = discoverProbableSymlinks(
                 files,
                 this.getCanonicalFileName,
@@ -1086,7 +1086,7 @@ namespace ts.server {
                                         watcher
                                     )) {
                                     closeFileWatcherOf(watcher);
-                                    (this.generatedFilesMap as Map<GeneratedFileWatcher>).delete(source);
+                                    (this.generatedFilesMap as Map<string, GeneratedFileWatcher>).delete(source);
                                 }
                             });
                         }
@@ -1354,11 +1354,11 @@ namespace ts.server {
         getChangesSinceVersion(lastKnownVersion?: number, includeProjectReferenceRedirectInfo?: boolean): ProjectFilesWithTSDiagnostics {
             const includeProjectReferenceRedirectInfoIfRequested =
                 includeProjectReferenceRedirectInfo
-                    ? (files: Map<boolean>) => arrayFrom(files.entries(), ([fileName, isSourceOfProjectReferenceRedirect]): protocol.FileWithProjectReferenceRedirectInfo => ({
+                    ? (files: Map<string, boolean>) => arrayFrom(files.entries(), ([fileName, isSourceOfProjectReferenceRedirect]): protocol.FileWithProjectReferenceRedirectInfo => ({
                         fileName,
                         isSourceOfProjectReferenceRedirect
                     }))
-                    : (files: Map<boolean>) => arrayFrom(files.keys());
+                    : (files: Map<string, boolean>) => arrayFrom(files.keys());
 
             // Update the graph only if initial configured project load is not pending
             if (!this.isInitialLoadPending()) {
@@ -1393,8 +1393,8 @@ namespace ts.server {
                     info => info.isSourceOfProjectReferenceRedirect
                 );
 
-                const added: Map<boolean> = new Map<boolean>();
-                const removed: Map<boolean> = new Map<boolean>();
+                const added: Map<string, boolean> = new Map<string, boolean>();
+                const removed: Map<string, boolean> = new Map<string, boolean>();
 
                 const updated: string[] = updatedFileNames ? arrayFrom(updatedFileNames.keys()) : [];
                 const updatedRedirects: protocol.FileWithProjectReferenceRedirectInfo[] = [];
@@ -1466,7 +1466,7 @@ namespace ts.server {
             return !!this.program && this.program.isSourceOfProjectReferenceRedirect(fileName);
         }
 
-        protected enableGlobalPlugins(options: CompilerOptions, pluginConfigOverrides: Map<any> | undefined) {
+        protected enableGlobalPlugins(options: CompilerOptions, pluginConfigOverrides: Map<string, any> | undefined) {
             const host = this.projectService.host;
 
             if (!host.require) {
@@ -1498,7 +1498,7 @@ namespace ts.server {
             }
         }
 
-        protected enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[], pluginConfigOverrides: Map<any> | undefined) {
+        protected enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[], pluginConfigOverrides: Map<string, any> | undefined) {
             this.projectService.logger.info(`Enabling plugin ${pluginConfigEntry.name} from candidate paths: ${searchPaths.join(",")}`);
 
             const log = (message: string) => this.projectService.logger.info(message);
@@ -1638,12 +1638,12 @@ namespace ts.server {
         }
     }
 
-    function getUnresolvedImports(program: Program, cachedUnresolvedImportsPerFile: Map<readonly string[]>): SortedReadonlyArray<string> {
+    function getUnresolvedImports(program: Program, cachedUnresolvedImportsPerFile: Map<string, readonly string[]>): SortedReadonlyArray<string> {
         const ambientModules = program.getTypeChecker().getAmbientModules().map(mod => stripQuotes(mod.getName()));
         return sortAndDeduplicate(flatMap(program.getSourceFiles(), sourceFile =>
             extractUnresolvedImportsFromSourceFile(sourceFile, ambientModules, cachedUnresolvedImportsPerFile)));
     }
-    function extractUnresolvedImportsFromSourceFile(file: SourceFile, ambientModules: readonly string[], cachedUnresolvedImportsPerFile: Map<readonly string[]>): readonly string[] {
+    function extractUnresolvedImportsFromSourceFile(file: SourceFile, ambientModules: readonly string[], cachedUnresolvedImportsPerFile: Map<string, readonly string[]>): readonly string[] {
         return getOrUpdate(cachedUnresolvedImportsPerFile, file.path, () => {
             if (!file.resolvedModules) return emptyArray;
             let unresolvedImports: string[] | undefined;
@@ -1713,7 +1713,7 @@ namespace ts.server {
             watchOptions: WatchOptions | undefined,
             projectRootPath: NormalizedPath | undefined,
             currentDirectory: string | undefined,
-            pluginConfigOverrides: Map<any> | undefined) {
+            pluginConfigOverrides: Map<string, any> | undefined) {
             super(InferredProject.newName(),
                 ProjectKind.Inferred,
                 projectService,
@@ -1788,7 +1788,7 @@ namespace ts.server {
         private typeAcquisition!: TypeAcquisition; // TODO: GH#18217
         /* @internal */
         configFileWatcher: FileWatcher | undefined;
-        private directoriesWatchedForWildcards: Map<WildcardDirectoryWatcher> | undefined;
+        private directoriesWatchedForWildcards: Map<string, WildcardDirectoryWatcher> | undefined;
         readonly canonicalConfigFilePath: NormalizedPath;
 
         /* @internal */
@@ -1814,7 +1814,7 @@ namespace ts.server {
 
         /** Potential project references before the project is actually loaded (read config file) */
         /*@internal*/
-        potentialProjectReferences: Map<true> | undefined;
+        potentialProjectReferences: Map<string, true> | undefined;
 
         /*@internal*/
         projectOptions?: ProjectOptions | true;
@@ -1950,7 +1950,7 @@ namespace ts.server {
         }
 
         /*@internal*/
-        enablePluginsWithOptions(options: CompilerOptions, pluginConfigOverrides: Map<any> | undefined) {
+        enablePluginsWithOptions(options: CompilerOptions, pluginConfigOverrides: Map<string, any> | undefined) {
             const host = this.projectService.host;
 
             if (!host.require) {
@@ -2005,7 +2005,7 @@ namespace ts.server {
         }
 
         /*@internal*/
-        watchWildcards(wildcardDirectories: Map<WatchDirectoryFlags>) {
+        watchWildcards(wildcardDirectories: Map<string, WatchDirectoryFlags>) {
             updateWatchingWildcardDirectories(
                 this.directoriesWatchedForWildcards || (this.directoriesWatchedForWildcards = createMap()),
                 wildcardDirectories,
@@ -2128,7 +2128,7 @@ namespace ts.server {
             lastFileExceededProgramSize: string | undefined,
             public compileOnSaveEnabled: boolean,
             projectFilePath?: string,
-            pluginConfigOverrides?: Map<any>,
+            pluginConfigOverrides?: Map<string, any>,
             watchOptions?: WatchOptions) {
             super(externalProjectName,
                 ProjectKind.External,
diff --git a/src/server/scriptInfo.ts b/src/server/scriptInfo.ts
index 335e283276c10..a6846a8a9c286 100644
--- a/src/server/scriptInfo.ts
+++ b/src/server/scriptInfo.ts
@@ -286,7 +286,7 @@ namespace ts.server {
     /*@internal*/
     export interface SourceMapFileWatcher {
         watcher: FileWatcher;
-        sourceInfos?: Map<true>;
+        sourceInfos?: Map<string, true>;
     }
 
     export class ScriptInfo {
@@ -324,7 +324,7 @@ namespace ts.server {
         /*@internal*/
         declarationInfoPath?: Path;
         /*@internal*/
-        sourceInfos?: Map<true>;
+        sourceInfos?: Map<string, true>;
         /*@internal*/
         documentPositionMapper?: DocumentPositionMapper | false;
 
diff --git a/src/server/session.ts b/src/server/session.ts
index 6aecc217b1c13..4c37851350c6e 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -262,7 +262,7 @@ namespace ts.server {
 
     type Projects = readonly Project[] | {
         readonly projects: readonly Project[];
-        readonly symLinkedProjects: MultiMap<Project>;
+        readonly symLinkedProjects: MultiMap<string, Project>;
     };
 
     /**
@@ -496,7 +496,7 @@ namespace ts.server {
         location: TLocation,
         projectService: ProjectService,
         toDo: ProjectAndLocation<TLocation>[] | undefined,
-        seenProjects: Map<true>,
+        seenProjects: Map<string, true>,
         cb: CombineProjectOutputCallback<TLocation>,
     ): ProjectAndLocation<TLocation>[] | undefined {
         if (project.getCancellationToken().isCancellationRequested()) return undefined; // Skip rest of toDo if cancelled
@@ -526,11 +526,11 @@ namespace ts.server {
         return toDo;
     }
 
-    function addToTodo<TLocation extends DocumentPosition | undefined>(project: Project, location: TLocation, toDo: Push<ProjectAndLocation<TLocation>>, seenProjects: Map<true>): void {
+    function addToTodo<TLocation extends DocumentPosition | undefined>(project: Project, location: TLocation, toDo: Push<ProjectAndLocation<TLocation>>, seenProjects: Map<string, true>): void {
         if (addToSeen(seenProjects, project)) toDo.push({ project, location });
     }
 
-    function addToSeen(seenProjects: Map<true>, project: Project) {
+    function addToSeen(seenProjects: Map<string, true>, project: Project) {
         return ts.addToSeen(seenProjects, getProjectKey(project));
     }
 
@@ -1355,7 +1355,7 @@ namespace ts.server {
 
         private getProjects(args: protocol.FileRequestArgs, getScriptInfoEnsuringProjectsUptoDate?: boolean, ignoreNoProjectError?: boolean): Projects {
             let projects: readonly Project[] | undefined;
-            let symLinkedProjects: MultiMap<Project> | undefined;
+            let symLinkedProjects: MultiMap<string, Project> | undefined;
             if (args.projectFileName) {
                 const project = this.getProject(args.projectFileName);
                 if (project) {
diff --git a/src/server/typingsCache.ts b/src/server/typingsCache.ts
index cb1d811b97edc..dfa86730690ec 100644
--- a/src/server/typingsCache.ts
+++ b/src/server/typingsCache.ts
@@ -41,7 +41,7 @@ namespace ts.server {
         if ((arr1 || emptyArray).length === 0 && (arr2 || emptyArray).length === 0) {
             return true;
         }
-        const set: Map<boolean> = createMap<boolean>();
+        const set: Map<string, boolean> = createMap<boolean>();
         let unique = 0;
 
         for (const v of arr1!) {
@@ -83,7 +83,7 @@ namespace ts.server {
 
     /*@internal*/
     export class TypingsCache {
-        private readonly perProjectCache: Map<TypingsCacheEntry> = createMap<TypingsCacheEntry>();
+        private readonly perProjectCache: Map<string, TypingsCacheEntry> = createMap<TypingsCacheEntry>();
 
         constructor(private readonly installer: ITypingsInstaller) {
         }
diff --git a/src/server/utilities.ts b/src/server/utilities.ts
index 4d6cd9dbf5dd2..651c11555da02 100644
--- a/src/server/utilities.ts
+++ b/src/server/utilities.ts
@@ -1,7 +1,7 @@
 /* @internal */
 namespace ts.server {
     export class ThrottledOperations {
-        private readonly pendingTimeouts: Map<any> = createMap<any>();
+        private readonly pendingTimeouts: Map<string, any> = createMap<any>();
         private readonly logger?: Logger | undefined;
         constructor(private readonly host: ServerHost, logger: Logger) {
             this.logger = logger.hasLevel(LogLevel.verbose) ? logger : undefined;
diff --git a/src/services/codefixes/addMissingAsync.ts b/src/services/codefixes/addMissingAsync.ts
index 2c3e57082309f..484ac29835c6c 100644
--- a/src/services/codefixes/addMissingAsync.ts
+++ b/src/services/codefixes/addMissingAsync.ts
@@ -40,12 +40,12 @@ namespace ts.codefix {
     });
 
     type FixableDeclaration = ArrowFunction | FunctionDeclaration | FunctionExpression | MethodDeclaration;
-    function getFix(context: CodeFixContext | CodeFixAllContext, decl: FixableDeclaration, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<true>) {
+    function getFix(context: CodeFixContext | CodeFixAllContext, decl: FixableDeclaration, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<string, true>) {
         const changes = trackChanges(t => makeChange(t, context.sourceFile, decl, fixedDeclarations));
         return createCodeFixAction(fixId, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId, Diagnostics.Add_all_missing_async_modifiers);
     }
 
-    function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, insertionSite: FixableDeclaration, fixedDeclarations?: Map<true>) {
+    function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, insertionSite: FixableDeclaration, fixedDeclarations?: Map<string, true>) {
         if (fixedDeclarations) {
             if (fixedDeclarations.has(getNodeId(insertionSite).toString())) {
                 return;
diff --git a/src/services/codefixes/addMissingAwait.ts b/src/services/codefixes/addMissingAwait.ts
index fc7c25d3f7db9..69152a0881970 100644
--- a/src/services/codefixes/addMissingAwait.ts
+++ b/src/services/codefixes/addMissingAwait.ts
@@ -58,7 +58,7 @@ namespace ts.codefix {
         },
     });
 
-    function getDeclarationSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<true>) {
+    function getDeclarationSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<string, true>) {
         const { sourceFile, program, cancellationToken } = context;
         const awaitableInitializers = findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker);
         if (awaitableInitializers) {
@@ -79,7 +79,7 @@ namespace ts.codefix {
         }
     }
 
-    function getUseSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<true>) {
+    function getUseSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<string, true>) {
         const changes = trackChanges(t => makeChange(t, errorCode, context.sourceFile, checker, expression, fixedDeclarations));
         return createCodeFixAction(fixId, changes, Diagnostics.Add_await, fixId, Diagnostics.Fix_all_expressions_possibly_missing_await);
     }
@@ -234,7 +234,7 @@ namespace ts.codefix {
                 ancestor.parent.kind === SyntaxKind.MethodDeclaration));
     }
 
-    function makeChange(changeTracker: textChanges.ChangeTracker, errorCode: number, sourceFile: SourceFile, checker: TypeChecker, insertionSite: Expression, fixedDeclarations?: Map<true>) {
+    function makeChange(changeTracker: textChanges.ChangeTracker, errorCode: number, sourceFile: SourceFile, checker: TypeChecker, insertionSite: Expression, fixedDeclarations?: Map<string, true>) {
         if (isBinaryExpression(insertionSite)) {
             for (const side of [insertionSite.left, insertionSite.right]) {
                 if (fixedDeclarations && isIdentifier(side)) {
diff --git a/src/services/codefixes/convertToAsyncFunction.ts b/src/services/codefixes/convertToAsyncFunction.ts
index 72bc3cb2a956a..604bd098ca2a2 100644
--- a/src/services/codefixes/convertToAsyncFunction.ts
+++ b/src/services/codefixes/convertToAsyncFunction.ts
@@ -38,8 +38,8 @@ namespace ts.codefix {
 
     interface Transformer {
         readonly checker: TypeChecker;
-        readonly synthNamesMap: Map<SynthIdentifier>; // keys are the symbol id of the identifier
-        readonly setOfExpressionsToReturn: ReadonlyMap<true>; // keys are the node ids of the expressions
+        readonly synthNamesMap: Map<string, SynthIdentifier>; // keys are the symbol id of the identifier
+        readonly setOfExpressionsToReturn: ReadonlyMap<string, true>; // keys are the node ids of the expressions
         readonly isInJSFile: boolean;
     }
 
@@ -61,7 +61,7 @@ namespace ts.codefix {
             return;
         }
 
-        const synthNamesMap: Map<SynthIdentifier> = createMap();
+        const synthNamesMap: Map<string, SynthIdentifier> = createMap();
         const isInJavascript = isInJSFile(functionToConvert);
         const setOfExpressionsToReturn = getAllPromiseExpressionsToReturn(functionToConvert, checker);
         const functionToConvertRenamed = renameCollidingVarNames(functionToConvert, checker, synthNamesMap, context.sourceFile);
@@ -99,12 +99,12 @@ namespace ts.codefix {
     /*
         Finds all of the expressions of promise type that should not be saved in a variable during the refactor
     */
-    function getAllPromiseExpressionsToReturn(func: FunctionLikeDeclaration, checker: TypeChecker): Map<true> {
+    function getAllPromiseExpressionsToReturn(func: FunctionLikeDeclaration, checker: TypeChecker): Map<string, true> {
         if (!func.body) {
             return createMap<true>();
         }
 
-        const setOfExpressionsToReturn: Map<true> = createMap<true>();
+        const setOfExpressionsToReturn: Map<string, true> = createMap<true>();
         forEachChild(func.body, function visit(node: Node) {
             if (isPromiseReturningCallExpression(node, checker, "then")) {
                 setOfExpressionsToReturn.set(getNodeId(node).toString(), true);
@@ -148,7 +148,7 @@ namespace ts.codefix {
         This function collects all existing identifier names and names of identifiers that will be created in the refactor.
         It then checks for any collisions and renames them through getSynthesizedDeepClone
     */
-    function renameCollidingVarNames(nodeToRename: FunctionLikeDeclaration, checker: TypeChecker, synthNamesMap: Map<SynthIdentifier>, sourceFile: SourceFile): FunctionLikeDeclaration {
+    function renameCollidingVarNames(nodeToRename: FunctionLikeDeclaration, checker: TypeChecker, synthNamesMap: Map<string, SynthIdentifier>, sourceFile: SourceFile): FunctionLikeDeclaration {
         const identsToRenameMap = createMap<Identifier>(); // key is the symbol id
         const collidingSymbolMap = createMultiMap<Symbol>();
         forEachChild(nodeToRename, function visit(node: Node) {
@@ -202,7 +202,7 @@ namespace ts.codefix {
         return getSynthesizedDeepCloneWithRenames(nodeToRename, /*includeTrivia*/ true, identsToRenameMap, checker);
     }
 
-    function getNewNameIfConflict(name: Identifier, originalNames: ReadonlyMap<Symbol[]>): SynthIdentifier {
+    function getNewNameIfConflict(name: Identifier, originalNames: ReadonlyMap<string, Symbol[]>): SynthIdentifier {
         const numVarsSameName = (originalNames.get(name.text) || emptyArray).length;
         const identifier = numVarsSameName === 0 ? name : factory.createIdentifier(name.text + "_" + numVarsSameName);
         return createSynthIdentifier(identifier);
diff --git a/src/services/codefixes/convertToEs6Module.ts b/src/services/codefixes/convertToEs6Module.ts
index 56648e7434856..cd23f55e47537 100644
--- a/src/services/codefixes/convertToEs6Module.ts
+++ b/src/services/codefixes/convertToEs6Module.ts
@@ -60,7 +60,7 @@ namespace ts.codefix {
      *     export { _x as x };
      * This conversion also must place if the exported name is not a valid identifier, e.g. `exports.class = 0;`.
      */
-    type ExportRenames = ReadonlyMap<string>;
+    type ExportRenames = ReadonlyMap<string, string>;
 
     function collectExportRenames(sourceFile: SourceFile, checker: TypeChecker, identifiers: Identifiers): ExportRenames {
         const res = createMap<string>();
@@ -441,10 +441,10 @@ namespace ts.codefix {
     interface Identifiers {
         readonly original: FreeIdentifiers;
         // Additional identifiers we've added. Mutable!
-        readonly additional: Map<true>;
+        readonly additional: Map<string, true>;
     }
 
-    type FreeIdentifiers = ReadonlyMap<readonly Identifier[]>;
+    type FreeIdentifiers = ReadonlyMap<string, readonly Identifier[]>;
     function collectFreeIdentifiers(file: SourceFile): FreeIdentifiers {
         const map = createMultiMap<Identifier>();
         forEachFreeIdentifier(file, id => map.add(id.text, id));
diff --git a/src/services/codefixes/disableJsDiagnostics.ts b/src/services/codefixes/disableJsDiagnostics.ts
index 13b1fec32eec2..8a7e6c516cbc2 100644
--- a/src/services/codefixes/disableJsDiagnostics.ts
+++ b/src/services/codefixes/disableJsDiagnostics.ts
@@ -46,7 +46,7 @@ namespace ts.codefix {
         },
     });
 
-    function makeChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, position: number, seenLines?: Map<true>) {
+    function makeChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, position: number, seenLines?: Map<string, true>) {
         const { line: lineNumber } = getLineAndCharacterOfPosition(sourceFile, position);
         // Only need to add `// @ts-ignore` for a line once.
         if (!seenLines || addToSeen(seenLines, lineNumber)) {
diff --git a/src/services/codefixes/importFixes.ts b/src/services/codefixes/importFixes.ts
index 4de3035f09f8b..cd335082dd728 100644
--- a/src/services/codefixes/importFixes.ts
+++ b/src/services/codefixes/importFixes.ts
@@ -512,7 +512,7 @@ namespace ts.codefix {
         checker: TypeChecker,
         program: Program,
         host: LanguageServiceHost
-    ): ReadonlyMap<readonly SymbolExportInfo[]> {
+    ): ReadonlyMap<string, readonly SymbolExportInfo[]> {
         // For each original symbol, keep all re-exports of that symbol together so we can call `getCodeActionsForImport` on the whole group at once.
         // Maps symbol id to info for modules providing that symbol (original export + re-exports).
         const originalSymbolToExportInfos = createMultiMap<SymbolExportInfo>();
diff --git a/src/services/completions.ts b/src/services/completions.ts
index 2eb444d54b7d5..c3e844317f2d9 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -2354,7 +2354,7 @@ namespace ts.Completions {
             return filteredSymbols;
         }
 
-        function setMembersDeclaredBySpreadAssignment(declaration: SpreadAssignment | JsxSpreadAttribute, membersDeclaredBySpreadAssignment: Map<true>) {
+        function setMembersDeclaredBySpreadAssignment(declaration: SpreadAssignment | JsxSpreadAttribute, membersDeclaredBySpreadAssignment: Map<string, true>) {
             const expression = declaration.expression;
             const symbol = typeChecker.getSymbolAtLocation(expression);
             const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
@@ -2376,7 +2376,7 @@ namespace ts.Completions {
         }
 
         // Set SortText to MemberDeclaredBySpreadAssignment if it is fulfilled by spread assignment
-        function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment: Map<true>, contextualMemberSymbols: Symbol[]): void {
+        function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment: Map<string, true>, contextualMemberSymbols: Symbol[]): void {
             if (membersDeclaredBySpreadAssignment.size === 0) {
                 return;
             }
diff --git a/src/services/documentRegistry.ts b/src/services/documentRegistry.ts
index decb66b5340e4..1f299cdc00043 100644
--- a/src/services/documentRegistry.ts
+++ b/src/services/documentRegistry.ts
@@ -118,7 +118,7 @@ namespace ts {
     export function createDocumentRegistryInternal(useCaseSensitiveFileNames?: boolean, currentDirectory = "", externalCache?: ExternalDocumentCache): DocumentRegistry {
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.
-        const buckets = createMap<Map<DocumentRegistryEntry>>();
+        const buckets = createMap<Map<string, DocumentRegistryEntry>>();
         const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
 
         function reportStats() {
@@ -170,7 +170,7 @@ namespace ts {
             acquiring: boolean,
             scriptKind?: ScriptKind): SourceFile {
 
-            const bucket = getOrUpdate<Map<DocumentRegistryEntry>>(buckets, key, createMap);
+            const bucket = getOrUpdate<Map<string, DocumentRegistryEntry>>(buckets, key, createMap);
             let entry = bucket.get(path);
             const scriptTarget = scriptKind === ScriptKind.JSON ? ScriptTarget.JSON : compilationSettings.target || ScriptTarget.ES5;
             if (!entry && externalCache) {
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 05d85fb708705..940e59acbfa6b 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -287,7 +287,7 @@ namespace ts.FindAllReferences {
         sourceFiles: readonly SourceFile[],
         cancellationToken: CancellationToken,
         options: Options = {},
-        sourceFilesSet: ReadonlyMap<true> = arrayToSet(sourceFiles, f => f.fileName),
+        sourceFilesSet: ReadonlyMap<string, true> = arrayToSet(sourceFiles, f => f.fileName),
     ): readonly Entry[] | undefined {
         return flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet));
     }
@@ -594,7 +594,7 @@ namespace ts.FindAllReferences {
     /** Encapsulates the core find-all-references algorithm. */
     export namespace Core {
         /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */
-        export function getReferencedSymbolsForNode(position: number, node: Node, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options = {}, sourceFilesSet: ReadonlyMap<true> = arrayToSet(sourceFiles, f => f.fileName)): readonly SymbolAndEntries[] | undefined {
+        export function getReferencedSymbolsForNode(position: number, node: Node, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options = {}, sourceFilesSet: ReadonlyMap<string, true> = arrayToSet(sourceFiles, f => f.fileName)): readonly SymbolAndEntries[] | undefined {
             if (options.use === FindReferencesUse.References) {
                 node = getAdjustedReferenceLocation(node);
             }
@@ -651,7 +651,7 @@ namespace ts.FindAllReferences {
             return undefined;
         }
 
-        function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol: Symbol, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options, sourceFilesSet: ReadonlyMap<true>) {
+        function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol: Symbol, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options, sourceFilesSet: ReadonlyMap<string, true>) {
             const moduleSourceFile = (symbol.flags & SymbolFlags.Module) && symbol.declarations && find(symbol.declarations, isSourceFile);
             if (!moduleSourceFile) return undefined;
             const exportEquals = symbol.exports!.get(InternalSymbolName.ExportEquals);
@@ -718,7 +718,7 @@ namespace ts.FindAllReferences {
             return program.getSourceFiles().indexOf(sourceFile);
         }
 
-        function getReferencedSymbolsForModule(program: Program, symbol: Symbol, excludeImportTypeOfExportEquals: boolean, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<true>): SymbolAndEntries[] {
+        function getReferencedSymbolsForModule(program: Program, symbol: Symbol, excludeImportTypeOfExportEquals: boolean, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<string, true>): SymbolAndEntries[] {
             Debug.assert(!!symbol.valueDeclaration);
 
             const references = mapDefined<ModuleReference, Entry>(findModuleReferences(program, sourceFiles, symbol), reference => {
@@ -830,7 +830,7 @@ namespace ts.FindAllReferences {
         }
 
         /** Core find-all-references algorithm for a normal symbol. */
-        function getReferencedSymbolsForSymbol(originalSymbol: Symbol, node: Node | undefined, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<true>, checker: TypeChecker, cancellationToken: CancellationToken, options: Options): SymbolAndEntries[] {
+        function getReferencedSymbolsForSymbol(originalSymbol: Symbol, node: Node | undefined, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<string, true>, checker: TypeChecker, cancellationToken: CancellationToken, options: Options): SymbolAndEntries[] {
             const symbol = node && skipPastExportOrImportSpecifierOrUnion(originalSymbol, node, checker, /*useLocalSymbolForExportSpecifier*/ !isForRenameWithPrefixAndSuffixText(options)) || originalSymbol;
 
             // Compute the meaning from the location and the symbol it references
@@ -972,7 +972,7 @@ namespace ts.FindAllReferences {
 
             constructor(
                 readonly sourceFiles: readonly SourceFile[],
-                readonly sourceFilesSet: ReadonlyMap<true>,
+                readonly sourceFilesSet: ReadonlyMap<string, true>,
                 readonly specialSearchKind: SpecialSearchKind,
                 readonly checker: TypeChecker,
                 readonly cancellationToken: CancellationToken,
@@ -1031,7 +1031,7 @@ namespace ts.FindAllReferences {
             }
 
             // Source file ID → symbol ID → Whether the symbol has been searched for in the source file.
-            private readonly sourceFileToSeenSymbols: Map<true>[] = [];
+            private readonly sourceFileToSeenSymbols: Map<string, true>[] = [];
             /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */
             markSearchedSymbols(sourceFile: SourceFile, symbols: readonly Symbol[]): boolean {
                 const sourceId = getNodeId(sourceFile);
@@ -1754,7 +1754,7 @@ namespace ts.FindAllReferences {
          * @param parent        Another class or interface Symbol
          * @param cachedResults A map of symbol id pairs (i.e. "child,parent") to booleans indicating previous results
          */
-        function explicitlyInheritsFrom(symbol: Symbol, parent: Symbol, cachedResults: Map<boolean>, checker: TypeChecker): boolean {
+        function explicitlyInheritsFrom(symbol: Symbol, parent: Symbol, cachedResults: Map<string, boolean>, checker: TypeChecker): boolean {
             if (symbol === parent) {
                 return true;
             }
diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts
index 6b3da6edc8936..54cfc352781a8 100644
--- a/src/services/importTracker.ts
+++ b/src/services/importTracker.ts
@@ -12,7 +12,7 @@ namespace ts.FindAllReferences {
     export type ImportTracker = (exportSymbol: Symbol, exportInfo: ExportInfo, isForRename: boolean) => ImportsResult;
 
     /** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily.  */
-    export function createImportTracker(sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<true>, checker: TypeChecker, cancellationToken: CancellationToken | undefined): ImportTracker {
+    export function createImportTracker(sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<string, true>, checker: TypeChecker, cancellationToken: CancellationToken | undefined): ImportTracker {
         const allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken);
         return (exportSymbol, exportInfo, isForRename) => {
             const { directImports, indirectUsers } = getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, exportInfo, checker, cancellationToken);
@@ -39,8 +39,8 @@ namespace ts.FindAllReferences {
     /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */
     function getImportersForExport(
         sourceFiles: readonly SourceFile[],
-        sourceFilesSet: ReadonlyMap<true>,
-        allDirectImports: Map<ImporterOrCallExpression[]>,
+        sourceFilesSet: ReadonlyMap<string, true>,
+        allDirectImports: Map<string, ImporterOrCallExpression[]>,
         { exportingModuleSymbol, exportKind }: ExportInfo,
         checker: TypeChecker,
         cancellationToken: CancellationToken | undefined,
@@ -368,7 +368,7 @@ namespace ts.FindAllReferences {
     }
 
     /** Returns a map from a module symbol Id to all import statements that directly reference the module. */
-    function getDirectImportsMap(sourceFiles: readonly SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken | undefined): Map<ImporterOrCallExpression[]> {
+    function getDirectImportsMap(sourceFiles: readonly SourceFile[], checker: TypeChecker, cancellationToken: CancellationToken | undefined): Map<string, ImporterOrCallExpression[]> {
         const map = createMap<ImporterOrCallExpression[]>();
 
         for (const sourceFile of sourceFiles) {
diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index a8fc64e53905d..b99b891cb169e 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -33,8 +33,8 @@ namespace ts.NavigationBar {
     let parentsStack: NavigationBarNode[] = [];
     let parent: NavigationBarNode;
 
-    const trackedEs5ClassesStack: (Map<boolean> | undefined)[] = [];
-    let trackedEs5Classes: Map<boolean> | undefined;
+    const trackedEs5ClassesStack: (Map<string, boolean> | undefined)[] = [];
+    let trackedEs5Classes: Map<string, boolean> | undefined;
 
     // NavigationBarItem requires an array, but will not mutate it, so just give it this for performance.
     let emptyChildItemArray: NavigationBarItem[] = [];
diff --git a/src/services/patternMatcher.ts b/src/services/patternMatcher.ts
index 254a684fc4975..e6fda18ab3c9c 100644
--- a/src/services/patternMatcher.ts
+++ b/src/services/patternMatcher.ts
@@ -115,7 +115,7 @@ namespace ts {
         };
     }
 
-    function getFullMatch(candidateContainers: readonly string[], candidate: string, dotSeparatedSegments: readonly Segment[], stringToWordSpans: Map<TextSpan[]>): PatternMatch | undefined {
+    function getFullMatch(candidateContainers: readonly string[], candidate: string, dotSeparatedSegments: readonly Segment[], stringToWordSpans: Map<string, TextSpan[]>): PatternMatch | undefined {
         // First, check that the last part of the dot separated pattern matches the name of the
         // candidate.  If not, then there's no point in proceeding and doing the more
         // expensive work.
@@ -141,7 +141,7 @@ namespace ts {
         return bestMatch;
     }
 
-    function getWordSpans(word: string, stringToWordSpans: Map<TextSpan[]>): TextSpan[] {
+    function getWordSpans(word: string, stringToWordSpans: Map<string, TextSpan[]>): TextSpan[] {
         let spans = stringToWordSpans.get(word);
         if (!spans) {
             stringToWordSpans.set(word, spans = breakIntoWordSpans(word));
@@ -149,7 +149,7 @@ namespace ts {
         return spans;
     }
 
-    function matchTextChunk(candidate: string, chunk: TextChunk, stringToWordSpans: Map<TextSpan[]>): PatternMatch | undefined {
+    function matchTextChunk(candidate: string, chunk: TextChunk, stringToWordSpans: Map<string, TextSpan[]>): PatternMatch | undefined {
         const index = indexOfIgnoringCase(candidate, chunk.textLowerCase);
         if (index === 0) {
             // a) Check if the word is a prefix of the candidate, in a case insensitive or
@@ -201,7 +201,7 @@ namespace ts {
         }
     }
 
-    function matchSegment(candidate: string, segment: Segment, stringToWordSpans: Map<TextSpan[]>): PatternMatch | undefined {
+    function matchSegment(candidate: string, segment: Segment, stringToWordSpans: Map<string, TextSpan[]>): PatternMatch | undefined {
         // First check if the segment matches as is.  This is also useful if the segment contains
         // characters we would normally strip when splitting into parts that we also may want to
         // match in the candidate.  For example if the segment is "@int" and the candidate is
diff --git a/src/services/refactorProvider.ts b/src/services/refactorProvider.ts
index 1418cb53807b6..f88613ecea7f6 100644
--- a/src/services/refactorProvider.ts
+++ b/src/services/refactorProvider.ts
@@ -2,7 +2,7 @@
 namespace ts.refactor {
     // A map with the refactor code as key, the refactor itself as value
     // e.g.  nonSuggestableRefactors[refactorCode] -> the refactor you want
-    const refactors: Map<Refactor> = createMap<Refactor>();
+    const refactors: Map<string, Refactor> = createMap<Refactor>();
 
     /** @param name An unique code associated with each refactor. Does not have to be human-readable. */
     export function registerRefactor(name: string, refactor: Refactor) {
diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts
index fcccf5a72a382..b79437b7063bb 100644
--- a/src/services/refactors/extractSymbol.ts
+++ b/src/services/refactors/extractSymbol.ts
@@ -22,10 +22,10 @@ namespace ts.refactor.extractSymbol {
         }
 
         const functionActions: RefactorActionInfo[] = [];
-        const usedFunctionNames: Map<boolean> = createMap();
+        const usedFunctionNames: Map<string, boolean> = createMap();
 
         const constantActions: RefactorActionInfo[] = [];
-        const usedConstantNames: Map<boolean> = createMap();
+        const usedConstantNames: Map<string, boolean> = createMap();
 
         let i = 0;
         for (const { functionExtraction, constantExtraction } of extractions) {
@@ -1263,7 +1263,7 @@ namespace ts.refactor.extractSymbol {
         }
     }
 
-    function transformFunctionBody(body: Node, exposedVariableDeclarations: readonly VariableDeclaration[], writes: readonly UsageEntry[] | undefined, substitutions: ReadonlyMap<Node>, hasReturn: boolean): { body: Block, returnValueProperty: string | undefined } {
+    function transformFunctionBody(body: Node, exposedVariableDeclarations: readonly VariableDeclaration[], writes: readonly UsageEntry[] | undefined, substitutions: ReadonlyMap<string, Node>, hasReturn: boolean): { body: Block, returnValueProperty: string | undefined } {
         const hasWritesOrVariableDeclarations = writes !== undefined || exposedVariableDeclarations.length > 0;
         if (isBlock(body) && !hasWritesOrVariableDeclarations && substitutions.size === 0) {
             // already block, no declarations or writes to propagate back, no substitutions - can use node as is
@@ -1319,7 +1319,7 @@ namespace ts.refactor.extractSymbol {
         }
     }
 
-    function transformConstantInitializer(initializer: Expression, substitutions: ReadonlyMap<Node>): Expression {
+    function transformConstantInitializer(initializer: Expression, substitutions: ReadonlyMap<string, Node>): Expression {
         return substitutions.size
             ? visitor(initializer) as Expression
             : initializer;
@@ -1467,9 +1467,9 @@ namespace ts.refactor.extractSymbol {
     }
 
     interface ScopeUsages {
-        readonly usages: Map<UsageEntry>;
-        readonly typeParameterUsages: Map<TypeParameter>; // Key is type ID
-        readonly substitutions: Map<Node>;
+        readonly usages: Map<string, UsageEntry>;
+        readonly typeParameterUsages: Map<string, TypeParameter>; // Key is type ID
+        readonly substitutions: Map<string, Node>;
     }
 
     interface ReadsAndWrites {
@@ -1489,7 +1489,7 @@ namespace ts.refactor.extractSymbol {
 
         const allTypeParameterUsages = createMap<TypeParameter>(); // Key is type ID
         const usagesPerScope: ScopeUsages[] = [];
-        const substitutionsPerScope: Map<Node>[] = [];
+        const substitutionsPerScope: Map<string, Node>[] = [];
         const functionErrorsPerScope: Diagnostic[][] = [];
         const constantErrorsPerScope: Diagnostic[][] = [];
         const visibleDeclarationsInExtractedRange: NamedDeclaration[] = [];
diff --git a/src/services/services.ts b/src/services/services.ts
index 92d8336d2f667..40a7095e822e2 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -634,13 +634,13 @@ namespace ts {
         public scriptKind!: ScriptKind;
         public languageVersion!: ScriptTarget;
         public languageVariant!: LanguageVariant;
-        public identifiers!: Map<string>;
+        public identifiers!: Map<string, string>;
         public nameTable: UnderscoreEscapedMap<number> | undefined;
-        public resolvedModules: Map<ResolvedModuleFull> | undefined;
-        public resolvedTypeReferenceDirectiveNames!: Map<ResolvedTypeReferenceDirective>;
+        public resolvedModules: Map<string, ResolvedModuleFull> | undefined;
+        public resolvedTypeReferenceDirectiveNames!: Map<string, ResolvedTypeReferenceDirective>;
         public imports!: readonly StringLiteralLike[];
         public moduleAugmentations!: StringLiteral[];
-        private namedDeclarations: Map<Declaration[]> | undefined;
+        private namedDeclarations: Map<string, Declaration[]> | undefined;
         public ambientModuleNames!: string[];
         public checkJsDirective: CheckJsDirective | undefined;
         public errorExpectations: TextRange[] | undefined;
@@ -686,7 +686,7 @@ namespace ts {
             return fullText[lastCharPos] === "\n" && fullText[lastCharPos - 1] === "\r" ? lastCharPos - 1 : lastCharPos;
         }
 
-        public getNamedDeclarations(): Map<Declaration[]> {
+        public getNamedDeclarations(): Map<string, Declaration[]> {
             if (!this.namedDeclarations) {
                 this.namedDeclarations = this.computeNamedDeclarations();
             }
@@ -694,7 +694,7 @@ namespace ts {
             return this.namedDeclarations;
         }
 
-        private computeNamedDeclarations(): Map<Declaration[]> {
+        private computeNamedDeclarations(): Map<string, Declaration[]> {
             const result = createMultiMap<Declaration>();
 
             this.forEachChild(visit);
@@ -937,7 +937,7 @@ namespace ts {
     // at each language service public entry point, since we don't know when
     // the set of scripts handled by the host changes.
     class HostCache {
-        private fileNameToEntry: Map<CachedHostFileInformation>;
+        private fileNameToEntry: Map<string, CachedHostFileInformation>;
         private _compilationSettings: CompilerOptions;
         private currentDirectory: string;
 
diff --git a/src/services/shims.ts b/src/services/shims.ts
index 5bca205d825b0..4c60639bdab88 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -25,11 +25,11 @@ namespace ts {
         fileNames: string[];                            // The file names that belong to the same project.
         projectRootPath: string;                        // The path to the project root directory
         safeListPath: string;                           // The path used to retrieve the safe list
-        packageNameToTypingLocation: Map<JsTyping.CachedTyping>;       // The map of package names to their cached typing locations and installed versions
+        packageNameToTypingLocation: Map<string, JsTyping.CachedTyping>;       // The map of package names to their cached typing locations and installed versions
         typeAcquisition: TypeAcquisition;               // Used to customize the type acquisition process
         compilerOptions: CompilerOptions;               // Used as a source for typing inference
         unresolvedImports: readonly string[];       // List of unresolved module ids from imports
-        typesRegistry: ReadonlyMap<MapLike<string>>;    // The map of available typings in npm to maps of TS versions to their latest supported versions
+        typesRegistry: ReadonlyMap<string, MapLike<string>>;    // The map of available typings in npm to maps of TS versions to their latest supported versions
     }
 
     export interface ScriptSnapshotShim {
diff --git a/src/services/types.ts b/src/services/types.ts
index 757122aa2a309..3c165832ef27b 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -92,7 +92,7 @@ namespace ts {
         /* @internal */ scriptSnapshot: IScriptSnapshot | undefined;
         /* @internal */ nameTable: UnderscoreEscapedMap<number> | undefined;
 
-        /* @internal */ getNamedDeclarations(): Map<readonly Declaration[]>;
+        /* @internal */ getNamedDeclarations(): Map<string, readonly Declaration[]>;
 
         getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
         getLineEndOfPosition(pos: number): number;
@@ -195,10 +195,10 @@ namespace ts {
     /* @internal */
     export interface PackageJsonInfo {
         fileName: string;
-        dependencies?: Map<string>;
-        devDependencies?: Map<string>;
-        peerDependencies?: Map<string>;
-        optionalDependencies?: Map<string>;
+        dependencies?: Map<string, string>;
+        devDependencies?: Map<string, string>;
+        peerDependencies?: Map<string, string>;
+        optionalDependencies?: Map<string, string>;
         get(dependencyName: string, inGroups?: PackageJsonDependencyGroup): string | undefined;
         has(dependencyName: string, inGroups?: PackageJsonDependencyGroup): boolean;
     }
@@ -258,7 +258,7 @@ namespace ts {
         /* @internal */
         getGlobalTypingsCacheLocation?(): string | undefined;
         /* @internal */
-        getProbableSymlinks?(files: readonly SourceFile[]): ReadonlyMap<string>;
+        getProbableSymlinks?(files: readonly SourceFile[]): ReadonlyMap<string, string>;
 
         /*
          * Required for full import and type reference completions.
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 5b9c2b1738016..ebeeb2187f330 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -2191,7 +2191,7 @@ namespace ts {
         return clone;
     }
 
-    export function getSynthesizedDeepCloneWithRenames<T extends Node>(node: T, includeTrivia = true, renameMap?: Map<Identifier>, checker?: TypeChecker, callback?: (originalNode: Node, clone: Node) => any): T {
+    export function getSynthesizedDeepCloneWithRenames<T extends Node>(node: T, includeTrivia = true, renameMap?: Map<string, Identifier>, checker?: TypeChecker, callback?: (originalNode: Node, clone: Node) => any): T {
         let clone;
         if (renameMap && checker && isBindingElement(node) && isIdentifier(node.name) && isObjectBindingPattern(node.parent)) {
             const symbol = checker.getSymbolAtLocation(node.name);
@@ -2227,7 +2227,7 @@ namespace ts {
     }
 
 
-    function getSynthesizedDeepCloneWorker<T extends Node>(node: T, renameMap?: Map<Identifier>, checker?: TypeChecker, callback?: (originalNode: Node, clone: Node) => any): T {
+    function getSynthesizedDeepCloneWorker<T extends Node>(node: T, renameMap?: Map<string, Identifier>, checker?: TypeChecker, callback?: (originalNode: Node, clone: Node) => any): T {
         const visited = (renameMap || checker || callback) ?
             visitEachChild(node, wrapper, nullTransformationContext) :
             visitEachChild(node, getSynthesizedDeepClone, nullTransformationContext);
diff --git a/src/shims/collectionShims.ts b/src/shims/collectionShims.ts
index e54c6fa470494..a1f478de9cee4 100644
--- a/src/shims/collectionShims.ts
+++ b/src/shims/collectionShims.ts
@@ -4,31 +4,41 @@ namespace ts {
         next(): { value: T, done?: false } | { value: never, done: true };
     }
 
-    interface MapShim<K, V> {
+    interface ReadonlyMapShim<K, V> {
         readonly size: number;
         get(key: K): V | undefined;
-        set(key: K, value: V): this;
         has(key: K): boolean;
-        delete(key: K): boolean;
-        clear(): void;
         keys(): IteratorShim<K>;
         values(): IteratorShim<V>;
         entries(): IteratorShim<[K, V]>;
         forEach(action: (value: V, key: K) => void): void;
     }
 
-    interface SetShim<T> {
+    interface MapShim<K, V> extends ReadonlyMapShim<K, V> {
+        set(key: K, value: V): this;
+        delete(key: K): boolean;
+        clear(): void;
+    }
+
+    type MapShimConstructor = new <K, V>(iterable?: readonly (readonly [K, V])[] | ReadonlyMapShim<K, V>) => MapShim<K, V>;
+
+    interface ReadonlySetShim<T> {
         readonly size: number;
-        add(value: T): this;
-        delete(value: T): boolean;
         has(value: T): boolean;
-        clear(): void;
         keys(): IteratorShim<T>;
         values(): IteratorShim<T>;
         entries(): IteratorShim<[T, T]>;
         forEach(action: (value: T, key: T) => void): void;
     }
 
+    interface SetShim<T> extends ReadonlySetShim<T> {
+        add(value: T): this;
+        delete(value: T): boolean;
+        clear(): void;
+    }
+
+    type SetShimConstructor = new <T>(iterable?: readonly T[] | ReadonlySetShim<T>) => SetShim<T>;
+
     interface WeakMapShim<K extends object, V> {
         get(key: K): V | undefined;
         has(key: K): boolean;
@@ -400,10 +410,26 @@ namespace ts {
     function pickEntry<K, V>(key: K, value: V) { return [key, value] as [K, V]; }
 
     /* @internal */
-    export function createMapShim(): new <K, V>() => MapShim<K, V> {
+    export function createMapShim(): MapShimConstructor {
         const MapIterator = createIterator("MapIterator");
         class Map<K, V> implements MapShim<K, V> {
             private _mapData = createMapData<K, V>();
+            constructor(iterable?: readonly (readonly [K, V])[] | ReadonlyMapShim<K, V>) {
+                if (iterable) {
+                    if ((Array.isArray as (value: any) => value is readonly any[])(iterable)) {
+                        for (const [key, value] of iterable) {
+                            this.set(key, value);
+                        }
+                    }
+                    else {
+                        const iterator = iterable.entries();
+                        for (let result = iterator.next(); !result.done; result = iterator.next()) {
+                            const [key, value] = result.value;
+                            this.set(key, value);
+                        }
+                    }
+                }
+            }
             get size() { return this._mapData.size; }
             get(key: K): V | undefined { return getEntry(this._mapData, key)?.value; }
             set(key: K, value: V): this { return addOrUpdateEntry(this._mapData, key, value), this; }
@@ -420,10 +446,25 @@ namespace ts {
     }
 
     /* @internal */
-    export function createSetShim(): new <T>() => SetShim<T> {
+    export function createSetShim(): SetShimConstructor {
         const SetIterator = createIterator("SetIterator");
         class Set<T> implements SetShim<T> {
             private _mapData = createMapData<T, T>();
+            constructor(iterable?: readonly T[] | ReadonlySetShim<T>) {
+                if (iterable) {
+                    if ((Array.isArray as (value: any) => value is readonly any[])(iterable)) {
+                        for (const value of iterable) {
+                            this.add(value);
+                        }
+                    }
+                    else {
+                        const iterator = iterable.values();
+                        for (let result = iterator.next(); !result.done; result = iterator.next()) {
+                            this.add(result.value);
+                        }
+                    }
+                }
+            }
             get size() { return this._mapData.size; }
             add(value: T): this { return addOrUpdateEntry(this._mapData, value, value), this; }
             has(value: T): boolean { return hasEntry(this._mapData, value); }
diff --git a/src/testRunner/parallel/worker.ts b/src/testRunner/parallel/worker.ts
index c1afd8df67c24..2e985ec8bed5c 100644
--- a/src/testRunner/parallel/worker.ts
+++ b/src/testRunner/parallel/worker.ts
@@ -301,9 +301,9 @@ namespace Harness.Parallel.Worker {
 
         // The root suite for all unit tests.
         let unitTestSuite: Suite;
-        let unitTestSuiteMap: ts.Map<Mocha.Suite>;
+        let unitTestSuiteMap: ts.Map<string, Mocha.Suite>;
         // (Unit) Tests directly within the root suite
-        let unitTestTestMap: ts.Map<Mocha.Test>;
+        let unitTestTestMap: ts.Map<string, Mocha.Test>;
 
         if (runUnitTests) {
             unitTestSuite = new Suite("", new Mocha.Context());
diff --git a/src/testRunner/unittests/config/commandLineParsing.ts b/src/testRunner/unittests/config/commandLineParsing.ts
index beff197912bf0..97de804b5ab91 100644
--- a/src/testRunner/unittests/config/commandLineParsing.ts
+++ b/src/testRunner/unittests/config/commandLineParsing.ts
@@ -493,7 +493,7 @@ namespace ts {
             }
 
             interface VerifyNullNonIncludedOption {
-                type: () => "string" | "number" | Map<number | string>;
+                type: () => "string" | "number" | Map<string, number | string>;
                 nonNullValue?: string;
             }
             function verifyNullNonIncludedOption({ type, nonNullValue }: VerifyNullNonIncludedOption) {
diff --git a/src/testRunner/unittests/createMapShim.ts b/src/testRunner/unittests/createMapShim.ts
index e335816ea72ee..dc8f1c3dd87d2 100644
--- a/src/testRunner/unittests/createMapShim.ts
+++ b/src/testRunner/unittests/createMapShim.ts
@@ -35,7 +35,7 @@ namespace ts {
             "Y"
         ];
 
-        function testMapIterationAddedValues<K>(keys: K[], map: ESMap<K, string>, useForEach: boolean): string {
+        function testMapIterationAddedValues<K>(keys: K[], map: Map<K, string>, useForEach: boolean): string {
             let resultString = "";
 
             map.set(keys[0], "1");
diff --git a/src/testRunner/unittests/moduleResolution.ts b/src/testRunner/unittests/moduleResolution.ts
index 7bf5e811bd304..01cb547df001e 100644
--- a/src/testRunner/unittests/moduleResolution.ts
+++ b/src/testRunner/unittests/moduleResolution.ts
@@ -458,7 +458,7 @@ namespace ts {
     });
 
     describe("unittests:: moduleResolution:: Relative imports", () => {
-        function test(files: Map<string>, currentDirectory: string, rootFiles: string[], expectedFilesCount: number, relativeNamesToCheck: string[]) {
+        function test(files: Map<string, string>, currentDirectory: string, rootFiles: string[], expectedFilesCount: number, relativeNamesToCheck: string[]) {
             const options: CompilerOptions = { module: ModuleKind.CommonJS };
             const host: CompilerHost = {
                 getSourceFile: (fileName: string, languageVersion: ScriptTarget) => {
@@ -533,7 +533,7 @@ export = C;
     describe("unittests:: moduleResolution:: Files with different casing with forceConsistentCasingInFileNames", () => {
         let library: SourceFile;
         function test(
-            files: Map<string>,
+            files: Map<string, string>,
             options: CompilerOptions,
             currentDirectory: string,
             useCaseSensitiveFileNames: boolean,
diff --git a/src/testRunner/unittests/programApi.ts b/src/testRunner/unittests/programApi.ts
index 8b13792d35ea5..170235b8308a1 100644
--- a/src/testRunner/unittests/programApi.ts
+++ b/src/testRunner/unittests/programApi.ts
@@ -1,7 +1,7 @@
 namespace ts {
     function verifyMissingFilePaths(missingPaths: readonly Path[], expected: readonly string[]) {
         assert.isDefined(missingPaths);
-        const map = arrayToSet(expected) as Map<boolean>;
+        const map = arrayToSet(expected) as Map<string, boolean>;
         for (const missing of missingPaths) {
             const value = map.get(missing);
             assert.isTrue(value, `${missing} to be ${value === undefined ? "not present" : "present only once"}, in actual: ${missingPaths} expected: ${expected}`);
diff --git a/src/testRunner/unittests/reuseProgramStructure.ts b/src/testRunner/unittests/reuseProgramStructure.ts
index cc4f6fadb785a..9ae4de199e212 100644
--- a/src/testRunner/unittests/reuseProgramStructure.ts
+++ b/src/testRunner/unittests/reuseProgramStructure.ts
@@ -175,7 +175,7 @@ namespace ts {
         return true;
     }
 
-    function checkCache<T>(caption: string, program: Program, fileName: string, expectedContent: Map<T> | undefined, getCache: (f: SourceFile) => Map<T> | undefined, entryChecker: (expected: T, original: T) => boolean): void {
+    function checkCache<T>(caption: string, program: Program, fileName: string, expectedContent: Map<string, T> | undefined, getCache: (f: SourceFile) => Map<string, T> | undefined, entryChecker: (expected: T, original: T) => boolean): void {
         const file = program.getSourceFile(fileName);
         assert.isTrue(file !== undefined, `cannot find file ${fileName}`);
         const cache = getCache(file!);
@@ -189,7 +189,7 @@ namespace ts {
     }
 
     /** True if the maps have the same keys and values. */
-    function mapsAreEqual<T>(left: Map<T>, right: Map<T>, valuesAreEqual?: (left: T, right: T) => boolean): boolean {
+    function mapsAreEqual<T>(left: Map<string, T>, right: Map<string, T>, valuesAreEqual?: (left: T, right: T) => boolean): boolean {
         if (left === right) return true;
         if (!left || !right) return false;
         const someInLeftHasNoMatch = forEachEntry(left, (leftValue, leftKey) => {
@@ -202,11 +202,11 @@ namespace ts {
         return !someInRightHasNoMatch;
     }
 
-    function checkResolvedModulesCache(program: Program, fileName: string, expectedContent: Map<ResolvedModule | undefined> | undefined): void {
+    function checkResolvedModulesCache(program: Program, fileName: string, expectedContent: Map<string, ResolvedModule | undefined> | undefined): void {
         checkCache("resolved modules", program, fileName, expectedContent, f => f.resolvedModules, checkResolvedModule);
     }
 
-    function checkResolvedTypeDirectivesCache(program: Program, fileName: string, expectedContent: Map<ResolvedTypeReferenceDirective> | undefined): void {
+    function checkResolvedTypeDirectivesCache(program: Program, fileName: string, expectedContent: Map<string, ResolvedTypeReferenceDirective> | undefined): void {
         checkCache("resolved type directives", program, fileName, expectedContent, f => f.resolvedTypeReferenceDirectiveNames, checkResolvedTypeDirective);
     }
 
diff --git a/src/testRunner/unittests/services/extract/helpers.ts b/src/testRunner/unittests/services/extract/helpers.ts
index a47875299946d..9d37b205a4d35 100644
--- a/src/testRunner/unittests/services/extract/helpers.ts
+++ b/src/testRunner/unittests/services/extract/helpers.ts
@@ -7,7 +7,7 @@ namespace ts {
 
     interface Test {
         source: string;
-        ranges: Map<Range>;
+        ranges: Map<string, Range>;
     }
 
     export function extractTest(source: string): Test {
diff --git a/src/testRunner/unittests/tsbuild/helpers.ts b/src/testRunner/unittests/tsbuild/helpers.ts
index 2fcca3613d1ed..95b22ff8900ed 100644
--- a/src/testRunner/unittests/tsbuild/helpers.ts
+++ b/src/testRunner/unittests/tsbuild/helpers.ts
@@ -186,7 +186,7 @@ interface Symbol {
         }
     }
 
-    export function generateSourceMapBaselineFiles(sys: System & { writtenFiles: Map<any>; }) {
+    export function generateSourceMapBaselineFiles(sys: System & { writtenFiles: Map<string, any>; }) {
         const mapFileNames = mapDefinedIterator(sys.writtenFiles.keys(), f => f.endsWith(".map") ? f : undefined);
         while (true) {
             const { value: mapFile, done } = mapFileNames.next();
@@ -237,7 +237,7 @@ interface Symbol {
 
     export function baselineBuildInfo(
         options: CompilerOptions,
-        sys: System & { writtenFiles: Map<any>; },
+        sys: System & { writtenFiles: Map<string, any>; },
         originalReadCall?: System["readFile"]
     ) {
         const out = outFile(options);
diff --git a/src/testRunner/unittests/tsbuild/watchEnvironment.ts b/src/testRunner/unittests/tsbuild/watchEnvironment.ts
index f3c076b09ac0c..3fc9e1d8aba52 100644
--- a/src/testRunner/unittests/tsbuild/watchEnvironment.ts
+++ b/src/testRunner/unittests/tsbuild/watchEnvironment.ts
@@ -11,7 +11,7 @@ namespace ts.tscWatch {
             );
         });
 
-        function verifyWatchFileOnMultipleProjects(singleWatchPerFile: boolean, environmentVariables?: Map<string>) {
+        function verifyWatchFileOnMultipleProjects(singleWatchPerFile: boolean, environmentVariables?: Map<string, string>) {
             it("watchFile on same file multiple times because file is part of multiple projects", () => {
                 const project = `${TestFSWithWatch.tsbuildProjectsLocation}/myproject`;
                 let maxPkgs = 4;
diff --git a/src/testRunner/unittests/tsc/helpers.ts b/src/testRunner/unittests/tsc/helpers.ts
index 93299b917da7f..88c33ca0eb648 100644
--- a/src/testRunner/unittests/tsc/helpers.ts
+++ b/src/testRunner/unittests/tsc/helpers.ts
@@ -1,6 +1,6 @@
 namespace ts {
     export type TscCompileSystem = fakes.System & {
-        writtenFiles: Map<true>;
+        writtenFiles: Map<string, true>;
         baseLine(): { file: string; text: string; };
     };
 
@@ -44,7 +44,7 @@ namespace ts {
         return !!(program as Program | EmitAndSemanticDiagnosticsBuilderProgram).getCompilerOptions;
     }
     export function commandLineCallbacks(
-        sys: System & { writtenFiles: Map<any>; },
+        sys: System & { writtenFiles: Map<string, any>; },
         originalReadCall?: System["readFile"]
     ): CommandLineCallbacks {
         let programs: CommandLineProgram[] | undefined;
diff --git a/src/testRunner/unittests/tsserver/cachingFileSystemInformation.ts b/src/testRunner/unittests/tsserver/cachingFileSystemInformation.ts
index ed15145cf9cce..5af74cc61f958 100644
--- a/src/testRunner/unittests/tsserver/cachingFileSystemInformation.ts
+++ b/src/testRunner/unittests/tsserver/cachingFileSystemInformation.ts
@@ -16,7 +16,7 @@ namespace ts.projectSystem {
         type CalledMaps = CalledMapsWithSingleArg | CalledMapsWithFiveArgs;
         type CalledWithFiveArgs = [readonly string[], readonly string[], readonly string[], number];
         function createCallsTrackingHost(host: TestServerHost) {
-            const calledMaps: Record<CalledMapsWithSingleArg, MultiMap<true>> & Record<CalledMapsWithFiveArgs, MultiMap<CalledWithFiveArgs>> = {
+            const calledMaps: Record<CalledMapsWithSingleArg, MultiMap<string, true>> & Record<CalledMapsWithFiveArgs, MultiMap<string, CalledWithFiveArgs>> = {
                 fileExists: setCallsTrackingWithSingleArgFn(CalledMapsWithSingleArg.fileExists),
                 directoryExists: setCallsTrackingWithSingleArgFn(CalledMapsWithSingleArg.directoryExists),
                 getDirectories: setCallsTrackingWithSingleArgFn(CalledMapsWithSingleArg.getDirectories),
@@ -65,7 +65,7 @@ namespace ts.projectSystem {
                 assert.equal(calledMap.size, 0, `${callback} shouldn't be called: ${arrayFrom(calledMap.keys())}`);
             }
 
-            function verifyCalledOnEachEntry(callback: CalledMaps, expectedKeys: Map<number>) {
+            function verifyCalledOnEachEntry(callback: CalledMaps, expectedKeys: Map<string, number>) {
                 TestFSWithWatch.checkMap<true | CalledWithFiveArgs>(callback, calledMaps[callback], expectedKeys);
             }
 
diff --git a/src/testRunner/unittests/tsserver/helpers.ts b/src/testRunner/unittests/tsserver/helpers.ts
index 992ca05c5ec0f..2523c8c724fd8 100644
--- a/src/testRunner/unittests/tsserver/helpers.ts
+++ b/src/testRunner/unittests/tsserver/helpers.ts
@@ -165,7 +165,7 @@ namespace ts.projectSystem {
         return JSON.stringify({ dependencies });
     }
 
-    export function createTypesRegistry(...list: string[]): Map<MapLike<string>> {
+    export function createTypesRegistry(...list: string[]): Map<string, MapLike<string>> {
         const versionMap = {
             "latest": "1.3.0",
             "ts2.0": "1.0.0",
diff --git a/src/testRunner/unittests/tsserver/symLinks.ts b/src/testRunner/unittests/tsserver/symLinks.ts
index 3b8eb07d1ee69..9b79e1e58609b 100644
--- a/src/testRunner/unittests/tsserver/symLinks.ts
+++ b/src/testRunner/unittests/tsserver/symLinks.ts
@@ -161,7 +161,7 @@ new C();`
                 });
             }
 
-            function verifyWatchedFilesAndDirectories(host: TestServerHost, files: string[], recursiveDirectories: ReadonlyMap<number>, nonRecursiveDirectories: string[]) {
+            function verifyWatchedFilesAndDirectories(host: TestServerHost, files: string[], recursiveDirectories: ReadonlyMap<string, number>, nonRecursiveDirectories: string[]) {
                 checkWatchedFilesDetailed(host, files.filter(f => f !== recognizersDateTimeSrcFile.path), 1);
                 checkWatchedDirectoriesDetailed(host, nonRecursiveDirectories, 1, /*recursive*/ false);
                 checkWatchedDirectoriesDetailed(host, recursiveDirectories, /*recursive*/ true);
diff --git a/src/testRunner/unittests/tsserver/typingsInstaller.ts b/src/testRunner/unittests/tsserver/typingsInstaller.ts
index 2120e86836d27..1efa5fec21275 100644
--- a/src/testRunner/unittests/tsserver/typingsInstaller.ts
+++ b/src/testRunner/unittests/tsserver/typingsInstaller.ts
@@ -5,7 +5,7 @@ namespace ts.projectSystem {
     interface InstallerParams {
         globalTypingsCacheLocation?: string;
         throttleLimit?: number;
-        typesRegistry?: Map<MapLike<string>>;
+        typesRegistry?: Map<string, MapLike<string>>;
     }
 
     class Installer extends TestTypingsInstaller {
diff --git a/src/tsserver/server.ts b/src/tsserver/server.ts
index 36f7869b4f1d4..43961eb0ba597 100644
--- a/src/tsserver/server.ts
+++ b/src/tsserver/server.ts
@@ -233,7 +233,7 @@ namespace ts.server {
         private requestMap = createMap<QueuedOperation>(); // Maps operation ID to newest requestQueue entry with that ID
         /** We will lazily request the types registry on the first call to `isKnownTypesPackageName` and store it in `typesRegistryCache`. */
         private requestedRegistry = false;
-        private typesRegistryCache: Map<MapLike<string>> | undefined;
+        private typesRegistryCache: Map<string, MapLike<string>> | undefined;
 
         // This number is essentially arbitrary.  Processing more than one typings request
         // at a time makes sense, but having too many in the pipe results in a hang
diff --git a/src/typingsInstaller/nodeTypingsInstaller.ts b/src/typingsInstaller/nodeTypingsInstaller.ts
index a59e8ec4b9d39..cac11df704336 100644
--- a/src/typingsInstaller/nodeTypingsInstaller.ts
+++ b/src/typingsInstaller/nodeTypingsInstaller.ts
@@ -46,7 +46,7 @@ namespace ts.server.typingsInstaller {
         entries: MapLike<MapLike<string>>;
     }
 
-    function loadTypesRegistryFile(typesRegistryFilePath: string, host: InstallTypingHost, log: Log): Map<MapLike<string>> {
+    function loadTypesRegistryFile(typesRegistryFilePath: string, host: InstallTypingHost, log: Log): Map<string, MapLike<string>> {
         if (!host.fileExists(typesRegistryFilePath)) {
             if (log.isEnabled()) {
                 log.writeLine(`Types registry file '${typesRegistryFilePath}' does not exist`);
@@ -79,7 +79,7 @@ namespace ts.server.typingsInstaller {
     export class NodeTypingsInstaller extends TypingsInstaller {
         private readonly nodeExecSync: ExecSync;
         private readonly npmPath: string;
-        readonly typesRegistry: Map<MapLike<string>>;
+        readonly typesRegistry: Map<string, MapLike<string>>;
 
         private delayedInitializationError: InitializationFailedResponse | undefined;
 
diff --git a/src/typingsInstallerCore/typingsInstaller.ts b/src/typingsInstallerCore/typingsInstaller.ts
index 770d0bc163cd3..821c001f62451 100644
--- a/src/typingsInstallerCore/typingsInstaller.ts
+++ b/src/typingsInstallerCore/typingsInstaller.ts
@@ -84,12 +84,12 @@ namespace ts.server.typingsInstaller {
         DirectoryWatcher = "DirectoryWatcher"
     }
 
-    type ProjectWatchers = Map<FileWatcher> & { isInvoked?: boolean; };
+    type ProjectWatchers = Map<string, FileWatcher> & { isInvoked?: boolean; };
 
     export abstract class TypingsInstaller {
-        private readonly packageNameToTypingLocation: Map<JsTyping.CachedTyping> = createMap<JsTyping.CachedTyping>();
-        private readonly missingTypingsSet: Map<true> = createMap<true>();
-        private readonly knownCachesSet: Map<true> = createMap<true>();
+        private readonly packageNameToTypingLocation: Map<string, JsTyping.CachedTyping> = createMap<JsTyping.CachedTyping>();
+        private readonly missingTypingsSet: Map<string, true> = createMap<true>();
+        private readonly knownCachesSet: Map<string, true> = createMap<true>();
         private readonly projectWatchers = createMap<ProjectWatchers>();
         private safeList: JsTyping.SafeList | undefined;
         readonly pendingRunRequests: PendingRequest[] = [];
@@ -99,7 +99,7 @@ namespace ts.server.typingsInstaller {
         private installRunCount = 1;
         private inFlightRequestCount = 0;
 
-        abstract readonly typesRegistry: Map<MapLike<string>>;
+        abstract readonly typesRegistry: Map<string, MapLike<string>>;
 
         constructor(
             protected readonly installTypingHost: InstallTypingHost,
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 0d0cf535cfbc0..89ab9f7cab6e5 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -32,27 +32,21 @@ declare namespace ts {
         " __sortedArrayBrand": any;
     }
     /** ES6 Map interface, only read methods included. */
-    interface ReadonlyESMap<K, V> {
+    interface ReadonlyMap<K, V> {
+        readonly size: number;
         get(key: K): V | undefined;
         has(key: K): boolean;
-        forEach(action: (value: V, key: K) => void): void;
-        readonly size: number;
         keys(): Iterator<K>;
         values(): Iterator<V>;
         entries(): Iterator<[K, V]>;
+        forEach(action: (value: V, key: K) => void): void;
     }
     /** ES6 Map interface. */
-    interface ESMap<K, V> extends ReadonlyESMap<K, V> {
+    interface Map<K, V> extends ReadonlyMap<K, V> {
         set(key: K, value: V): this;
         delete(key: K): boolean;
         clear(): void;
     }
-    /** ES6 Map interface, only read methods included. */
-    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
-    }
-    /** ES6 Map interface. */
-    interface Map<T> extends ESMap<string, T>, ReadonlyMap<T> {
-    }
     interface ReadonlySet<T> {
         readonly size: number;
         has(value: T): boolean;
@@ -2417,20 +2411,10 @@ declare namespace ts {
         __escapedIdentifier: void;
     }) | InternalSymbolName;
     /** ReadonlyMap where keys are `__String`s. */
-    export interface ReadonlyUnderscoreEscapedMap<T> {
-        get(key: __String): T | undefined;
-        has(key: __String): boolean;
-        forEach(action: (value: T, key: __String) => void): void;
-        readonly size: number;
-        keys(): Iterator<__String>;
-        values(): Iterator<T>;
-        entries(): Iterator<[__String, T]>;
+    export interface ReadonlyUnderscoreEscapedMap<T> extends ReadonlyMap<__String, T> {
     }
     /** Map where keys are `__String`s. */
-    export interface UnderscoreEscapedMap<T> extends ReadonlyUnderscoreEscapedMap<T> {
-        set(key: __String, value: T): this;
-        delete(key: __String): boolean;
-        clear(): void;
+    export interface UnderscoreEscapedMap<T> extends Map<__String, T>, ReadonlyUnderscoreEscapedMap<T> {
     }
     /** SymbolTable based on ES6 Map interface. */
     export type SymbolTable = UnderscoreEscapedMap<Symbol>;
@@ -2613,7 +2597,7 @@ declare namespace ts {
         isDistributive: boolean;
         inferTypeParameters?: TypeParameter[];
         outerTypeParameters?: TypeParameter[];
-        instantiations?: Map<Type>;
+        instantiations?: Map<string, Type>;
         aliasSymbol?: Symbol;
         aliasTypeArguments?: Type[];
     }
@@ -4503,7 +4487,7 @@ declare namespace ts {
     /**
      * Reads the config file, reports errors if any and exits if the config file cannot be found
      */
-    export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions, host: ParseConfigFileHost, extendedConfigCache?: Map<ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined;
+    export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions, host: ParseConfigFileHost, extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined;
     /**
      * Read tsconfig.json file
      * @param fileName The path to the config file
@@ -4537,7 +4521,7 @@ declare namespace ts {
      * @param basePath A root directory to resolve relative path entries in the config
      *    file to. e.g. outDir
      */
-    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
     /**
      * Parse the contents of a config file (tsconfig.json).
      * @param jsonNode The contents of the config file to parse
@@ -4545,7 +4529,7 @@ declare namespace ts {
      * @param basePath A root directory to resolve relative path entries in the config
      *    file to. e.g. outDir
      */
-    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
+    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
     export interface ParsedTsconfig {
         raw: any;
         options?: CompilerOptions;
@@ -4592,7 +4576,7 @@ declare namespace ts {
      * This assumes that any module id will have the same resolution for sibling files located in the same folder.
      */
     interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
-        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<ResolvedModuleWithFailedLookupLocations>;
+        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<string, ResolvedModuleWithFailedLookupLocations>;
     }
     /**
      * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory
@@ -9190,8 +9174,8 @@ declare namespace ts.server {
         filesToString(writeProjectFileNames: boolean): string;
         setCompilerOptions(compilerOptions: CompilerOptions): void;
         protected removeRoot(info: ScriptInfo): void;
-        protected enableGlobalPlugins(options: CompilerOptions, pluginConfigOverrides: Map<any> | undefined): void;
-        protected enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[], pluginConfigOverrides: Map<any> | undefined): void;
+        protected enableGlobalPlugins(options: CompilerOptions, pluginConfigOverrides: Map<string, any> | undefined): void;
+        protected enablePlugin(pluginConfigEntry: PluginImport, searchPaths: string[], pluginConfigOverrides: Map<string, any> | undefined): void;
         private enableProxy;
         /** Starts a new check for diagnostics. Call this if some file has updated that would cause diagnostics to be changed. */
         refreshDiagnostics(): void;
@@ -9448,11 +9432,11 @@ declare namespace ts.server {
         /**
          * projects specified by a tsconfig.json file
          */
-        readonly configuredProjects: Map<ConfiguredProject>;
+        readonly configuredProjects: Map<string, ConfiguredProject>;
         /**
          * Open files: with value being project root path, and key being Path of the file that is open
          */
-        readonly openFiles: Map<NormalizedPath | undefined>;
+        readonly openFiles: Map<string, NormalizedPath | undefined>;
         /**
          * Map of open files that are opened without complete path but have projectRoot as current directory
          */
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 0aa33e2b43537..16fcc4836468a 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -32,27 +32,21 @@ declare namespace ts {
         " __sortedArrayBrand": any;
     }
     /** ES6 Map interface, only read methods included. */
-    interface ReadonlyESMap<K, V> {
+    interface ReadonlyMap<K, V> {
+        readonly size: number;
         get(key: K): V | undefined;
         has(key: K): boolean;
-        forEach(action: (value: V, key: K) => void): void;
-        readonly size: number;
         keys(): Iterator<K>;
         values(): Iterator<V>;
         entries(): Iterator<[K, V]>;
+        forEach(action: (value: V, key: K) => void): void;
     }
     /** ES6 Map interface. */
-    interface ESMap<K, V> extends ReadonlyESMap<K, V> {
+    interface Map<K, V> extends ReadonlyMap<K, V> {
         set(key: K, value: V): this;
         delete(key: K): boolean;
         clear(): void;
     }
-    /** ES6 Map interface, only read methods included. */
-    interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
-    }
-    /** ES6 Map interface. */
-    interface Map<T> extends ESMap<string, T>, ReadonlyMap<T> {
-    }
     interface ReadonlySet<T> {
         readonly size: number;
         has(value: T): boolean;
@@ -2417,20 +2411,10 @@ declare namespace ts {
         __escapedIdentifier: void;
     }) | InternalSymbolName;
     /** ReadonlyMap where keys are `__String`s. */
-    export interface ReadonlyUnderscoreEscapedMap<T> {
-        get(key: __String): T | undefined;
-        has(key: __String): boolean;
-        forEach(action: (value: T, key: __String) => void): void;
-        readonly size: number;
-        keys(): Iterator<__String>;
-        values(): Iterator<T>;
-        entries(): Iterator<[__String, T]>;
+    export interface ReadonlyUnderscoreEscapedMap<T> extends ReadonlyMap<__String, T> {
     }
     /** Map where keys are `__String`s. */
-    export interface UnderscoreEscapedMap<T> extends ReadonlyUnderscoreEscapedMap<T> {
-        set(key: __String, value: T): this;
-        delete(key: __String): boolean;
-        clear(): void;
+    export interface UnderscoreEscapedMap<T> extends Map<__String, T>, ReadonlyUnderscoreEscapedMap<T> {
     }
     /** SymbolTable based on ES6 Map interface. */
     export type SymbolTable = UnderscoreEscapedMap<Symbol>;
@@ -2613,7 +2597,7 @@ declare namespace ts {
         isDistributive: boolean;
         inferTypeParameters?: TypeParameter[];
         outerTypeParameters?: TypeParameter[];
-        instantiations?: Map<Type>;
+        instantiations?: Map<string, Type>;
         aliasSymbol?: Symbol;
         aliasTypeArguments?: Type[];
     }
@@ -4503,7 +4487,7 @@ declare namespace ts {
     /**
      * Reads the config file, reports errors if any and exits if the config file cannot be found
      */
-    export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions, host: ParseConfigFileHost, extendedConfigCache?: Map<ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined;
+    export function getParsedCommandLineOfConfigFile(configFileName: string, optionsToExtend: CompilerOptions, host: ParseConfigFileHost, extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, watchOptionsToExtend?: WatchOptions, extraFileExtensions?: readonly FileExtensionInfo[]): ParsedCommandLine | undefined;
     /**
      * Read tsconfig.json file
      * @param fileName The path to the config file
@@ -4537,7 +4521,7 @@ declare namespace ts {
      * @param basePath A root directory to resolve relative path entries in the config
      *    file to. e.g. outDir
      */
-    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
+    export function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
     /**
      * Parse the contents of a config file (tsconfig.json).
      * @param jsonNode The contents of the config file to parse
@@ -4545,7 +4529,7 @@ declare namespace ts {
      * @param basePath A root directory to resolve relative path entries in the config
      *    file to. e.g. outDir
      */
-    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
+    export function parseJsonSourceFileConfigFileContent(sourceFile: TsConfigSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: readonly FileExtensionInfo[], extendedConfigCache?: Map<string, ExtendedConfigCacheEntry>, existingWatchOptions?: WatchOptions): ParsedCommandLine;
     export interface ParsedTsconfig {
         raw: any;
         options?: CompilerOptions;
@@ -4592,7 +4576,7 @@ declare namespace ts {
      * This assumes that any module id will have the same resolution for sibling files located in the same folder.
      */
     interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
-        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<ResolvedModuleWithFailedLookupLocations>;
+        getOrCreateCacheForDirectory(directoryName: string, redirectedReference?: ResolvedProjectReference): Map<string, ResolvedModuleWithFailedLookupLocations>;
     }
     /**
      * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory

From f773f187668b1c32d964ca0ce1d2f684aa6676cb Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Thu, 18 Jun 2020 16:56:25 -0700
Subject: [PATCH 03/10] Remove WeakMap/WeakSet

---
 src/compiler/core.ts                          | 110 ++--
 src/compiler/corePublic.ts                    | 115 ++---
 src/compiler/sys.ts                           |  12 +-
 src/shims/collectionShims.ts                  | 470 +++++++-----------
 src/testRunner/unittests/createMapShim.ts     |   4 +-
 .../reference/api/tsserverlibrary.d.ts        |  40 +-
 tests/baselines/reference/api/typescript.d.ts |  40 +-
 7 files changed, 335 insertions(+), 456 deletions(-)

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 27976899cfe8c..40da8b819b554 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -1,36 +1,43 @@
 /* @internal */
 namespace ts {
-    export const Map: MapConstructor = tryGetNativeMap() || (() => {
-        // NOTE: ts.createMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createMapShim === "function") {
-            return createMapShim();
+    type GetIteratorCallback = <I extends readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined>(iterable: I) => Iterator<
+        I extends ReadonlyMap<infer K, infer V> ? [K, V] :
+        I extends ReadonlySet<infer T> ? T :
+        I extends readonly (infer T)[] ? T :
+        I extends undefined ? undefined :
+        never>;
+
+    function getCollectionImplementation<
+        K1 extends MatchingKeys<typeof NativeCollections, () => any>,
+        K2 extends MatchingKeys<typeof ShimCollections, (getIterator?: GetIteratorCallback) => ReturnType<(typeof NativeCollections)[K1]>>
+    >(name: string, nativeFactory: K1, shimFactory: K2): NonNullable<ReturnType<(typeof NativeCollections)[K1]>> {
+        // NOTE: ts.ShimCollections will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
+        const constructor = NativeCollections[nativeFactory]() ?? ShimCollections?.[shimFactory](getIterator);
+        if (constructor) return constructor as NonNullable<ReturnType<(typeof NativeCollections)[K1]>>;
+        throw new Error(`TypeScript requires an environment that provides a compatible native ${name} implementation.`);
+    }
+
+    export const Map = getCollectionImplementation("Map", "tryGetNativeMap", "createMapShim");
+    export const Set = getCollectionImplementation("Set", "tryGetNativeSet", "createSetShim");
+
+    export function getIterator<I extends readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined>(iterable: I): Iterator<
+        I extends ReadonlyMap<infer K, infer V> ? [K, V] :
+        I extends ReadonlySet<infer T> ? T :
+        I extends readonly (infer T)[] ? T :
+        I extends undefined ? undefined :
+        never>;
+    export function getIterator<K, V>(iterable: ReadonlyMap<K, V>): Iterator<[K, V]>;
+    export function getIterator<K, V>(iterable: ReadonlyMap<K, V> | undefined): Iterator<[K, V]> | undefined;
+    export function getIterator<T>(iterable: readonly T[] | ReadonlySet<T>): Iterator<T>;
+    export function getIterator<T>(iterable: readonly T[] | ReadonlySet<T> | undefined): Iterator<T> | undefined;
+    export function getIterator(iterable: readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined): Iterator<any> | undefined {
+        if (iterable) {
+            if (isArray(iterable)) return arrayIterator(iterable);
+            if (iterable instanceof Map) return iterable.entries();
+            if (iterable instanceof Set) return iterable.values();
+            throw new Error("Iteration not supported.");
         }
-        throw new Error("TypeScript requires an environment that provides a compatible native Map implementation.");
-    })();
-
-    export const Set: SetConstructor = tryGetNativeSet() || (() => {
-        // NOTE: ts.createSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createSetShim === "function") {
-            return createSetShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native Set implementation.");
-    })();
-
-    export const WeakMap: WeakMapConstructor = tryGetNativeWeakMap() || (() => {
-        // NOTE: ts.createWeakMapShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createWeakMapShim === "function") {
-            return createWeakMapShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native WeakMap implementation.");
-    })();
-
-    export const WeakSet: WeakSetConstructor = tryGetNativeWeakSet() || (() => {
-        // NOTE: ts.createWeakSetShim will be defined for typescriptServices.js but not for tsc.js, so we must test for it.
-        if (typeof createWeakSetShim === "function") {
-            return createWeakSetShim();
-        }
-        throw new Error("TypeScript requires an environment that provides a compatible native WeakSet implementation.");
-    })();
+    }
 
     export const emptyArray: never[] = [] as never[];
 
@@ -61,14 +68,6 @@ namespace ts {
         return map;
     }
 
-    export function createSet<T>(): Set<T> {
-        return new Set<T>();
-    }
-
-    export function createSetFromValues<T>(values: readonly T[]): Set<T> {
-        return new Set(values);
-    }
-
     export function length(array: readonly any[] | undefined): number {
         return array ? array.length : 0;
     }
@@ -133,6 +132,16 @@ namespace ts {
         }
     }
 
+    export function reduceLeftIterator<T, U>(iterator: Iterator<T> | undefined, f: (memo: U, value: T, i: number) => U, initial: U): U {
+        let result = initial;
+        if (iterator) {
+            for (let step = iterator.next(), pos = 0; !step.done; step = iterator.next(), pos++) {
+                result = f(result, step.value, pos);
+            }
+        }
+        return result;
+    }
+
     export function zipWith<T, U, V>(arrayA: readonly T[], arrayB: readonly U[], callback: (a: T, b: U, index: number) => V): V[] {
         const result: V[] = [];
         Debug.assertEqual(arrayA.length, arrayB.length);
@@ -158,7 +167,7 @@ namespace ts {
 
     export function zipToMap<K, V>(keys: readonly K[], values: readonly V[]): Map<K, V> {
         Debug.assert(keys.length === values.length);
-        const map = createMap<K, V>();
+        const map = new Map<K, V>();
         for (let i = 0; i < keys.length; ++i) {
             map.set(keys[i], values[i]);
         }
@@ -557,7 +566,7 @@ namespace ts {
             return undefined;
         }
 
-        const result = createMap<K2, V2>();
+        const result = new Map<K2, V2>();
         map.forEach((value, key) => {
             const entry = f(key, value);
             if (entry !== undefined) {
@@ -571,6 +580,21 @@ namespace ts {
         return result;
     }
 
+    export function mapDefinedValues<V1, V2>(set: ReadonlySet<V1>, f: (value: V1) => V2 | undefined): Set<V2>;
+    export function mapDefinedValues<V1, V2>(set: ReadonlySet<V1> | undefined, f: (value: V1) => V2 | undefined): Set<V2> | undefined;
+    export function mapDefinedValues<V1, V2>(set: ReadonlySet<V1> | undefined, f: (value: V1) => V2 | undefined): Set<V2> | undefined {
+        if (set) {
+            const result = new Set<V2>();
+            set.forEach(value => {
+                const newValue = f(value);
+                if (newValue !== undefined) {
+                    result.add(newValue);
+                }
+            });
+            return result;
+        }
+    }
+
     export const emptyIterator: Iterator<never> = { next: () => ({ value: undefined as never, done: true }) };
 
     export function singleIterator<T>(value: T): Iterator<T> {
@@ -640,7 +664,7 @@ namespace ts {
             return undefined;
         }
 
-        const result = createMap<K2, V2>();
+        const result = new Map<K2, V2>();
         map.forEach((value, key) => {
             const [newKey, newValue] = f(key, value);
             result.set(newKey, newValue);
@@ -1312,7 +1336,7 @@ namespace ts {
     export function arrayToMap<K, V>(array: readonly V[], makeKey: (value: V) => K | undefined): Map<K, V>;
     export function arrayToMap<K, V1, V2>(array: readonly V1[], makeKey: (value: V1) => K | undefined, makeValue: (value: V1) => V2): Map<K, V2>;
     export function arrayToMap<K, V1, V2>(array: readonly V1[], makeKey: (value: V1) => K | undefined, makeValue: (value: V1) => V1 | V2 = identity): Map<K, V1 | V2> {
-        const result = createMap<K, V1 | V2>();
+        const result = new Map<K, V1 | V2>();
         for (const value of array) {
             const key = makeKey(value);
             if (key !== undefined) result.set(key, makeValue(value));
@@ -1407,7 +1431,7 @@ namespace ts {
     export function createMultiMap<V>(): MultiMap<string, V>;
     export function createMultiMap<K, V>(): MultiMap<K, V>;
     export function createMultiMap<K, V>(): MultiMap<K, V> {
-        const map = createMap<K, V[]>() as MultiMap<K, V>;
+        const map = new Map<K, V[]>() as MultiMap<K, V>;
         map.add = multiMapAdd;
         map.remove = multiMapRemove;
         return map;
diff --git a/src/compiler/corePublic.ts b/src/compiler/corePublic.ts
index a9869a82e7693..bd935bb22844b 100644
--- a/src/compiler/corePublic.ts
+++ b/src/compiler/corePublic.ts
@@ -22,22 +22,34 @@ namespace ts {
         " __sortedArrayBrand": any;
     }
 
-    /** ES6 Map interface, only read methods included. */
-    export interface ReadonlyMap<K, V> {
+    /** Common read methods for ES6 Map/Set. */
+    export interface ReadonlyCollection<K> {
         readonly size: number;
-        get(key: K): V | undefined;
         has(key: K): boolean;
         keys(): Iterator<K>;
+    }
+
+    /** Common write methods for ES6 Map/Set. */
+    export interface Collection<K> extends ReadonlyCollection<K> {
+        delete(key: K): boolean;
+        clear(): void;
+    }
+
+    /** ES6 Map interface, only read methods included. */
+    export interface ReadonlyMap<K, V> extends ReadonlyCollection<K> {
+        get(key: K): V | undefined;
         values(): Iterator<V>;
         entries(): Iterator<[K, V]>;
         forEach(action: (value: V, key: K) => void): void;
     }
 
+    /* @internal */
+    export interface ReadonlyMap<K, V> {
+    }
+
     /** ES6 Map interface. */
-    export interface Map<K, V> extends ReadonlyMap<K, V> {
+    export interface Map<K, V> extends ReadonlyMap<K, V>, Collection<K> {
         set(key: K, value: V): this;
-        delete(key: K): boolean;
-        clear(): void;
     }
 
     /* @internal */
@@ -46,19 +58,22 @@ namespace ts {
         new <K, V>(iterable?: readonly (readonly [K, V])[] | ReadonlyMap<K, V>): Map<K, V>;
     }
 
-    export interface ReadonlySet<T> {
-        readonly size: number;
+    /** ES6 Set interface, only read methods included. */
+    export interface ReadonlySet<T> extends ReadonlyCollection<T> {
         has(value: T): boolean;
-        forEach(action: (value: T, key: T) => void): void;
-        keys(): Iterator<T>;
         values(): Iterator<T>;
         entries(): Iterator<[T, T]>;
+        forEach(action: (value: T, key: T) => void): void;
     }
 
-    export interface Set<T> extends ReadonlySet<T> {
+    /* @internal */
+    export interface ReadonlySet<T> {
+    }
+
+    /** ES6 Set interface. */
+    export interface Set<T> extends ReadonlySet<T>, Collection<T> {
         add(value: T): this;
         delete(value: T): boolean;
-        clear(): void;
     }
 
     /* @internal */
@@ -67,31 +82,6 @@ namespace ts {
         new <T>(iterable?: readonly T[] | ReadonlySet<T>): Set<T>;
     }
 
-    export interface WeakMap<K extends object, V> {
-        get(key: K): V | undefined;
-        has(key: K): boolean;
-        set(key: K, value: V): this;
-        delete(key: K): boolean;
-    }
-
-    /* @internal */
-    export interface WeakMapConstructor {
-        // eslint-disable-next-line @typescript-eslint/prefer-function-type
-        new <K extends object, V>(): WeakMap<K, V>;
-    }
-
-    export interface WeakSet<T extends object> {
-        has(key: T): boolean;
-        add(key: T): this;
-        delete(key: T): boolean;
-    }
-
-    /* @internal */
-    export interface WeakSetConstructor {
-        // eslint-disable-next-line @typescript-eslint/prefer-function-type
-        new <T extends object>(): WeakSet<T>;
-    }
-
     /** ES6 Iterator type. */
     export interface Iterator<T> {
         next(): { value: T, done?: false } | { value: never, done: true };
@@ -116,62 +106,27 @@ namespace ts {
         GreaterThan = 1
     }
 
-    namespace NativeCollections {
+    /* @internal */
+    export namespace NativeCollections {
         declare const Map: MapConstructor | undefined;
         declare const Set: SetConstructor | undefined;
-        declare const WeakMap: WeakMapConstructor | undefined;
-        declare const WeakSet: WeakSetConstructor | undefined;
 
+        /**
+         * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
+         */
         export function tryGetNativeMap(): MapConstructor | undefined {
             // Internet Explorer's Map doesn't support iteration, so don't use it.
             // eslint-disable-next-line no-in-operator
             return typeof Map !== "undefined" && "entries" in Map.prototype && new Map([[0, 0]]).size === 1 ? Map : undefined;
         }
 
+        /**
+         * Returns the native Set implementation if it is available and compatible (i.e. supports iteration).
+         */
         export function tryGetNativeSet(): SetConstructor | undefined {
             // Internet Explorer's Set doesn't support iteration, so don't use it.
             // eslint-disable-next-line no-in-operator
             return typeof Set !== "undefined" && "entries" in Set.prototype && new Set([0]).size === 1 ? Set : undefined;
         }
-
-        export function tryGetNativeWeakMap(): WeakMapConstructor | undefined {
-            return typeof WeakMap !== "undefined" ? WeakMap : undefined;
-        }
-
-        export function tryGetNativeWeakSet(): WeakSetConstructor | undefined {
-            return typeof WeakSet !== "undefined" ? WeakSet : undefined;
-        }
-    }
-
-    /**
-     * Returns the native Map implementation if it is available and compatible (i.e. supports iteration).
-     */
-    /* @internal */
-    export function tryGetNativeMap() {
-        return NativeCollections.tryGetNativeMap();
-    }
-
-    /**
-     * Returns the native Set implementation if it is available and compatible (i.e. supports iteration).
-     */
-    /* @internal */
-    export function tryGetNativeSet() {
-        return NativeCollections.tryGetNativeSet();
-    }
-
-    /**
-     * Returns the native WeakMap implementation if it is available.
-     */
-    /* @internal */
-    export function tryGetNativeWeakMap() {
-        return NativeCollections.tryGetNativeWeakMap();
-    }
-
-    /**
-     * Returns the native WeakSet implementation if it is available.
-     */
-    /* @internal */
-    export function tryGetNativeWeakSet() {
-        return NativeCollections.tryGetNativeWeakSet();
     }
 }
\ No newline at end of file
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 0132af7223bda..d096f7dd66358 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -310,7 +310,7 @@ namespace ts {
     function createUseFsEventsOnParentDirectoryWatchFile(fsWatch: FsWatch, useCaseSensitiveFileNames: boolean): HostWatchFile {
         // One file can have multiple watchers
         const fileWatcherCallbacks = createMultiMap<FileWatcherCallback>();
-        const dirWatchers = createMap<DirectoryWatcher>();
+        const dirWatchers = new Map<string, DirectoryWatcher>();
         const toCanonicalName = createGetCanonicalFileName(useCaseSensitiveFileNames);
         return nonPollingWatchFile;
 
@@ -370,7 +370,7 @@ namespace ts {
             watcher: FileWatcher;
             refCount: number;
         }
-        const cache = createMap<SingleFileWatcher>();
+        const cache = new Map<string, SingleFileWatcher>();
         const callbacksCache = createMultiMap<FileWatcherCallback>();
         const toCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);
 
@@ -473,9 +473,9 @@ namespace ts {
             refCount: number;
         }
 
-        const cache = createMap<HostDirectoryWatcher>();
+        const cache = new Map<string, HostDirectoryWatcher>();
         const callbackCache = createMultiMap<{ dirName: string; callback: DirectoryWatcherCallback; }>();
-        const cacheToUpdateChildWatches = createMap<{ dirName: string; options: WatchOptions | undefined; fileNames: string[]; }>();
+        const cacheToUpdateChildWatches = new Map<string, { dirName: string; options: WatchOptions | undefined; fileNames: string[]; }>();
         let timerToUpdateChildWatches: any;
 
         const filePathComparer = getStringComparer(!host.useCaseSensitiveFileNames);
@@ -608,7 +608,7 @@ namespace ts {
             timerToUpdateChildWatches = undefined;
             sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
             const start = timestamp();
-            const invokeMap = createMap<string[]>();
+            const invokeMap = new Map<string, string[]>();
 
             while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
                 const { value: [dirPath, { dirName, options, fileNames }], done } = cacheToUpdateChildWatches.entries().next();
@@ -1316,7 +1316,7 @@ namespace ts {
              */
             function cleanupPaths(profile: import("inspector").Profiler.Profile) {
                 let externalFileCounter = 0;
-                const remappedPaths = createMap<string>();
+                const remappedPaths = new Map<string, string>();
                 const normalizedDir = normalizeSlashes(__dirname);
                 // Windows rooted dir names need an extra `/` prepended to be valid file:/// urls
                 const fileUrlRoot = `file://${getRootLength(normalizedDir) === 1 ? "" : "/"}${normalizedDir}`;
diff --git a/src/shims/collectionShims.ts b/src/shims/collectionShims.ts
index a1f478de9cee4..349d712a2193e 100644
--- a/src/shims/collectionShims.ts
+++ b/src/shims/collectionShims.ts
@@ -1,7 +1,18 @@
 /* @internal */
 namespace ts {
+    type GetIteratorCallback = <I extends readonly any[] | ReadonlySetShim<any> | ReadonlyMapShim<any, any> | undefined>(iterable: I) => Iterator<
+        I extends ReadonlyMapShim<infer K, infer V> ? [K, V] :
+        I extends ReadonlySetShim<infer T> ? T :
+        I extends readonly (infer T)[] ? T :
+        I extends undefined ? undefined :
+        never>;
+
+    type IteratorResultShim<T> =
+        | { value: T, done?: false }
+        | { value: never, done: true };
+
     interface IteratorShim<T> {
-        next(): { value: T, done?: false } | { value: never, done: true };
+        next(): IteratorResultShim<T>;
     }
 
     interface ReadonlyMapShim<K, V> {
@@ -39,28 +50,14 @@ namespace ts {
 
     type SetShimConstructor = new <T>(iterable?: readonly T[] | ReadonlySetShim<T>) => SetShim<T>;
 
-    interface WeakMapShim<K extends object, V> {
-        get(key: K): V | undefined;
-        has(key: K): boolean;
-        set(key: K, value: V): this;
-        delete(key: K): boolean;
-    }
-
-    interface WeakSetShim<T extends object> {
-        has(key: T): boolean;
-        add(key: T): this;
-        delete(key: T): boolean;
-    }
-
-    interface WeakMapData<K, V> {
-        objects?: ObjectMapEntry<K, V>;
-    }
-
     interface MapData<K, V> {
         size: number;
         strings?: Record<string, MapEntry<K, V>>;
         numbers?: MapEntry<K, V>[];
-        objects?: ObjectMapEntry<K, V>;
+        nan?: MapEntry<K, V>;
+        positiveInfinity?: MapEntry<K, V>;
+        negativeInfinity?: MapEntry<K, V>;
+        list?: MapEntry<K, V>;
         true?: MapEntry<K, V>;
         false?: MapEntry<K, V>;
         null?: MapEntry<K, V>;
@@ -83,6 +80,9 @@ namespace ts {
         readonly key?: K;
         value?: V;
 
+        // Linked list references for non-primitive keys
+        next?: MapEntry<K, V>;
+
         // Linked list references for iterators.
         nextIterationEntry?: MapEntry<K, V>;
         previousIterationEntry?: MapEntry<K, V>;
@@ -95,15 +95,9 @@ namespace ts {
         skipNextIteration?: boolean;
     }
 
-    interface ObjectMapEntry<K, V> extends MapEntry<K, V> {
-        // Linked list references for object-based keys
-        next?: ObjectMapEntry<K, V>;
-    }
-
-    function isObject(value: unknown): value is object {
-        // eslint-disable-next-line no-null/no-null
-        return typeof value === "object" && value !== null
-            || typeof value === "function";
+    interface IteratorData<K, V, U extends (K | V | [K, V])> {
+        currentEntry?: MapEntry<K, V>;
+        selector: (key: K, value: V) => U;
     }
 
     function createDictionaryObject<T>(): Record<string, T> {
@@ -117,73 +111,44 @@ namespace ts {
         return map;
     }
 
-    function tryAddIterator<T>(value: T, iterator: (this: T) => IteratorShim<any>) {
-        if (typeof Symbol === "function" && Symbol.iterator !== undefined) {
-            (value as any)[Symbol.iterator] = iterator;
-        }
+    function createMapData<K, V>(): MapData<K, V> {
+        const entry: MapEntry<K, V> = {};
+        return { first: entry, last: entry, size: 0 };
     }
 
-    function createIterator(name: string) {
-        class Iterator<K, V, U extends (K | V | [K, V])> {
-            private currentEntry?: MapEntry<K, V>;
-            private selector: (key: K, value: V) => U;
-
-            constructor(data: MapData<K, V>, selector: (key: K, value: V) => U) {
-                this.currentEntry = data.first;
-                this.selector = selector;
-            }
+    function createMapEntry<K, V>(key: K, value: V): MapEntry<K, V> {
+        return { key, value, nextIterationEntry: undefined, previousIterationEntry: undefined, skipNextIteration: false };
+    }
 
-            public next(): { value: U, done?: false } | { value: never, done: true } {
-                // Navigate to the next entry.
-                while (this.currentEntry) {
-                    const skipNext = !!this.currentEntry.skipNextIteration;
-                    this.currentEntry = this.currentEntry.nextIterationEntry;
-                    if (!skipNext) {
-                        break;
-                    }
-                }
+    function createListMapEntry<K, V>(key: K, value: V, next?: MapEntry<K, V>): MapEntry<K, V> {
+        const entry = createMapEntry(key, value);
+        entry.next = next;
+        return entry;
+    }
 
-                if (this.currentEntry) {
-                    return { value: this.selector(this.currentEntry.key!, this.currentEntry.value!), done: false };
-                }
-                else {
-                    return { value: undefined as never, done: true };
-                }
-            }
+    function getSingletonBucket(key: unknown) {
+        /* eslint-disable no-null/no-null */
+        if (key === true) return "true";
+        if (key === false) return "false";
+        if (key === null) return "null";
+        if (key === undefined) return "undefined";
+        if (typeof key === "number") {
+            if (isNaN(key)) return "nan";
+            if (!isFinite(key)) return key < 0 ? "negativeInfinity" : "positiveInfinity";
         }
-        tryAddIterator(Iterator.prototype, function() { return this; })
-        Object.defineProperty(Iterator, "name", {
-            ...Object.getOwnPropertyDescriptor(Iterator, "name"),
-            configurable: true,
-            value: name
-        });
-        return Iterator;
-    }
-
-    function hasEntry<K, V>(data: MapData<K, V>, key: K): boolean {
-        /* eslint-disable no-in-operator, no-null/no-null */
-        return typeof key === "string" ? !!data.strings && key in data.strings :
-            typeof key === "number" ? !!data.numbers && key in data.numbers :
-            typeof key === "boolean" ? key ? !!data.true : !!data.false :
-            key === null ? !!data.null :
-            key === undefined ? !!data.undefined :
-            !!getObjectEntry(data, key);
-        // eslint-enable no-in-operator, no-null/no-null
+        /* eslint-enable no-null/no-null */
     }
 
     function getEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
-        /* eslint-disable no-null/no-null */
-        return typeof key === "string" ? data.strings && data.strings[key] :
-            typeof key === "number" ? data.numbers && data.numbers[key] :
-            typeof key === "boolean" ? key ? data.true : data.false :
-            key === undefined ? data.undefined :
-            key === null ? data.null :
-            getObjectEntry(data, key);
-        /* eslint-enable no-null/no-null */
+        const bucket = getSingletonBucket(key);
+        return bucket ? data[bucket] :
+            typeof key === "string" ? data.strings?.[key] :
+            typeof key === "number" ? data.numbers?.[key] :
+            getListEntry(data, key);
     }
 
-    function getObjectEntry<K, V>(data: WeakMapData<K, V>, key: K): ObjectMapEntry<K, V> | undefined {
-        for (let node = data.objects; node; node = node.next) {
+    function getListEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        for (let node = data.list; node; node = node.next) {
             if (node.key === key) {
                 return node;
             }
@@ -191,44 +156,11 @@ namespace ts {
     }
 
     function addOrUpdateEntry<K, V>(data: MapData<K, V>, key: K, value: V): MapEntry<K, V> | undefined {
-        let entry: MapEntry<K, V> | undefined;
-        if (typeof key === "string") {
-            if (!data.strings) data.strings = createDictionaryObject();
-            if (!data.strings[key]) {
-                entry = data.strings[key] = { key, value };
-            }
-            else {
-                data.strings[key].value = value;
-            }
-        }
-        else if (typeof key === "number") {
-            if (!data.numbers) data.numbers = [];
-            if (!data.numbers[key]) {
-                entry = data.numbers[key] = { key, value };
-            }
-            else {
-                data.numbers[key].value = value;
-            }
-        }
-        else {
-            /* eslint-disable no-null/no-null */
-            const prop = typeof key === "boolean" ? key ? "true" : "false" :
-                key === null ? "null" :
-                key === undefined ? "undefined" :
-                undefined;
-            /* eslint-enable no-null/no-null */
-            if (prop) {
-                if (!data[prop]) {
-                    entry = data[prop] = { key, value };
-                }
-                else {
-                    data[prop]!.value = value;
-                }
-            }
-            else {
-                entry = addOrUpdateObjectEntry(data, key, value);
-            }
-        }
+        const bucket = getSingletonBucket(key);
+        const entry = bucket ? addOrUpdateSingletonEntry(data, bucket, key, value) :
+            typeof key === "string" ? addOrUpdateStringsEntry(data, key, value) :
+            typeof key === "number" ? addOrUpdateNumbersEntry(data, key, value) :
+            addOrUpdateListEntry(data, key, value);
         if (entry) {
             addToIteration(data, entry);
             data.size++;
@@ -236,47 +168,63 @@ namespace ts {
         return entry;
     }
 
-    function addOrUpdateObjectEntry<K, V>(data: WeakMapData<K, V>, key: K, value: V): ObjectMapEntry<K, V> | undefined {
-        if (!data.objects) return data.objects = { key, value, next: undefined };
-        const existing = getObjectEntry(data, key);
-        if (!existing) return data.objects = { key, value, next: data.objects };
+    function addOrUpdateSingletonEntry<K, V>(data: MapData<K, V>, prop: "nan" | "negativeInfinity" | "positiveInfinity" | "true" | "false" | "null" | "undefined", key: K, value: V) {
+        const entry = data[prop];
+        if (!entry) {
+            return data[prop] = createMapEntry(key, value);
+        }
+        else {
+            entry.value = value;
+        }
+    }
+
+    function addOrUpdateStringsEntry<K, V>(data: MapData<K, V>, key: K & string, value: V) {
+        if (!data.strings) data.strings = createDictionaryObject();
+        if (!data.strings[key]) {
+            return data.strings[key] = createMapEntry(key, value);
+        }
+        else {
+            data.strings[key].value = value;
+        }
+    }
+
+    function addOrUpdateNumbersEntry<K, V>(data: MapData<K, V>, key: K & number, value: V) {
+        if (!data.numbers) data.numbers = [];
+        if (!data.numbers[key]) {
+            return data.numbers[key] = createMapEntry(key, value);
+        }
+        else {
+            data.numbers[key].value = value;
+        }
+    }
+
+    function addOrUpdateListEntry<K, V>(data: MapData<K, V>, key: K, value: V): MapEntry<K, V> | undefined {
+        if (!data.list) return data.list = createListMapEntry(key, value, /*next*/ undefined);
+        const existing = getListEntry(data, key);
+        if (!existing) return data.list = createListMapEntry(key, value, data.list);
         existing.value = value;
     }
 
     function deleteEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        const bucket = getSingletonBucket(key);
         let entry: MapEntry<K, V> | undefined;
-        if (typeof key === "string") {
-            if (data.strings) {
-                entry = data.strings[key];
-                if (entry) {
-                    delete data.strings[key];
-                }
+        if (bucket) {
+            if (entry = data[bucket]) {
+                delete data[bucket];
+            }
+        }
+        else if (typeof key === "string") {
+            if (entry = data.strings?.[key]) {
+                delete data.strings[key];
             }
         }
         else if (typeof key === "number") {
-            if (data.numbers) {
-                entry = data.numbers[key];
-                if (entry) {
-                    delete data.numbers[key];
-                }
+            if (entry = data.numbers?.[key]) {
+                delete data.numbers[key];
             }
         }
         else {
-            /* eslint-disable no-null/no-null */
-            const prop = typeof key === "boolean" ? key ? "true" : "false" :
-                key === null ? "null" :
-                key === undefined ? "undefined" :
-                undefined;
-            /* eslint-enable no-null/no-null */
-            if (prop) {
-                entry = data[prop];
-                if (entry) {
-                    data[prop] = undefined;
-                }
-            }
-            else {
-                entry = deleteObjectEntry(data, key);
-            }
+            entry = deleteListEntry(data, key);
         }
         if (entry) {
             removeFromIteration(data, entry);
@@ -285,15 +233,15 @@ namespace ts {
         return entry;
     }
 
-    function deleteObjectEntry<K, V>(data: WeakMapData<K, V>, key: K): ObjectMapEntry<K, V> | undefined {
-        let prev: ObjectMapEntry<K, V> | undefined;
-        for (let node = data.objects; node; prev = node, node = node.next) {
+    function deleteListEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        let prev: MapEntry<K, V> | undefined;
+        for (let node = data.list; node; prev = node, node = node.next) {
             if (node.key === key) {
                 if (prev) {
                     prev.next = node.next;
                 }
                 else {
-                    data.objects = node.next;
+                    data.list = node.next;
                 }
                 node.next = undefined;
                 return node;
@@ -308,15 +256,15 @@ namespace ts {
         if (data.false) data.false = undefined;
         if (data.null) data.null = undefined;
         if (data.undefined) data.undefined = undefined;
-        clearObjectEntries(data);
+        clearListEntries(data);
         removeAllFromIteration(data);
         data.size = 0;
     }
 
-    function clearObjectEntries<K, V>(data: WeakMapData<K, V>) {
-        if (data.objects) {
-            let node = data.objects;
-            data.objects = undefined;
+    function clearListEntries<K, V>(data: MapData<K, V>) {
+        if (data.list) {
+            let node = data.list;
+            data.list = undefined;
             while (node) {
                 const next = node.next!;
                 node.next = undefined;
@@ -392,140 +340,104 @@ namespace ts {
         }
     }
 
-    function createMapData<K, V>(): MapData<K, V> {
-        const entry: MapEntry<K, V> = {};
-        return {
-            first: entry,
-            last: entry,
-            size: 0
-        };
+    function fill<T, O extends ReadonlyMapShim<any, any> | ReadonlySetShim<any>>(object: O, iterator: Iterator<T> | undefined, add: (object: O, value: any) => void) {
+        if (iterator) {
+            for (let step = iterator.next(); !step.done; step = iterator.next()) {
+                add(object, step.value);
+            }
+        }
     }
 
-    function createWeakMapData<K, V>(): WeakMapData<K, V> {
-        return {};
+    function createIteratorData<K, V, U extends (K | V | [K, V])>(data: MapData<K, V>, selector: (key: K, value: V) => U): IteratorData<K, V, U> {
+        return { currentEntry: data.first, selector };
     }
 
-    function pickKey<K, V>(key: K, _value: V) { return key; }
-    function pickValue<K, V>(_key: K, value: V) { return value; }
-    function pickEntry<K, V>(key: K, value: V) { return [key, value] as [K, V]; }
-
-    /* @internal */
-    export function createMapShim(): MapShimConstructor {
-        const MapIterator = createIterator("MapIterator");
-        class Map<K, V> implements MapShim<K, V> {
-            private _mapData = createMapData<K, V>();
-            constructor(iterable?: readonly (readonly [K, V])[] | ReadonlyMapShim<K, V>) {
-                if (iterable) {
-                    if ((Array.isArray as (value: any) => value is readonly any[])(iterable)) {
-                        for (const [key, value] of iterable) {
-                            this.set(key, value);
-                        }
-                    }
-                    else {
-                        const iterator = iterable.entries();
-                        for (let result = iterator.next(); !result.done; result = iterator.next()) {
-                            const [key, value] = result.value;
-                            this.set(key, value);
-                        }
-                    }
-                }
+    function iteratorNext<K, V, U extends (K | V | [K, V])>(data: IteratorData<K, V, U>): IteratorResultShim<U> {
+        // Navigate to the next entry.
+        while (data.currentEntry) {
+            const skipNext = !!data.currentEntry.skipNextIteration;
+            data.currentEntry = data.currentEntry.nextIterationEntry;
+            if (!skipNext) {
+                break;
             }
-            get size() { return this._mapData.size; }
-            get(key: K): V | undefined { return getEntry(this._mapData, key)?.value; }
-            set(key: K, value: V): this { return addOrUpdateEntry(this._mapData, key, value), this; }
-            has(key: K): boolean { return hasEntry(this._mapData, key); }
-            delete(key: K): boolean { return !!deleteEntry(this._mapData, key); }
-            clear(): void { clearEntries(this._mapData); }
-            keys(): IteratorShim<K> { return new MapIterator(this._mapData, pickKey); }
-            values(): IteratorShim<V> { return new MapIterator(this._mapData, pickValue); }
-            entries(): IteratorShim<[K, V]> { return new MapIterator(this._mapData, pickEntry); }
-            forEach(action: (value: V, key: K) => void): void { forEachEntry(this._mapData, action); }
         }
-        tryAddIterator(Map.prototype, Map.prototype.entries);
-        return Map;
+        if (data.currentEntry) {
+            return { value: data.selector(data.currentEntry.key!, data.currentEntry.value!), done: false };
+        }
+        else {
+            return { value: undefined as never, done: true };
+        }
     }
 
-    /* @internal */
-    export function createSetShim(): SetShimConstructor {
-        const SetIterator = createIterator("SetIterator");
-        class Set<T> implements SetShim<T> {
-            private _mapData = createMapData<T, T>();
-            constructor(iterable?: readonly T[] | ReadonlySetShim<T>) {
-                if (iterable) {
-                    if ((Array.isArray as (value: any) => value is readonly any[])(iterable)) {
-                        for (const value of iterable) {
-                            this.add(value);
-                        }
-                    }
-                    else {
-                        const iterator = iterable.values();
-                        for (let result = iterator.next(); !result.done; result = iterator.next()) {
-                            this.add(result.value);
-                        }
-                    }
-                }
-            }
-            get size() { return this._mapData.size; }
-            add(value: T): this { return addOrUpdateEntry(this._mapData, value, value), this; }
-            has(value: T): boolean { return hasEntry(this._mapData, value); }
-            delete(value: T): boolean { return !!deleteEntry(this._mapData, value); }
-            clear(): void { clearEntries(this._mapData); }
-            keys(): IteratorShim<T> { return new SetIterator(this._mapData, pickKey); }
-            values(): IteratorShim<T> { return new SetIterator(this._mapData, pickValue); }
-            entries(): IteratorShim<[T, T]> { return new SetIterator(this._mapData, pickEntry); }
-            forEach(action: (value: T, key: T) => void): void { forEachEntry(this._mapData, action); }
-        }
-        tryAddIterator(Set.prototype, Set.prototype.values);
-        return Set;
+    function pickKey<K, V>(key: K, _value: V) {
+        return key;
+    }
+
+    function pickValue<K, V>(_key: K, value: V) {
+        return value;
+    }
+
+    function pickEntry<K, V>(key: K, value: V) {
+        return [key, value] as [K, V];
     }
 
-    // NOTE: Not a real WeakMap, this implementation will hold onto references until it is GC'ed. However, it's the best
-    // we can do without storing data on each value itself.
     /* @internal */
-    export function createWeakMapShim(): new <K extends object, V>() => WeakMapShim<K, V> {
-        class WeakMap<K extends object, V> implements WeakMapShim<K, V> {
-            private _mapData = createWeakMapData<K, V>();
-            get(key: K): V | undefined {
-                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
-                return getObjectEntry(this._mapData, key)?.value;
-            }
-            set(key: K, value: V): this {
-                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
-                addOrUpdateObjectEntry(this._mapData, key, value);
-                return this;
-            }
-            has(key: K): boolean {
-                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
-                return !!getObjectEntry(this._mapData, key);
+    export namespace ShimCollections {
+        export function createMapShim(getIterator: GetIteratorCallback): MapShimConstructor {
+            class MapIterator<K, V, U extends (K | V | [K, V])> {
+                private _data: IteratorData<K, V, U>;
+                constructor(data: MapData<K, V>, selector: (key: K, value: V) => U) {
+                    this._data = createIteratorData(data, selector);
+                }
+                next() { return iteratorNext(this._data); }
             }
-            delete(key: K): boolean {
-                if (!isObject(key)) throw new TypeError("Invalid value used as weak map key");
-                return !!deleteObjectEntry(this._mapData, key);
+            function fillMap<K, V>(object: MapShim<K, V>, [key, value]: readonly [K, V]) {
+                object.set(key, value);
             }
+            return class Map<K, V> implements MapShim<K, V> {
+                private _mapData = createMapData<K, V>();
+                constructor(iterable?: readonly (readonly [K, V])[] | ReadonlyMapShim<K, V>) {
+                    fill(this, getIterator(iterable), fillMap);
+                }
+                get size() { return this._mapData.size; }
+                get(key: K): V | undefined { return getEntry(this._mapData, key)?.value; }
+                set(key: K, value: V): this { return addOrUpdateEntry(this._mapData, key, value), this; }
+                has(key: K): boolean { return !!getEntry(this._mapData, key); }
+                delete(key: K): boolean { return !!deleteEntry(this._mapData, key); }
+                clear(): void { clearEntries(this._mapData); }
+                keys(): IteratorShim<K> { return new MapIterator(this._mapData, pickKey); }
+                values(): IteratorShim<V> { return new MapIterator(this._mapData, pickValue); }
+                entries(): IteratorShim<[K, V]> { return new MapIterator(this._mapData, pickEntry); }
+                forEach(action: (value: V, key: K) => void): void { forEachEntry(this._mapData, action); }
+            };
         }
-        return WeakMap;
-    }
 
-    // NOTE: Not a real WeakSet, this implementation will hold onto references until it is GC'ed. However, it's the best
-    // we can do without storing data on each value itself.
-    /* @internal */
-    export function createWeakSetShim(): new <T extends object>() => WeakSetShim<T> {
-        class WeakSet<T extends object> implements WeakSetShim<T> {
-            private _mapData = createWeakMapData<T, T>();
-            add(value: T): this {
-                if (!isObject(value)) throw new TypeError("Invalid value used in weak set");
-                addOrUpdateObjectEntry(this._mapData, value, value);
-                return this;
-            }
-            has(value: T): boolean {
-                if (!isObject(value)) throw new TypeError("Invalid value used in weak set");
-                return !!getObjectEntry(this._mapData, value);
+        export function createSetShim(getIterator: GetIteratorCallback): SetShimConstructor {
+            class SetIterator<K, V, U extends (K | V | [K, V])> {
+                private _data: IteratorData<K, V, U>;
+                constructor(data: MapData<K, V>, selector: (key: K, value: V) => U) {
+                    this._data = createIteratorData(data, selector);
+                }
+                next() { return iteratorNext(this._data); }
             }
-            delete(value: T): boolean {
-                if (!isObject(value)) throw new TypeError("Invalid value used in weak set");
-                return !!deleteObjectEntry(this._mapData, value);
+            function fillSet<T>(object: SetShim<T>, value: T) {
+                object.add(value);
             }
+            return class Set<T> implements SetShim<T> {
+                private _mapData = createMapData<T, T>();
+                constructor(iterable?: readonly T[] | ReadonlySetShim<T>) {
+                    fill(this, getIterator(iterable), fillSet);
+                }
+                get size() { return this._mapData.size; }
+                add(value: T): this { return addOrUpdateEntry(this._mapData, value, value), this; }
+                has(value: T): boolean { return !!getEntry(this._mapData, value); }
+                delete(value: T): boolean { return !!deleteEntry(this._mapData, value); }
+                clear(): void { clearEntries(this._mapData); }
+                keys(): IteratorShim<T> { return new SetIterator(this._mapData, pickKey); }
+                values(): IteratorShim<T> { return new SetIterator(this._mapData, pickValue); }
+                entries(): IteratorShim<[T, T]> { return new SetIterator(this._mapData, pickEntry); }
+                forEach(action: (value: T, key: T) => void): void { forEachEntry(this._mapData, action); }
+            };
         }
-        return WeakSet;
     }
 }
diff --git a/src/testRunner/unittests/createMapShim.ts b/src/testRunner/unittests/createMapShim.ts
index dc8f1c3dd87d2..aee5c48b5859e 100644
--- a/src/testRunner/unittests/createMapShim.ts
+++ b/src/testRunner/unittests/createMapShim.ts
@@ -128,7 +128,7 @@ namespace ts {
             assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
 
             // Then, test the map shim.
-            const MapShim = createMapShim(); // tslint:disable-line variable-name
+            const MapShim = ShimCollections.createMapShim(getIterator); // tslint:disable-line variable-name
             let localShimMap = new MapShim<string, string>();
             const shimMapForEachResult = testMapIterationAddedValues(stringKeys, localShimMap, /* useForEach */ true);
             assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
@@ -151,7 +151,7 @@ namespace ts {
             assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
 
             // Then, test the map shim.
-            const MapShim = createMapShim(); // tslint:disable-line variable-name
+            const MapShim = ShimCollections.createMapShim(getIterator); // tslint:disable-line variable-name
             let localShimMap = new MapShim<any, string>();
             const shimMapForEachResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ true);
             assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 89ab9f7cab6e5..af4c0fc768539 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -31,45 +31,39 @@ declare namespace ts {
     interface SortedArray<T> extends Array<T> {
         " __sortedArrayBrand": any;
     }
-    /** ES6 Map interface, only read methods included. */
-    interface ReadonlyMap<K, V> {
+    /** Common read methods for ES6 Map/Set. */
+    interface ReadonlyCollection<K> {
         readonly size: number;
-        get(key: K): V | undefined;
         has(key: K): boolean;
         keys(): Iterator<K>;
+    }
+    /** Common write methods for ES6 Map/Set. */
+    interface Collection<K> extends ReadonlyCollection<K> {
+        delete(key: K): boolean;
+        clear(): void;
+    }
+    /** ES6 Map interface, only read methods included. */
+    interface ReadonlyMap<K, V> extends ReadonlyCollection<K> {
+        get(key: K): V | undefined;
         values(): Iterator<V>;
         entries(): Iterator<[K, V]>;
         forEach(action: (value: V, key: K) => void): void;
     }
     /** ES6 Map interface. */
-    interface Map<K, V> extends ReadonlyMap<K, V> {
+    interface Map<K, V> extends ReadonlyMap<K, V>, Collection<K> {
         set(key: K, value: V): this;
-        delete(key: K): boolean;
-        clear(): void;
     }
-    interface ReadonlySet<T> {
-        readonly size: number;
+    /** ES6 Set interface, only read methods included. */
+    interface ReadonlySet<T> extends ReadonlyCollection<T> {
         has(value: T): boolean;
-        forEach(action: (value: T, key: T) => void): void;
-        keys(): Iterator<T>;
         values(): Iterator<T>;
         entries(): Iterator<[T, T]>;
+        forEach(action: (value: T, key: T) => void): void;
     }
-    interface Set<T> extends ReadonlySet<T> {
+    /** ES6 Set interface. */
+    interface Set<T> extends ReadonlySet<T>, Collection<T> {
         add(value: T): this;
         delete(value: T): boolean;
-        clear(): void;
-    }
-    interface WeakMap<K extends object, V> {
-        get(key: K): V | undefined;
-        has(key: K): boolean;
-        set(key: K, value: V): this;
-        delete(key: K): boolean;
-    }
-    interface WeakSet<T extends object> {
-        has(key: T): boolean;
-        add(key: T): this;
-        delete(key: T): boolean;
     }
     /** ES6 Iterator type. */
     interface Iterator<T> {
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 16fcc4836468a..b79a6662aadef 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -31,45 +31,39 @@ declare namespace ts {
     interface SortedArray<T> extends Array<T> {
         " __sortedArrayBrand": any;
     }
-    /** ES6 Map interface, only read methods included. */
-    interface ReadonlyMap<K, V> {
+    /** Common read methods for ES6 Map/Set. */
+    interface ReadonlyCollection<K> {
         readonly size: number;
-        get(key: K): V | undefined;
         has(key: K): boolean;
         keys(): Iterator<K>;
+    }
+    /** Common write methods for ES6 Map/Set. */
+    interface Collection<K> extends ReadonlyCollection<K> {
+        delete(key: K): boolean;
+        clear(): void;
+    }
+    /** ES6 Map interface, only read methods included. */
+    interface ReadonlyMap<K, V> extends ReadonlyCollection<K> {
+        get(key: K): V | undefined;
         values(): Iterator<V>;
         entries(): Iterator<[K, V]>;
         forEach(action: (value: V, key: K) => void): void;
     }
     /** ES6 Map interface. */
-    interface Map<K, V> extends ReadonlyMap<K, V> {
+    interface Map<K, V> extends ReadonlyMap<K, V>, Collection<K> {
         set(key: K, value: V): this;
-        delete(key: K): boolean;
-        clear(): void;
     }
-    interface ReadonlySet<T> {
-        readonly size: number;
+    /** ES6 Set interface, only read methods included. */
+    interface ReadonlySet<T> extends ReadonlyCollection<T> {
         has(value: T): boolean;
-        forEach(action: (value: T, key: T) => void): void;
-        keys(): Iterator<T>;
         values(): Iterator<T>;
         entries(): Iterator<[T, T]>;
+        forEach(action: (value: T, key: T) => void): void;
     }
-    interface Set<T> extends ReadonlySet<T> {
+    /** ES6 Set interface. */
+    interface Set<T> extends ReadonlySet<T>, Collection<T> {
         add(value: T): this;
         delete(value: T): boolean;
-        clear(): void;
-    }
-    interface WeakMap<K extends object, V> {
-        get(key: K): V | undefined;
-        has(key: K): boolean;
-        set(key: K, value: V): this;
-        delete(key: K): boolean;
-    }
-    interface WeakSet<T extends object> {
-        has(key: T): boolean;
-        add(key: T): this;
-        delete(key: T): boolean;
     }
     /** ES6 Iterator type. */
     interface Iterator<T> {

From c6fc934e29b77901f34095c5fa372afac069504d Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Thu, 18 Jun 2020 18:08:45 -0700
Subject: [PATCH 04/10] Add tests for set shim

---
 src/testRunner/tsconfig.json              |   1 +
 src/testRunner/unittests/createSetShim.ts | 162 ++++++++++++++++++++++
 2 files changed, 163 insertions(+)
 create mode 100644 src/testRunner/unittests/createSetShim.ts

diff --git a/src/testRunner/tsconfig.json b/src/testRunner/tsconfig.json
index f17f10789f03b..9de2381228c0a 100644
--- a/src/testRunner/tsconfig.json
+++ b/src/testRunner/tsconfig.json
@@ -73,6 +73,7 @@
         "unittests/reuseProgramStructure.ts",
         "unittests/semver.ts",
         "unittests/createMapShim.ts",
+        "unittests/createSetShim.ts",
         "unittests/transform.ts",
         "unittests/config/commandLineParsing.ts",
         "unittests/config/configurationExtension.ts",
diff --git a/src/testRunner/unittests/createSetShim.ts b/src/testRunner/unittests/createSetShim.ts
new file mode 100644
index 0000000000000..f21cdd4e7f84d
--- /dev/null
+++ b/src/testRunner/unittests/createSetShim.ts
@@ -0,0 +1,162 @@
+namespace ts {
+    describe("unittests:: createSetShim", () => {
+        const stringKeys = [
+            "1",
+            "3",
+            "2",
+            "4",
+            "0",
+            "999",
+            "A",
+            "B",
+            "C",
+            "Z",
+            "X",
+            "X1",
+            "X2",
+            "Y"
+        ];
+
+        const mixedKeys = [
+            true,
+            3,
+            { toString() { return "2"; } },
+            "4",
+            false,
+            null, // eslint-disable-line no-null/no-null
+            undefined,
+            "B",
+            { toString() { return "C"; } },
+            "Z",
+            "X",
+            { toString() { return "X1"; } },
+            "X2",
+            "Y"
+        ];
+
+        function testSetIterationAddedValues<K>(keys: K[], set: Set<K>, useForEach: boolean): string {
+            let resultString = "";
+
+            set.add(keys[0]);
+            set.add(keys[1]);
+            set.add(keys[2]);
+            set.add(keys[3]);
+
+            let addedThree = false;
+            const doForEach = (key: K) => {
+                resultString += `${key};`;
+
+                // Add a new key ("0") - the map should provide this
+                // one in the next iteration.
+                if (key === keys[0]) {
+                    set.add(keys[0]);
+                    set.add(keys[4]);
+                    set.add(keys[3]);
+                }
+                else if (key === keys[1]) {
+                    if (!addedThree) {
+                        addedThree = true;
+
+                        // Remove and re-add key "3"; the map should
+                        // visit it after "0".
+                        set.delete(keys[1]);
+                        set.add(keys[1]);
+
+                        // Change the value of "2"; the map should provide
+                        // it when visiting the key.
+                        set.add(keys[2]);
+                    }
+                    else {
+                        // Check that an entry added when we visit the
+                        // currently last entry will still be visited.
+                        set.add(keys[5]);
+                    }
+                }
+                else if (key === keys[5]) {
+                    // Ensure that clear() behaves correctly same as removing all keys.
+                    set.add(keys[6]);
+                    set.add(keys[7]);
+                    set.add(keys[8]);
+                }
+                else if (key === keys[6]) {
+                    set.clear();
+                    set.add(keys[9]);
+                }
+                else if (key === keys[9]) {
+                    // Check that the map behaves correctly when two items are
+                    // added and removed immediately.
+                    set.add(keys[10]);
+                    set.add(keys[11]);
+                    set.add(keys[12]);
+                    set.delete(keys[11]);
+                    set.delete(keys[12]);
+                    set.add(keys[13]);
+                }
+            };
+
+            if (useForEach) {
+                set.forEach(doForEach);
+            }
+            else {
+                // Use an iterator.
+                const iterator = set.values();
+                while (true) {
+                    const iterResult = iterator.next();
+                    if (iterResult.done) {
+                        break;
+                    }
+
+                    doForEach(iterResult.value);
+                }
+            }
+
+            return resultString;
+        }
+
+        it("iterates values in insertion order and handles changes with string keys", () => {
+            const expectedResult = "1;3;2;4;0;3;999;A;Z;X;Y;";
+
+            // First, ensure the test actually has the same behavior as a native Map.
+            let nativeSet = new Set<string>();
+            const nativeSetForEachResult = testSetIterationAddedValues(stringKeys, nativeSet, /* useForEach */ true);
+            assert.equal(nativeSetForEachResult, expectedResult, "nativeSet-forEach");
+
+            nativeSet = new Set<string>();
+            const nativeSetIteratorResult = testSetIterationAddedValues(stringKeys, nativeSet, /* useForEach */ false);
+            assert.equal(nativeSetIteratorResult, expectedResult, "nativeSet-iterator");
+
+            // Then, test the map shim.
+            const SetShim = ShimCollections.createSetShim(getIterator);
+            let localShimSet = new SetShim<string>();
+            const shimSetForEachResult = testSetIterationAddedValues(stringKeys, localShimSet, /* useForEach */ true);
+            assert.equal(shimSetForEachResult, expectedResult, "shimSet-forEach");
+
+            localShimSet = new SetShim<string>();
+            const shimSetIteratorResult = testSetIterationAddedValues(stringKeys, localShimSet, /* useForEach */ false);
+            assert.equal(shimSetIteratorResult, expectedResult, "shimSet-iterator");
+        });
+
+        it("iterates values in insertion order and handles changes with mixed-type keys", () => {
+            const expectedResult = "true;3;2;4;false;3;null;undefined;Z;X;Y;";
+
+            // First, ensure the test actually has the same behavior as a native Map.
+            let nativeSet = new Set<any>();
+            const nativeSetForEachResult = testSetIterationAddedValues(mixedKeys, nativeSet, /* useForEach */ true);
+            assert.equal(nativeSetForEachResult, expectedResult, "nativeSet-forEach");
+
+            nativeSet = new Set<any>();
+            const nativeSetIteratorResult = testSetIterationAddedValues(mixedKeys, nativeSet, /* useForEach */ false);
+            assert.equal(nativeSetIteratorResult, expectedResult, "nativeSet-iterator");
+
+            // Then, test the map shim.
+            const SetShim = ShimCollections.createSetShim(getIterator); // tslint:disable-line variable-name
+            let localshimSet = new SetShim<any>();
+            const shimSetForEachResult = testSetIterationAddedValues(mixedKeys, localshimSet, /* useForEach */ true);
+            assert.equal(shimSetForEachResult, expectedResult, "shimSet-forEach");
+
+            localshimSet = new SetShim<any>();
+            const shimSetIteratorResult = testSetIterationAddedValues(mixedKeys, localshimSet, /* useForEach */ false);
+            assert.equal(shimSetIteratorResult, expectedResult, "shimSet-iterator");
+        });
+    });
+}

From 2f484289c81423bd3939ec7d5431165dc05a111b Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Thu, 18 Jun 2020 23:41:52 -0700
Subject: [PATCH 05/10] Update most usages of Map<K, true> to Set

---
 src/compiler/builder.ts                       | 52 +++++++------
 src/compiler/builderState.ts                  | 24 +++---
 src/compiler/checker.ts                       | 73 +++++++++----------
 src/compiler/core.ts                          |  8 ++
 src/compiler/emitter.ts                       | 30 ++++----
 src/compiler/parser.ts                        |  6 +-
 src/compiler/program.ts                       | 26 +++----
 src/compiler/resolutionCache.ts               |  4 +-
 src/compiler/transformers/declarations.ts     |  6 +-
 src/compiler/utilities.ts                     |  2 +-
 src/server/editorServices.ts                  | 24 +++---
 src/server/project.ts                         | 14 ++--
 src/server/scriptInfo.ts                      |  4 +-
 src/server/session.ts                         | 10 +--
 src/services/codefixes/addMissingAsync.ts     | 10 +--
 src/services/codefixes/addMissingAwait.ts     | 16 ++--
 .../codefixes/convertToAsyncFunction.ts       | 16 ++--
 src/services/codefixes/convertToEs6Module.ts  |  6 +-
 .../codefixes/disableJsDiagnostics.ts         |  6 +-
 src/services/completions.ts                   | 10 +--
 src/services/documentHighlights.ts            |  2 +-
 src/services/findAllReferences.ts             | 20 ++---
 src/services/importTracker.ts                 |  4 +-
 src/testRunner/unittests/tsbuild/helpers.ts   |  4 +-
 src/testRunner/unittests/tsc/helpers.ts       |  8 +-
 src/typingsInstallerCore/typingsInstaller.ts  | 16 ++--
 26 files changed, 201 insertions(+), 200 deletions(-)

diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
index 488c89bea24ef..18acfdfe3f450 100644
--- a/src/compiler/builder.ts
+++ b/src/compiler/builder.ts
@@ -28,7 +28,7 @@ namespace ts {
         /**
          * The map has key by source file's path that has been changed
          */
-        changedFilesSet?: ReadonlyMap<string, true>;
+        changedFilesSet?: ReadonlySet<string>;
         /**
          * Set of affected files being iterated
          */
@@ -49,7 +49,7 @@ namespace ts {
         /**
          * True if the semantic diagnostics were copied from the old state
          */
-        semanticDiagnosticsFromOldState?: Map<string, true>;
+        semanticDiagnosticsFromOldState?: Set<string>;
         /**
          * program corresponding to this state
          */
@@ -93,7 +93,7 @@ namespace ts {
         /**
          * The map has key by source file's path that has been changed
          */
-        changedFilesSet: Map<string, true>;
+        changedFilesSet: Set<string>;
         /**
          * Set of affected files being iterated
          */
@@ -118,7 +118,7 @@ namespace ts {
         /**
          * Already seen affected files
          */
-        seenAffectedFiles: Map<string, true> | undefined;
+        seenAffectedFiles: Set<string> | undefined;
         /**
          * whether this program has cleaned semantic diagnostics cache for lib files
          */
@@ -126,7 +126,7 @@ namespace ts {
         /**
          * True if the semantic diagnostics were copied from the old state
          */
-        semanticDiagnosticsFromOldState?: Map<string, true>;
+        semanticDiagnosticsFromOldState?: Set<string>;
         /**
          * program corresponding to this state
          */
@@ -161,9 +161,9 @@ namespace ts {
         programEmitComplete?: true;
     }
 
-    function hasSameKeys<T, U>(map1: ReadonlyMap<string, T> | undefined, map2: ReadonlyMap<string, U> | undefined): boolean {
+    function hasSameKeys(map1: ReadonlyCollection<string> | undefined, map2: ReadonlyCollection<string> | undefined): boolean {
         // Has same size and every key is present in both maps
-        return map1 as ReadonlyMap<string, T | U> === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !forEachKey(map1, key => !map2.has(key));
+        return map1 === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !forEachKey(map1, key => !map2.has(key));
     }
 
     /**
@@ -178,7 +178,7 @@ namespace ts {
         if (!outFile(compilerOptions)) {
             state.semanticDiagnosticsPerFile = createMap<readonly Diagnostic[]>();
         }
-        state.changedFilesSet = createMap<true>();
+        state.changedFilesSet = new Set();
 
         const useOldState = BuilderState.canReuseOldState(state.referencedMap, oldState);
         const oldCompilerOptions = useOldState ? oldState!.compilerOptions : undefined;
@@ -196,14 +196,12 @@ namespace ts {
             }
 
             // Copy old state's changed files set
-            if (changedFilesSet) {
-                copyEntries(changedFilesSet, state.changedFilesSet);
-            }
+            changedFilesSet?.forEach(value => state.changedFilesSet.add(value));
             if (!outFile(compilerOptions) && oldState!.affectedFilesPendingEmit) {
                 state.affectedFilesPendingEmit = oldState!.affectedFilesPendingEmit.slice();
                 state.affectedFilesPendingEmitKind = cloneMapOrUndefined(oldState!.affectedFilesPendingEmitKind);
                 state.affectedFilesPendingEmitIndex = oldState!.affectedFilesPendingEmitIndex;
-                state.seenAffectedFiles = createMap();
+                state.seenAffectedFiles = new Set();
             }
         }
 
@@ -227,7 +225,7 @@ namespace ts {
                 // Referenced file was deleted in the new program
                 newReferences && forEachKey(newReferences, path => !state.fileInfos.has(path) && oldState!.fileInfos.has(path))) {
                 // Register file as changed file and do not copy semantic diagnostics, since all changed files need to be re-evaluated
-                state.changedFilesSet.set(sourceFilePath, true);
+                state.changedFilesSet.add(sourceFilePath);
             }
             else if (canCopySemanticDiagnostics) {
                 const sourceFile = newProgram.getSourceFileByPath(sourceFilePath as Path)!;
@@ -240,9 +238,9 @@ namespace ts {
                 if (diagnostics) {
                     state.semanticDiagnosticsPerFile!.set(sourceFilePath, oldState!.hasReusableDiagnostic ? convertToDiagnostics(diagnostics as readonly ReusableDiagnostic[], newProgram, getCanonicalFileName) : diagnostics as readonly Diagnostic[]);
                     if (!state.semanticDiagnosticsFromOldState) {
-                        state.semanticDiagnosticsFromOldState = createMap<true>();
+                        state.semanticDiagnosticsFromOldState = new Set();
                     }
-                    state.semanticDiagnosticsFromOldState.set(sourceFilePath, true);
+                    state.semanticDiagnosticsFromOldState.add(sourceFilePath);
                 }
             }
         });
@@ -250,13 +248,13 @@ namespace ts {
         // If the global file is removed, add all files as changed
         if (useOldState && forEachEntry(oldState!.fileInfos, (info, sourceFilePath) => info.affectsGlobalScope && !state.fileInfos.has(sourceFilePath))) {
             BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, /*firstSourceFile*/ undefined)
-                .forEach(file => state.changedFilesSet.set(file.resolvedPath, true));
+                .forEach(file => state.changedFilesSet.add(file.resolvedPath));
         }
         else if (oldCompilerOptions && !outFile(compilerOptions) && compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
             // Add all files to affectedFilesPendingEmit since emit changed
             newProgram.getSourceFiles().forEach(f => addToAffectedFilesPendingEmit(state, f.resolvedPath, BuilderFileEmit.Full));
             Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
-            state.seenAffectedFiles = state.seenAffectedFiles || createMap<true>();
+            state.seenAffectedFiles = state.seenAffectedFiles || new Set();
         }
 
         state.buildInfoEmitPending = !!state.changedFilesSet.size;
@@ -308,15 +306,15 @@ namespace ts {
     function cloneBuilderProgramState(state: Readonly<BuilderProgramState>): BuilderProgramState {
         const newState = BuilderState.clone(state) as BuilderProgramState;
         newState.semanticDiagnosticsPerFile = cloneMapOrUndefined(state.semanticDiagnosticsPerFile);
-        newState.changedFilesSet = cloneMap(state.changedFilesSet);
+        newState.changedFilesSet = new Set(state.changedFilesSet);
         newState.affectedFiles = state.affectedFiles;
         newState.affectedFilesIndex = state.affectedFilesIndex;
         newState.currentChangedFilePath = state.currentChangedFilePath;
         newState.currentAffectedFilesSignatures = cloneMapOrUndefined(state.currentAffectedFilesSignatures);
         newState.currentAffectedFilesExportedModulesMap = cloneMapOrUndefined(state.currentAffectedFilesExportedModulesMap);
-        newState.seenAffectedFiles = cloneMapOrUndefined(state.seenAffectedFiles);
+        newState.seenAffectedFiles = state.seenAffectedFiles && new Set(state.seenAffectedFiles);
         newState.cleanedDiagnosticsOfLibFiles = state.cleanedDiagnosticsOfLibFiles;
-        newState.semanticDiagnosticsFromOldState = cloneMapOrUndefined(state.semanticDiagnosticsFromOldState);
+        newState.semanticDiagnosticsFromOldState = state.semanticDiagnosticsFromOldState && new Set(state.semanticDiagnosticsFromOldState);
         newState.program = state.program;
         newState.compilerOptions = state.compilerOptions;
         newState.affectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
@@ -391,7 +389,7 @@ namespace ts {
             state.affectedFiles = BuilderState.getFilesAffectedBy(state, program, nextKey.value as Path, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
             state.currentChangedFilePath = nextKey.value as Path;
             state.affectedFilesIndex = 0;
-            state.seenAffectedFiles = state.seenAffectedFiles || createMap<true>();
+            state.seenAffectedFiles = state.seenAffectedFiles || new Set();
         }
     }
 
@@ -533,7 +531,7 @@ namespace ts {
         }
 
         Debug.assert(!!state.currentAffectedFilesExportedModulesMap);
-        const seenFileAndExportsOfFile = createMap<true>();
+        const seenFileAndExportsOfFile = new Set<string>();
         // Go through exported modules from cache first
         // If exported modules has path, all files referencing file exported from are affected
         if (forEachEntry(state.currentAffectedFilesExportedModulesMap, (exportedModules, exportedFromPath) =>
@@ -555,7 +553,7 @@ namespace ts {
     /**
      * Iterate on files referencing referencedPath
      */
-    function forEachFilesReferencingPath(state: BuilderProgramState, referencedPath: Path, seenFileAndExportsOfFile: Map<string, true>, fn: (state: BuilderProgramState, filePath: Path) => boolean) {
+    function forEachFilesReferencingPath(state: BuilderProgramState, referencedPath: Path, seenFileAndExportsOfFile: Set<string>, fn: (state: BuilderProgramState, filePath: Path) => boolean) {
         return forEachEntry(state.referencedMap!, (referencesInFile, filePath) =>
             referencesInFile.has(referencedPath) && forEachFileAndExportsOfFile(state, filePath as Path, seenFileAndExportsOfFile, fn)
         );
@@ -564,8 +562,8 @@ namespace ts {
     /**
      * fn on file and iterate on anything that exports this file
      */
-    function forEachFileAndExportsOfFile(state: BuilderProgramState, filePath: Path, seenFileAndExportsOfFile: Map<string, true>, fn: (state: BuilderProgramState, filePath: Path) => boolean): boolean {
-        if (!addToSeen(seenFileAndExportsOfFile, filePath)) {
+    function forEachFileAndExportsOfFile(state: BuilderProgramState, filePath: Path, seenFileAndExportsOfFile: Set<string>, fn: (state: BuilderProgramState, filePath: Path) => boolean): boolean {
+        if (!tryAddToSet(seenFileAndExportsOfFile, filePath)) {
             return false;
         }
 
@@ -622,7 +620,7 @@ namespace ts {
             state.programEmitComplete = true;
         }
         else {
-            state.seenAffectedFiles!.set((affected as SourceFile).resolvedPath, true);
+            state.seenAffectedFiles!.add((affected as SourceFile).resolvedPath);
             if (emitKind !== undefined) {
                 (state.seenEmittedFiles || (state.seenEmittedFiles = createMap())).set((affected as SourceFile).resolvedPath, emitKind);
             }
@@ -1149,7 +1147,7 @@ namespace ts {
         // template is undefined, and instead will just exit the loop.
         for (const key in mapLike) {
             if (hasProperty(mapLike, key)) {
-                map.set(toPath(key), arrayToSet(mapLike[key], toPath));
+                map.set(toPath(key), new Set(mapLike[key].map(toPath)));
             }
         }
         return map;
diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index beea442101eab..15a0df20f7286 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -50,7 +50,7 @@ namespace ts {
          * That means hence forth these files are assumed to have
          * no change in their signature for this version of the program
          */
-        hasCalledUpdateShapeSignature: Map<string, true>;
+        hasCalledUpdateShapeSignature: Set<string>;
         /**
          * Cache of all files excluding default library file for the current program
          */
@@ -73,7 +73,7 @@ namespace ts {
         /**
          * Referenced files with values for the keys as referenced file's path to be true
          */
-        export type ReferencedSet = ReadonlyMap<string, true>;
+        export type ReferencedSet = ReadonlySet<string>;
         /**
          * Compute the hash to store the shape of the file
          */
@@ -113,8 +113,8 @@ namespace ts {
         /**
          * Gets the referenced files for a file from the program with values for the keys as referenced file's path to be true
          */
-        function getReferencedFiles(program: Program, sourceFile: SourceFile, getCanonicalFileName: GetCanonicalFileName): Map<string, true> | undefined {
-            let referencedFiles: Map<string, true> | undefined;
+        function getReferencedFiles(program: Program, sourceFile: SourceFile, getCanonicalFileName: GetCanonicalFileName): Set<string> | undefined {
+            let referencedFiles: Set<string> | undefined;
 
             // We need to use a set here since the code can contain the same import twice,
             // but that will only be one dependency.
@@ -186,9 +186,9 @@ namespace ts {
 
             function addReferencedFile(referencedPath: Path) {
                 if (!referencedFiles) {
-                    referencedFiles = createMap<true>();
+                    referencedFiles = new Set<string>();
                 }
-                referencedFiles.set(referencedPath, true);
+                referencedFiles.add(referencedPath);
             }
         }
 
@@ -206,7 +206,7 @@ namespace ts {
             const fileInfos = createMap<FileInfo>();
             const referencedMap = newProgram.getCompilerOptions().module !== ModuleKind.None ? createMap<ReferencedSet>() : undefined;
             const exportedModulesMap = referencedMap ? createMap<ReferencedSet>() : undefined;
-            const hasCalledUpdateShapeSignature = createMap<true>();
+            const hasCalledUpdateShapeSignature = new Set<string>();
             const useOldState = canReuseOldState(referencedMap, oldState);
 
             // Create the reference map, and set the file infos
@@ -258,7 +258,7 @@ namespace ts {
                 fileInfos,
                 referencedMap: cloneMapOrUndefined(state.referencedMap),
                 exportedModulesMap: cloneMapOrUndefined(state.exportedModulesMap),
-                hasCalledUpdateShapeSignature: cloneMap(state.hasCalledUpdateShapeSignature),
+                hasCalledUpdateShapeSignature: new Set(state.hasCalledUpdateShapeSignature),
             };
         }
 
@@ -298,7 +298,7 @@ namespace ts {
 
         export function updateSignatureOfFile(state: BuilderState, signature: string | undefined, path: Path) {
             state.fileInfos.get(path)!.signature = signature;
-            state.hasCalledUpdateShapeSignature.set(path, true);
+            state.hasCalledUpdateShapeSignature.add(path);
         }
 
         /**
@@ -365,16 +365,16 @@ namespace ts {
                 return;
             }
 
-            let exportedModules: Map<string, true> | undefined;
+            let exportedModules: Set<string> | undefined;
             exportedModulesFromDeclarationEmit.forEach(symbol => addExportedModule(getReferencedFileFromImportedModuleSymbol(symbol)));
             exportedModulesMapCache.set(sourceFile.resolvedPath, exportedModules || false);
 
             function addExportedModule(exportedModulePath: Path | undefined) {
                 if (exportedModulePath) {
                     if (!exportedModules) {
-                        exportedModules = createMap<true>();
+                        exportedModules = new Set();
                     }
-                    exportedModules.set(exportedModulePath, true);
+                    exportedModules.add(exportedModulePath);
                 }
             }
         }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ea212dea29e7a..478bed61ddbf9 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -277,13 +277,13 @@ namespace ts {
     }
 
     export function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker {
-        const getPackagesSet: () => Map<string, true> = memoize(() => {
-            const set = createMap<true>();
+        const getPackagesSet = memoize(() => {
+            const set = new Set<string>();
             host.getSourceFiles().forEach(sf => {
                 if (!sf.resolvedModules) return;
 
                 forEachEntry(sf.resolvedModules, r => {
-                    if (r && r.packageId) set.set(r.packageId.name, true);
+                    if (r && r.packageId) set.add(r.packageId.name);
                 });
             });
             return set;
@@ -4457,7 +4457,7 @@ namespace ts {
 
                 function typeToTypeNodeOrCircularityElision(type: Type) {
                     if (type.flags & TypeFlags.Union) {
-                        if (context.visitedTypes && context.visitedTypes.has("" + getTypeId(type))) {
+                        if (context.visitedTypes?.has(getTypeId(type))) {
                             if (!(context.flags & NodeBuilderFlags.AllowAnonymousIdentifier)) {
                                 context.encounteredError = true;
                                 context.tracker?.reportCyclicStructureError?.();
@@ -4490,7 +4490,7 @@ namespace ts {
                 }
 
                 function createAnonymousTypeNode(type: ObjectType): TypeNode {
-                    const typeId = "" + type.id;
+                    const typeId = type.id;
                     const symbol = type.symbol;
                     if (symbol) {
                         if (isJSConstructor(symbol.valueDeclaration)) {
@@ -4504,7 +4504,7 @@ namespace ts {
                             shouldWriteTypeOfFunctionSymbol()) {
                             return symbolToTypeNode(symbol, context, SymbolFlags.Value);
                         }
-                        else if (context.visitedTypes && context.visitedTypes.has(typeId)) {
+                        else if (context.visitedTypes?.has(typeId)) {
                             // If type is an anonymous type literal in a type alias declaration, use type alias name
                             const typeAlias = getTypeAliasForTypeLiteral(type);
                             if (typeAlias) {
@@ -4532,14 +4532,14 @@ namespace ts {
                                     declaration.parent.kind === SyntaxKind.SourceFile || declaration.parent.kind === SyntaxKind.ModuleBlock));
                         if (isStaticMethodSymbol || isNonLocalFunctionSymbol) {
                             // typeof is allowed only for static/non local functions
-                            return (!!(context.flags & NodeBuilderFlags.UseTypeOfFunction) || (context.visitedTypes && context.visitedTypes.has(typeId))) && // it is type of the symbol uses itself recursively
+                            return (!!(context.flags & NodeBuilderFlags.UseTypeOfFunction) || (context.visitedTypes?.has(typeId))) && // it is type of the symbol uses itself recursively
                                 (!(context.flags & NodeBuilderFlags.UseStructuralFallback) || isValueSymbolAccessible(symbol, context.enclosingDeclaration)); // And the build is going to succeed without visibility error or there is no structural fallback allowed
                         }
                     }
                 }
 
                 function visitAndTransformType<T>(type: Type, transform: (type: Type) => T) {
-                    const typeId = "" + type.id;
+                    const typeId = type.id;
                     const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class;
                     const id = getObjectFlags(type) & ObjectFlags.Reference && (<TypeReference>type).node ? "N" + getNodeId((<TypeReference>type).node!) :
                         type.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type.symbol) :
@@ -4547,7 +4547,7 @@ namespace ts {
                     // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead
                     // of types allows us to catch circular references to instantiations of the same anonymous type
                     if (!context.visitedTypes) {
-                        context.visitedTypes = createMap<true>();
+                        context.visitedTypes = new Set();
                     }
                     if (id && !context.symbolDepth) {
                         context.symbolDepth = createMap<number>();
@@ -4561,7 +4561,7 @@ namespace ts {
                         }
                         context.symbolDepth!.set(id, depth + 1);
                     }
-                    context.visitedTypes.set(typeId, true);
+                    context.visitedTypes.add(typeId);
                     const result = transform(type);
                     context.visitedTypes.delete(typeId);
                     if (id) {
@@ -5250,11 +5250,11 @@ namespace ts {
             function lookupTypeParameterNodes(chain: Symbol[], index: number, context: NodeBuilderContext) {
                 Debug.assert(chain && 0 <= index && index < chain.length);
                 const symbol = chain[index];
-                const symbolId = "" + getSymbolId(symbol);
-                if (context.typeParameterSymbolList && context.typeParameterSymbolList.get(symbolId)) {
+                const symbolId = getSymbolId(symbol);
+                if (context.typeParameterSymbolList?.has(symbolId)) {
                     return undefined;
                 }
-                (context.typeParameterSymbolList || (context.typeParameterSymbolList = createMap())).set(symbolId, true);
+                (context.typeParameterSymbolList || (context.typeParameterSymbolList = new Set())).add(symbolId);
                 let typeParameterNodes: readonly TypeNode[] | readonly TypeParameterDeclaration[] | undefined;
                 if (context.flags & NodeBuilderFlags.WriteTypeParametersInQualifiedName && index < (chain.length - 1)) {
                     const parentSymbol = symbol;
@@ -5467,7 +5467,7 @@ namespace ts {
                     const rawtext = result.escapedText as string;
                     let i = 0;
                     let text = rawtext;
-                    while ((context.typeParameterNamesByText && context.typeParameterNamesByText.get(text)) || typeParameterShadowsNameInScope(text as __String, context, type)) {
+                    while (context.typeParameterNamesByText?.has(text) || typeParameterShadowsNameInScope(text as __String, context, type)) {
                         i++;
                         text = `${rawtext}_${i}`;
                     }
@@ -5475,7 +5475,7 @@ namespace ts {
                         result = factory.createIdentifier(text, result.typeArguments);
                     }
                     (context.typeParameterNames || (context.typeParameterNames = createMap())).set("" + getTypeId(type), result);
-                    (context.typeParameterNamesByText || (context.typeParameterNamesByText = createMap())).set(result.escapedText as string, true);
+                    (context.typeParameterNamesByText || (context.typeParameterNamesByText = new Set())).add(result.escapedText as string);
                 }
                 return result;
             }
@@ -5634,10 +5634,10 @@ namespace ts {
                     initial.typeParameterNames = cloneMap(initial.typeParameterNames);
                 }
                 if (initial.typeParameterNamesByText) {
-                    initial.typeParameterNamesByText = cloneMap(initial.typeParameterNamesByText);
+                    initial.typeParameterNamesByText = new Set(initial.typeParameterNamesByText);
                 }
                 if (initial.typeParameterSymbolList) {
-                    initial.typeParameterSymbolList = cloneMap(initial.typeParameterSymbolList);
+                    initial.typeParameterSymbolList = new Set(initial.typeParameterSymbolList);
                 }
                 return initial;
             }
@@ -5876,12 +5876,12 @@ namespace ts {
                 // we're trying to emit from later on)
                 const enclosingDeclaration = context.enclosingDeclaration!;
                 let results: Statement[] = [];
-                const visitedSymbols: Map<string, true> = createMap();
+                const visitedSymbols = new Set<number>();
                 let deferredPrivates: Map<string, Symbol> | undefined;
                 const oldcontext = context;
                 context = {
                     ...oldcontext,
-                    usedSymbolNames: createMap(),
+                    usedSymbolNames: new Set(oldcontext.usedSymbolNames),
                     remappedSymbolNames: createMap(),
                     tracker: {
                         ...oldcontext.tracker,
@@ -5900,11 +5900,6 @@ namespace ts {
                         }
                     }
                 };
-                if (oldcontext.usedSymbolNames) {
-                    oldcontext.usedSymbolNames.forEach((_, name) => {
-                        context.usedSymbolNames!.set(name, true);
-                    });
-                }
                 forEachEntry(symbolTable, (symbol, name) => {
                     const baseName = unescapeLeadingUnderscores(name);
                     void getInternalSymbolName(symbol, baseName); // Called to cache values into `usedSymbolNames` and `remappedSymbolNames`
@@ -6115,10 +6110,10 @@ namespace ts {
                     // cache visited list based on merged symbol, since we want to use the unmerged top-level symbol, but
                     // still skip reserializing it if we encounter the merged product later on
                     const visitedSym = getMergedSymbol(symbol);
-                    if (visitedSymbols.has("" + getSymbolId(visitedSym))) {
+                    if (visitedSymbols.has(getSymbolId(visitedSym))) {
                         return; // Already printed
                     }
-                    visitedSymbols.set("" + getSymbolId(visitedSym), true);
+                    visitedSymbols.add(getSymbolId(visitedSym));
                     // Only actually serialize symbols within the correct enclosing declaration, otherwise do nothing with the out-of-context symbol
                     const skipMembershipCheck = !isPrivate; // We only call this on exported symbols when we know they're in the correct scope
                     if (skipMembershipCheck || (!!length(symbol.declarations) && some(symbol.declarations, d => !!findAncestor(d, n => n === enclosingDeclaration)))) {
@@ -7073,11 +7068,11 @@ namespace ts {
                     }
                     let i = 0;
                     const original = input;
-                    while (context.usedSymbolNames!.has(input)) {
+                    while (context.usedSymbolNames?.has(input)) {
                         i++;
                         input = `${original}_${i}`;
                     }
-                    context.usedSymbolNames!.set(input, true);
+                    context.usedSymbolNames?.add(input);
                     if (symbol) {
                         context.remappedSymbolNames!.set("" + getSymbolId(symbol), input);
                     }
@@ -7189,15 +7184,15 @@ namespace ts {
 
             // State
             encounteredError: boolean;
-            visitedTypes: Map<string, true> | undefined;
+            visitedTypes: Set<number> | undefined;
             symbolDepth: Map<string, number> | undefined;
             inferTypeParameters: TypeParameter[] | undefined;
             approximateLength: number;
             truncating?: boolean;
-            typeParameterSymbolList?: Map<string, true>;
+            typeParameterSymbolList?: Set<number>;
             typeParameterNames?: Map<string, Identifier>;
-            typeParameterNamesByText?: Map<string, true>;
-            usedSymbolNames?: Map<string, true>;
+            typeParameterNamesByText?: Set<string>;
+            usedSymbolNames?: Set<string>;
             remappedSymbolNames?: Map<string, string>;
         }
 
@@ -7394,10 +7389,10 @@ namespace ts {
                 exportSymbol = getTargetOfExportSpecifier(<ExportSpecifier>node.parent, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias);
             }
             let result: Node[] | undefined;
-            let visited: Map<string, true> | undefined;
+            let visited: Set<number> | undefined;
             if (exportSymbol) {
-                visited = createMap();
-                visited.set("" + getSymbolId(exportSymbol), true);
+                visited = new Set();
+                visited.add(getSymbolId(exportSymbol));
                 buildVisibleNodeList(exportSymbol.declarations);
             }
             return result;
@@ -7419,10 +7414,10 @@ namespace ts {
                         const firstIdentifier = getFirstIdentifier(internalModuleReference);
                         const importSymbol = resolveName(declaration, firstIdentifier.escapedText, SymbolFlags.Value | SymbolFlags.Type | SymbolFlags.Namespace,
                             undefined, undefined, /*isUse*/ false);
-                        const id = importSymbol && "" + getSymbolId(importSymbol);
-                        if (importSymbol && !visited!.has(id!)) {
-                            visited!.set(id!, true);
-                            buildVisibleNodeList(importSymbol.declarations);
+                        if (importSymbol && visited) {
+                            if (tryAddToSet(visited, getSymbolId(importSymbol))) {
+                                buildVisibleNodeList(importSymbol.declarations);
+                            }
                         }
                     }
                 });
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 40da8b819b554..73c77251f7720 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -595,6 +595,14 @@ namespace ts {
         }
     }
 
+    export function tryAddToSet<T>(set: Set<T>, value: T) {
+        if (!set.has(value)) {
+            set.add(value);
+            return true;
+        }
+        return false;
+    }
+
     export const emptyIterator: Iterator<never> = { next: () => ({ value: undefined as never, done: true }) };
 
     export function singleIterator<T>(value: T): Iterator<T> {
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 1243440e45810..6cbe25b92671e 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -839,11 +839,11 @@ namespace ts {
         let currentSourceFile: SourceFile | undefined;
         let nodeIdToGeneratedName: string[]; // Map of generated names for specific nodes.
         let autoGeneratedIdToGeneratedName: string[]; // Map of generated names for temp and loop variables.
-        let generatedNames: Map<string, true>; // Set of names generated by the NameGenerator.
+        let generatedNames: Set<string>; // Set of names generated by the NameGenerator.
         let tempFlagsStack: TempFlags[]; // Stack of enclosing name generation scopes.
         let tempFlags: TempFlags; // TempFlags for the current name generation scope.
-        let reservedNamesStack: Map<string, true>[]; // Stack of TempFlags reserved in enclosing name generation scopes.
-        let reservedNames: Map<string, true>; // TempFlags to reserve in nested name generation scopes.
+        let reservedNamesStack: Set<string>[]; // Stack of TempFlags reserved in enclosing name generation scopes.
+        let reservedNames: Set<string>; // TempFlags to reserve in nested name generation scopes.
         let preserveSourceNewlines = printerOptions.preserveSourceNewlines; // Can be overridden inside nodes with the `IgnoreSourceNewlines` emit flag.
 
         let writer: EmitTextWriter;
@@ -1119,7 +1119,7 @@ namespace ts {
         function reset() {
             nodeIdToGeneratedName = [];
             autoGeneratedIdToGeneratedName = [];
-            generatedNames = createMap<true>();
+            generatedNames = new Set();
             tempFlagsStack = [];
             tempFlags = TempFlags.Auto;
             reservedNamesStack = [];
@@ -3718,7 +3718,7 @@ namespace ts {
          * Emits any prologue directives at the start of a Statement list, returning the
          * number of prologue directives written to the output.
          */
-        function emitPrologueDirectives(statements: readonly Node[], sourceFile?: SourceFile, seenPrologueDirectives?: Map<string, true>, recordBundleFileSection?: true): number {
+        function emitPrologueDirectives(statements: readonly Node[], sourceFile?: SourceFile, seenPrologueDirectives?: Set<string>, recordBundleFileSection?: true): number {
             let needsToSetSourceFile = !!sourceFile;
             for (let i = 0; i < statements.length; i++) {
                 const statement = statements[i];
@@ -3734,7 +3734,7 @@ namespace ts {
                         emit(statement);
                         if (recordBundleFileSection && bundleFileInfo) bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: BundleFileSectionKind.Prologue, data: statement.expression.text });
                         if (seenPrologueDirectives) {
-                            seenPrologueDirectives.set(statement.expression.text, true);
+                            seenPrologueDirectives.add(statement.expression.text);
                         }
                     }
                 }
@@ -3747,7 +3747,7 @@ namespace ts {
             return statements.length;
         }
 
-        function emitUnparsedPrologues(prologues: readonly UnparsedPrologue[], seenPrologueDirectives: Map<string, true>) {
+        function emitUnparsedPrologues(prologues: readonly UnparsedPrologue[], seenPrologueDirectives: Set<string>) {
             for (const prologue of prologues) {
                 if (!seenPrologueDirectives.has(prologue.data)) {
                     writeLine();
@@ -3755,7 +3755,7 @@ namespace ts {
                     emit(prologue);
                     if (bundleFileInfo) bundleFileInfo.sections.push({ pos, end: writer.getTextPos(), kind: BundleFileSectionKind.Prologue, data: prologue.data });
                     if (seenPrologueDirectives) {
-                        seenPrologueDirectives.set(prologue.data, true);
+                        seenPrologueDirectives.add(prologue.data);
                     }
                 }
             }
@@ -3766,7 +3766,7 @@ namespace ts {
                 emitPrologueDirectives(sourceFileOrBundle.statements, sourceFileOrBundle);
             }
             else {
-                const seenPrologueDirectives = createMap<true>();
+                const seenPrologueDirectives = new Set<string>();
                 for (const prepend of sourceFileOrBundle.prepends) {
                     emitUnparsedPrologues((prepend as UnparsedSource).prologues, seenPrologueDirectives);
                 }
@@ -3778,7 +3778,7 @@ namespace ts {
         }
 
         function getPrologueDirectivesFromBundledSourceFiles(bundle: Bundle): SourceFilePrologueInfo[] | undefined {
-            const seenPrologueDirectives = createMap<true>();
+            const seenPrologueDirectives = new Set<string>();
             let prologues: SourceFilePrologueInfo[] | undefined;
             for (let index = 0; index < bundle.sourceFiles.length; index++) {
                 const sourceFile = bundle.sourceFiles[index];
@@ -3787,7 +3787,7 @@ namespace ts {
                 for (const statement of sourceFile.statements) {
                     if (!isPrologueDirective(statement)) break;
                     if (seenPrologueDirectives.has(statement.expression.text)) continue;
-                    seenPrologueDirectives.set(statement.expression.text, true);
+                    seenPrologueDirectives.add(statement.expression.text);
                     (directives || (directives = [])).push({
                         pos: statement.pos,
                         end: statement.end,
@@ -4539,9 +4539,9 @@ namespace ts {
 
         function reserveNameInNestedScopes(name: string) {
             if (!reservedNames || reservedNames === lastOrUndefined(reservedNamesStack)) {
-                reservedNames = createMap<true>();
+                reservedNames = new Set();
             }
-            reservedNames.set(name, true);
+            reservedNames.add(name);
         }
 
         function generateNames(node: Node | undefined) {
@@ -4758,7 +4758,7 @@ namespace ts {
                         reserveNameInNestedScopes(baseName);
                     }
                     else {
-                        generatedNames.set(baseName, true);
+                        generatedNames.add(baseName);
                     }
                     return baseName;
                 }
@@ -4775,7 +4775,7 @@ namespace ts {
                         reserveNameInNestedScopes(generatedName);
                     }
                     else {
-                        generatedNames.set(generatedName, true);
+                        generatedNames.add(generatedName);
                     }
                     return generatedName;
                 }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index ecff0dfa88bd1..f8413c564bfb3 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -755,7 +755,7 @@ namespace ts {
 
         let parsingContext: ParsingContext;
 
-        let notParenthesizedArrow: Map<string, true> | undefined;
+        let notParenthesizedArrow: Set<number> | undefined;
 
         // Flags that dictate what parsing context we're in.  For example:
         // Whether or not we are in strict parsing mode.  All that changes in strict parsing mode is
@@ -4135,13 +4135,13 @@ namespace ts {
 
         function parsePossibleParenthesizedArrowFunctionExpression(): ArrowFunction | undefined {
             const tokenPos = scanner.getTokenPos();
-            if (notParenthesizedArrow && notParenthesizedArrow.has(tokenPos.toString())) {
+            if (notParenthesizedArrow?.has(tokenPos)) {
                 return undefined;
             }
 
             const result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false);
             if (!result) {
-                (notParenthesizedArrow || (notParenthesizedArrow = createMap())).set(tokenPos.toString(), true);
+                (notParenthesizedArrow || (notParenthesizedArrow = new Set())).add(tokenPos);
             }
 
             return result;
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 66741c6079e9b..aadfeefb6f140 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -2892,13 +2892,13 @@ namespace ts {
         function checkSourceFilesBelongToPath(sourceFiles: readonly SourceFile[], rootDirectory: string): boolean {
             let allFilesBelongToPath = true;
             const absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-            let rootPaths: Map<string, true> | undefined;
+            let rootPaths: Set<string> | undefined;
 
             for (const sourceFile of sourceFiles) {
                 if (!sourceFile.isDeclarationFile) {
                     const absoluteSourceFilePath = host.getCanonicalFileName(getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory));
                     if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) {
-                        if (!rootPaths) rootPaths = arrayToSet(rootNames, toPath);
+                        if (!rootPaths) rootPaths = new Set(rootNames.map(toPath));
                         addProgramDiagnosticAtRefPath(
                             sourceFile,
                             rootPaths,
@@ -3015,7 +3015,7 @@ namespace ts {
 
             // List of collected files is complete; validate exhautiveness if this is a project with a file list
             if (options.composite) {
-                const rootPaths = arrayToSet(rootNames, toPath);
+                const rootPaths = new Set(rootNames.map(toPath));
                 for (const file of files) {
                     // Ignore file that is not emitted
                     if (sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) {
@@ -3204,7 +3204,7 @@ namespace ts {
             // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files
             if (!options.noEmit && !options.suppressOutputPathCheck) {
                 const emitHost = getEmitHost();
-                const emitFilesSeen = createMap<true>();
+                const emitFilesSeen = new Set<string>();
                 forEachEmittedFile(emitHost, (emitFileNames) => {
                     if (!options.emitDeclarationOnly) {
                         verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen);
@@ -3214,7 +3214,7 @@ namespace ts {
             }
 
             // Verify that all the emit files are unique and don't overwrite input files
-            function verifyEmitFilePath(emitFileName: string | undefined, emitFilesSeen: Map<string, true>) {
+            function verifyEmitFilePath(emitFileName: string | undefined, emitFilesSeen: Set<string>) {
                 if (emitFileName) {
                     const emitFilePath = toPath(emitFileName);
                     // Report error if the output overwrites input file
@@ -3235,7 +3235,7 @@ namespace ts {
                         blockEmittingOfFile(emitFileName, createCompilerDiagnostic(Diagnostics.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files, emitFileName));
                     }
                     else {
-                        emitFilesSeen.set(emitFileKey, true);
+                        emitFilesSeen.add(emitFileKey);
                     }
                 }
             }
@@ -3262,7 +3262,7 @@ namespace ts {
             return createFileDiagnostic(refFile, pos, end - pos, message, ...args);
         }
 
-        function addProgramDiagnosticAtRefPath(file: SourceFile, rootPaths: Map<string, true>, message: DiagnosticMessage, ...args: (string | number | undefined)[]) {
+        function addProgramDiagnosticAtRefPath(file: SourceFile, rootPaths: Set<string>, message: DiagnosticMessage, ...args: (string | number | undefined)[]) {
             const refPaths = refFileMap && refFileMap.get(file.path);
             const refPathToReportErrorOn = forEach(refPaths, refPath => rootPaths.has(refPath.file) ? refPath : undefined) ||
                 elementAt(refPaths, 0);
@@ -3481,7 +3481,7 @@ namespace ts {
     }
 
     function updateHostForUseSourceOfProjectReferenceRedirect(host: HostForUseSourceOfProjectReferenceRedirect) {
-        let mapOfDeclarationDirectories: Map<string, true> | undefined;
+        let setOfDeclarationDirectories: Set<string> | undefined;
         let symlinkedDirectories: Map<string, SymlinkedDirectory | false> | undefined;
         let symlinkedFiles: Map<string, string> | undefined;
 
@@ -3506,19 +3506,19 @@ namespace ts {
 
                 if (!host.getResolvedProjectReferences()) return false;
 
-                if (!mapOfDeclarationDirectories) {
-                    mapOfDeclarationDirectories = createMap();
+                if (!setOfDeclarationDirectories) {
+                    setOfDeclarationDirectories = new Set();
                     host.forEachResolvedProjectReference(ref => {
                         if (!ref) return;
                         const out = outFile(ref.commandLine.options);
                         if (out) {
-                            mapOfDeclarationDirectories!.set(getDirectoryPath(host.toPath(out)), true);
+                            setOfDeclarationDirectories!.add(getDirectoryPath(host.toPath(out)));
                         }
                         else {
                             // Set declaration's in different locations only, if they are next to source the directory present doesnt change
                             const declarationDir = ref.commandLine.options.declarationDir || ref.commandLine.options.outDir;
                             if (declarationDir) {
-                                mapOfDeclarationDirectories!.set(host.toPath(declarationDir), true);
+                                setOfDeclarationDirectories!.add(host.toPath(declarationDir));
                             }
                         }
                     });
@@ -3576,7 +3576,7 @@ namespace ts {
             const dirPath = host.toPath(dir);
             const dirPathWithTrailingDirectorySeparator = `${dirPath}${directorySeparator}`;
             return forEachKey(
-                mapOfDeclarationDirectories!,
+                setOfDeclarationDirectories!,
                 declDirPath => dirPath === declDirPath ||
                     // Any parent directory of declaration dir
                     startsWith(declDirPath, dirPathWithTrailingDirectorySeparator) ||
diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts
index d97cc49c48b69..9f2c023c6872b 100644
--- a/src/compiler/resolutionCache.ts
+++ b/src/compiler/resolutionCache.ts
@@ -143,7 +143,7 @@ namespace ts {
 
     export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootDirForResolution: string | undefined, logChangesWhenResolvingModule: boolean): ResolutionCache {
         let filesWithChangedSetOfUnresolvedImports: Path[] | undefined;
-        let filesWithInvalidatedResolutions: Map<string, true> | undefined;
+        let filesWithInvalidatedResolutions: Set<string> | undefined;
         let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<string, readonly string[]> | undefined;
         const nonRelativeExternalModuleResolutions = createMultiMap<ResolutionWithFailedLookupLocations>();
 
@@ -722,7 +722,7 @@ namespace ts {
                 if (resolution.isInvalidated || !canInvalidate(resolution)) continue;
                 resolution.isInvalidated = invalidated = true;
                 for (const containingFilePath of Debug.assertDefined(resolution.files)) {
-                    (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = createMap<true>())).set(containingFilePath, true);
+                    (filesWithInvalidatedResolutions || (filesWithInvalidatedResolutions = new Set())).add(containingFilePath);
                     // When its a file with inferred types resolution, invalidate type reference directive resolution
                     hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || containingFilePath.endsWith(inferredTypesContainingFile);
                 }
diff --git a/src/compiler/transformers/declarations.ts b/src/compiler/transformers/declarations.ts
index d9a7c8e1f6fc9..8d05347bc6f31 100644
--- a/src/compiler/transformers/declarations.ts
+++ b/src/compiler/transformers/declarations.ts
@@ -58,7 +58,7 @@ namespace ts {
         let needsScopeFixMarker = false;
         let resultHasScopeMarker = false;
         let enclosingDeclaration: Node;
-        let necessaryTypeReferences: Map<string, true> | undefined;
+        let necessaryTypeReferences: Set<string> | undefined;
         let lateMarkedStatements: LateVisibilityPaintedStatement[] | undefined;
         let lateStatementReplacementMap: Map<string, VisitResult<LateVisibilityPaintedStatement | ExportAssignment>>;
         let suppressNewDiagnosticContexts: boolean;
@@ -93,9 +93,9 @@ namespace ts {
             if (!typeReferenceDirectives) {
                 return;
             }
-            necessaryTypeReferences = necessaryTypeReferences || createMap<true>();
+            necessaryTypeReferences = necessaryTypeReferences || new Set();
             for (const ref of typeReferenceDirectives) {
-                necessaryTypeReferences.set(ref, true);
+                necessaryTypeReferences.add(ref);
             }
         }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 20d288efd14d0..b2306437107f0 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -145,7 +145,7 @@ namespace ts {
     }
 
     /** `forEachEntry` for just keys. */
-    export function forEachKey<K, T>(map: ReadonlyMap<K, unknown>, callback: (key: K) => T | undefined): T | undefined {
+    export function forEachKey<K, T>(map: ReadonlyCollection<K>, callback: (key: K) => T | undefined): T | undefined {
         const iterator = map.keys();
         for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
             const result = callback(iterResult.value);
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 85528a9bf3e6c..98460aa42b079 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -1119,7 +1119,7 @@ namespace ts.server {
             }
         }
 
-        private delayUpdateSourceInfoProjects(sourceInfos: Map<string, true> | undefined) {
+        private delayUpdateSourceInfoProjects(sourceInfos: Set<string> | undefined) {
             if (sourceInfos) {
                 sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path as Path));
             }
@@ -2592,11 +2592,11 @@ namespace ts.server {
             return documentPositionMapper;
         }
 
-        private addSourceInfoToSourceMap(sourceFileName: string | undefined, project: Project, sourceInfos?: Map<string, true>) {
+        private addSourceInfoToSourceMap(sourceFileName: string | undefined, project: Project, sourceInfos?: Set<string>) {
             if (sourceFileName) {
                 // Attach as source
                 const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient(sourceFileName, project.currentDirectory, project.directoryStructureHost)!;
-                (sourceInfos || (sourceInfos = createMap())).set(sourceInfo.path, true);
+                (sourceInfos || (sourceInfos = new Set())).add(sourceInfo.path);
             }
             return sourceInfos;
         }
@@ -2638,7 +2638,7 @@ namespace ts.server {
             if (declarationInfo && isString(declarationInfo.sourceMapFilePath) && info !== declarationInfo) {
                 const sourceMapInfo = this.getScriptInfoForPath(declarationInfo.sourceMapFilePath);
                 if (sourceMapInfo) {
-                    (sourceMapInfo.sourceInfos || (sourceMapInfo.sourceInfos = createMap())).set(info.path, true);
+                    (sourceMapInfo.sourceInfos || (sourceMapInfo.sourceInfos = new Set())).add(info.path);
                 }
             }
 
@@ -2926,9 +2926,9 @@ namespace ts.server {
 
             function addOriginalConfiguredProject(originalProject: ConfiguredProject) {
                 if (!project.originalConfiguredProjects) {
-                    project.originalConfiguredProjects = createMap<true>();
+                    project.originalConfiguredProjects = new Set();
                 }
-                project.originalConfiguredProjects.set(originalProject.canonicalConfigFilePath, true);
+                project.originalConfiguredProjects.add(originalProject.canonicalConfigFilePath);
             }
         }
 
@@ -3075,13 +3075,13 @@ namespace ts.server {
         }
 
         /*@internal*/
-        loadAncestorProjectTree(forProjects?: ReadonlyMap<string, true>) {
+        loadAncestorProjectTree(forProjects?: ReadonlyCollection<string>) {
             forProjects = forProjects || mapDefinedEntries(
                 this.configuredProjects,
                 (key, project) => !project.isInitialLoadPending() ? [key, true] : undefined
             );
 
-            const seenProjects = createMap<true>();
+            const seenProjects = new Set<string>();
             // Work on array copy as we could add more projects as part of callback
             for (const project of arrayFrom(this.configuredProjects.values())) {
                 // If this project has potential project reference for any of the project we are loading ancestor tree for
@@ -3099,8 +3099,8 @@ namespace ts.server {
             }
         }
 
-        private ensureProjectChildren(project: ConfiguredProject, seenProjects: Map<string, true>) {
-            if (!addToSeen(seenProjects, project.canonicalConfigFilePath)) return;
+        private ensureProjectChildren(project: ConfiguredProject, seenProjects: Set<string>) {
+            if (!tryAddToSet(seenProjects, project.canonicalConfigFilePath)) return;
             // Update the project
             updateProjectIfDirty(project);
 
@@ -3204,7 +3204,7 @@ namespace ts.server {
                 if (!info.isScriptOpen() && info.isOrphan()) {
                     // Otherwise if there is any source info that is alive, this alive too
                     if (!info.sourceMapFilePath) return;
-                    let sourceInfos: Map<string, true> | undefined;
+                    let sourceInfos: Set<string> | undefined;
                     if (isString(info.sourceMapFilePath)) {
                         const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
                         sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
@@ -3224,7 +3224,7 @@ namespace ts.server {
                 // Retain this script info
                 toRemoveScriptInfos.delete(info.path);
                 if (info.sourceMapFilePath) {
-                    let sourceInfos: Map<string, true> | undefined;
+                    let sourceInfos: Set<string> | undefined;
                     if (isString(info.sourceMapFilePath)) {
                         // And map file info and source infos
                         toRemoveScriptInfos.delete(info.sourceMapFilePath);
diff --git a/src/server/project.ts b/src/server/project.ts
index 82821be6de9ec..9efa434e7baf1 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -169,7 +169,7 @@ namespace ts.server {
         /**
          * Set of files names that were updated since the last call to getChangesSinceVersion.
          */
-        private updatedFileNames: Map<string, true> | undefined;
+        private updatedFileNames: Set<string> | undefined;
         /**
          * Set of files that was returned from the last call to getChangesSinceVersion.
          */
@@ -200,7 +200,7 @@ namespace ts.server {
         typingFiles: SortedReadonlyArray<string> = emptyArray;
 
         /*@internal*/
-        originalConfiguredProjects: Map<string, true> | undefined;
+        originalConfiguredProjects: Set<string> | undefined;
 
         /*@internal*/
         getResolvedProjectReferenceToRedirect(_fileName: string): ResolvedProjectReference | undefined {
@@ -246,7 +246,7 @@ namespace ts.server {
         /*@internal*/
         private importSuggestionsCache = Completions.createImportSuggestionsForFileCache();
         /*@internal*/
-        private dirtyFilesForSuggestions: Map<string, true> | undefined;
+        private dirtyFilesForSuggestions: Set<string> | undefined;
         /*@internal*/
         private symlinks: ReadonlyMap<string, string> | undefined;
 
@@ -928,14 +928,14 @@ namespace ts.server {
         }
 
         registerFileUpdate(fileName: string) {
-            (this.updatedFileNames || (this.updatedFileNames = createMap<true>())).set(fileName, true);
+            (this.updatedFileNames || (this.updatedFileNames = new Set<string>())).add(fileName);
         }
 
         /*@internal*/
         markFileAsDirty(changedFile: Path) {
             this.markAsDirty();
             if (!this.importSuggestionsCache.isEmpty()) {
-                (this.dirtyFilesForSuggestions || (this.dirtyFilesForSuggestions = createMap())).set(changedFile, true);
+                (this.dirtyFilesForSuggestions || (this.dirtyFilesForSuggestions = new Set())).add(changedFile);
             }
         }
 
@@ -1814,7 +1814,7 @@ namespace ts.server {
 
         /** Potential project references before the project is actually loaded (read config file) */
         /*@internal*/
-        potentialProjectReferences: Map<string, true> | undefined;
+        potentialProjectReferences: Set<string> | undefined;
 
         /*@internal*/
         projectOptions?: ProjectOptions | true;
@@ -1940,7 +1940,7 @@ namespace ts.server {
         /*@internal*/
         setPotentialProjectReference(canonicalConfigPath: NormalizedPath) {
             Debug.assert(this.isInitialLoadPending());
-            (this.potentialProjectReferences || (this.potentialProjectReferences = createMap())).set(canonicalConfigPath, true);
+            (this.potentialProjectReferences || (this.potentialProjectReferences = new Set())).add(canonicalConfigPath);
         }
 
         /*@internal*/
diff --git a/src/server/scriptInfo.ts b/src/server/scriptInfo.ts
index a6846a8a9c286..0b0c5f409b816 100644
--- a/src/server/scriptInfo.ts
+++ b/src/server/scriptInfo.ts
@@ -286,7 +286,7 @@ namespace ts.server {
     /*@internal*/
     export interface SourceMapFileWatcher {
         watcher: FileWatcher;
-        sourceInfos?: Map<string, true>;
+        sourceInfos?: Set<string>;
     }
 
     export class ScriptInfo {
@@ -324,7 +324,7 @@ namespace ts.server {
         /*@internal*/
         declarationInfoPath?: Path;
         /*@internal*/
-        sourceInfos?: Map<string, true>;
+        sourceInfos?: Set<string>;
         /*@internal*/
         documentPositionMapper?: DocumentPositionMapper | false;
 
diff --git a/src/server/session.ts b/src/server/session.ts
index 4c37851350c6e..d92ea4c9c9f4e 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -423,7 +423,7 @@ namespace ts.server {
     ): void {
         const projectService = defaultProject.projectService;
         let toDo: ProjectAndLocation<TLocation>[] | undefined;
-        const seenProjects = createMap<true>();
+        const seenProjects = new Set<string>();
         forEachProjectInProjects(projects, initialLocation && initialLocation.fileName, (project, path) => {
             // TLocation should be either `DocumentPosition` or `undefined`. Since `initialLocation` is `TLocation` this cast should be valid.
             const location = (initialLocation ? { fileName: path, pos: initialLocation.pos } : undefined) as TLocation;
@@ -496,7 +496,7 @@ namespace ts.server {
         location: TLocation,
         projectService: ProjectService,
         toDo: ProjectAndLocation<TLocation>[] | undefined,
-        seenProjects: Map<string, true>,
+        seenProjects: Set<string>,
         cb: CombineProjectOutputCallback<TLocation>,
     ): ProjectAndLocation<TLocation>[] | undefined {
         if (project.getCancellationToken().isCancellationRequested()) return undefined; // Skip rest of toDo if cancelled
@@ -526,12 +526,12 @@ namespace ts.server {
         return toDo;
     }
 
-    function addToTodo<TLocation extends DocumentPosition | undefined>(project: Project, location: TLocation, toDo: Push<ProjectAndLocation<TLocation>>, seenProjects: Map<string, true>): void {
+    function addToTodo<TLocation extends DocumentPosition | undefined>(project: Project, location: TLocation, toDo: Push<ProjectAndLocation<TLocation>>, seenProjects: Set<string>): void {
         if (addToSeen(seenProjects, project)) toDo.push({ project, location });
     }
 
-    function addToSeen(seenProjects: Map<string, true>, project: Project) {
-        return ts.addToSeen(seenProjects, getProjectKey(project));
+    function addToSeen(seenProjects: Set<string>, project: Project) {
+        return tryAddToSet(seenProjects, getProjectKey(project));
     }
 
     function getProjectKey(project: Project) {
diff --git a/src/services/codefixes/addMissingAsync.ts b/src/services/codefixes/addMissingAsync.ts
index 484ac29835c6c..5876805ee1c02 100644
--- a/src/services/codefixes/addMissingAsync.ts
+++ b/src/services/codefixes/addMissingAsync.ts
@@ -26,7 +26,7 @@ namespace ts.codefix {
         },
         getAllCodeActions: context => {
             const { sourceFile } = context;
-            const fixedDeclarations = createMap<true>();
+            const fixedDeclarations = new Set<number>();
             return codeFixAll(context, errorCodes, (t, diagnostic) => {
                 const span = diagnostic.relatedInformation && find(diagnostic.relatedInformation, r => r.code === Diagnostics.Did_you_mean_to_mark_this_function_as_async.code) as TextSpan | undefined;
                 const decl = getFixableErrorSpanDeclaration(sourceFile, span);
@@ -40,18 +40,18 @@ namespace ts.codefix {
     });
 
     type FixableDeclaration = ArrowFunction | FunctionDeclaration | FunctionExpression | MethodDeclaration;
-    function getFix(context: CodeFixContext | CodeFixAllContext, decl: FixableDeclaration, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<string, true>) {
+    function getFix(context: CodeFixContext | CodeFixAllContext, decl: FixableDeclaration, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Set<number>) {
         const changes = trackChanges(t => makeChange(t, context.sourceFile, decl, fixedDeclarations));
         return createCodeFixAction(fixId, changes, Diagnostics.Add_async_modifier_to_containing_function, fixId, Diagnostics.Add_all_missing_async_modifiers);
     }
 
-    function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, insertionSite: FixableDeclaration, fixedDeclarations?: Map<string, true>) {
+    function makeChange(changeTracker: textChanges.ChangeTracker, sourceFile: SourceFile, insertionSite: FixableDeclaration, fixedDeclarations?: Set<number>) {
         if (fixedDeclarations) {
-            if (fixedDeclarations.has(getNodeId(insertionSite).toString())) {
+            if (fixedDeclarations.has(getNodeId(insertionSite))) {
                 return;
             }
         }
-        fixedDeclarations?.set(getNodeId(insertionSite).toString(), true);
+        fixedDeclarations?.add(getNodeId(insertionSite));
         const cloneWithModifier = factory.updateModifiers(
             getSynthesizedDeepClone(insertionSite, /*includeTrivia*/ true),
             factory.createNodeArray(factory.createModifiersFromModifierFlags(getSyntacticModifierFlags(insertionSite) | ModifierFlags.Async)));
diff --git a/src/services/codefixes/addMissingAwait.ts b/src/services/codefixes/addMissingAwait.ts
index 69152a0881970..1b16a33deb382 100644
--- a/src/services/codefixes/addMissingAwait.ts
+++ b/src/services/codefixes/addMissingAwait.ts
@@ -45,7 +45,7 @@ namespace ts.codefix {
         getAllCodeActions: context => {
             const { sourceFile, program, cancellationToken } = context;
             const checker = context.program.getTypeChecker();
-            const fixedDeclarations = createMap<true>();
+            const fixedDeclarations = new Set<number>();
             return codeFixAll(context, errorCodes, (t, diagnostic) => {
                 const expression = getFixableErrorSpanExpression(sourceFile, diagnostic.code, diagnostic, cancellationToken, program);
                 if (!expression) {
@@ -58,7 +58,7 @@ namespace ts.codefix {
         },
     });
 
-    function getDeclarationSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<string, true>) {
+    function getDeclarationSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Set<number>) {
         const { sourceFile, program, cancellationToken } = context;
         const awaitableInitializers = findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker);
         if (awaitableInitializers) {
@@ -79,7 +79,7 @@ namespace ts.codefix {
         }
     }
 
-    function getUseSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Map<string, true>) {
+    function getUseSiteFix(context: CodeFixContext | CodeFixAllContext, expression: Expression, errorCode: number, checker: TypeChecker, trackChanges: ContextualTrackChangesFunction, fixedDeclarations?: Set<number>) {
         const changes = trackChanges(t => makeChange(t, errorCode, context.sourceFile, checker, expression, fixedDeclarations));
         return createCodeFixAction(fixId, changes, Diagnostics.Add_await, fixId, Diagnostics.Fix_all_expressions_possibly_missing_await);
     }
@@ -234,12 +234,12 @@ namespace ts.codefix {
                 ancestor.parent.kind === SyntaxKind.MethodDeclaration));
     }
 
-    function makeChange(changeTracker: textChanges.ChangeTracker, errorCode: number, sourceFile: SourceFile, checker: TypeChecker, insertionSite: Expression, fixedDeclarations?: Map<string, true>) {
+    function makeChange(changeTracker: textChanges.ChangeTracker, errorCode: number, sourceFile: SourceFile, checker: TypeChecker, insertionSite: Expression, fixedDeclarations?: Set<number>) {
         if (isBinaryExpression(insertionSite)) {
             for (const side of [insertionSite.left, insertionSite.right]) {
                 if (fixedDeclarations && isIdentifier(side)) {
                     const symbol = checker.getSymbolAtLocation(side);
-                    if (symbol && fixedDeclarations.has(getSymbolId(symbol).toString())) {
+                    if (symbol && fixedDeclarations.has(getSymbolId(symbol))) {
                         continue;
                     }
                 }
@@ -251,7 +251,7 @@ namespace ts.codefix {
         else if (errorCode === propertyAccessCode && isPropertyAccessExpression(insertionSite.parent)) {
             if (fixedDeclarations && isIdentifier(insertionSite.parent.expression)) {
                 const symbol = checker.getSymbolAtLocation(insertionSite.parent.expression);
-                if (symbol && fixedDeclarations.has(getSymbolId(symbol).toString())) {
+                if (symbol && fixedDeclarations.has(getSymbolId(symbol))) {
                     return;
                 }
             }
@@ -264,7 +264,7 @@ namespace ts.codefix {
         else if (contains(callableConstructableErrorCodes, errorCode) && isCallOrNewExpression(insertionSite.parent)) {
             if (fixedDeclarations && isIdentifier(insertionSite)) {
                 const symbol = checker.getSymbolAtLocation(insertionSite);
-                if (symbol && fixedDeclarations.has(getSymbolId(symbol).toString())) {
+                if (symbol && fixedDeclarations.has(getSymbolId(symbol))) {
                     return;
                 }
             }
@@ -274,7 +274,7 @@ namespace ts.codefix {
         else {
             if (fixedDeclarations && isVariableDeclaration(insertionSite.parent) && isIdentifier(insertionSite.parent.name)) {
                 const symbol = checker.getSymbolAtLocation(insertionSite.parent.name);
-                if (symbol && !addToSeen(fixedDeclarations, getSymbolId(symbol))) {
+                if (symbol && !tryAddToSet(fixedDeclarations, getSymbolId(symbol))) {
                     return;
                 }
             }
diff --git a/src/services/codefixes/convertToAsyncFunction.ts b/src/services/codefixes/convertToAsyncFunction.ts
index 604bd098ca2a2..03a7f167cff91 100644
--- a/src/services/codefixes/convertToAsyncFunction.ts
+++ b/src/services/codefixes/convertToAsyncFunction.ts
@@ -39,7 +39,7 @@ namespace ts.codefix {
     interface Transformer {
         readonly checker: TypeChecker;
         readonly synthNamesMap: Map<string, SynthIdentifier>; // keys are the symbol id of the identifier
-        readonly setOfExpressionsToReturn: ReadonlyMap<string, true>; // keys are the node ids of the expressions
+        readonly setOfExpressionsToReturn: ReadonlySet<number>; // keys are the node ids of the expressions
         readonly isInJSFile: boolean;
     }
 
@@ -99,24 +99,24 @@ namespace ts.codefix {
     /*
         Finds all of the expressions of promise type that should not be saved in a variable during the refactor
     */
-    function getAllPromiseExpressionsToReturn(func: FunctionLikeDeclaration, checker: TypeChecker): Map<string, true> {
+    function getAllPromiseExpressionsToReturn(func: FunctionLikeDeclaration, checker: TypeChecker): Set<number> {
         if (!func.body) {
-            return createMap<true>();
+            return new Set();
         }
 
-        const setOfExpressionsToReturn: Map<string, true> = createMap<true>();
+        const setOfExpressionsToReturn = new Set<number>();
         forEachChild(func.body, function visit(node: Node) {
             if (isPromiseReturningCallExpression(node, checker, "then")) {
-                setOfExpressionsToReturn.set(getNodeId(node).toString(), true);
+                setOfExpressionsToReturn.add(getNodeId(node));
                 forEach(node.arguments, visit);
             }
             else if (isPromiseReturningCallExpression(node, checker, "catch")) {
-                setOfExpressionsToReturn.set(getNodeId(node).toString(), true);
+                setOfExpressionsToReturn.add(getNodeId(node));
                 // if .catch() is the last call in the chain, move leftward in the chain until we hit something else that should be returned
                 forEachChild(node, visit);
             }
             else if (isPromiseTypedExpression(node, checker)) {
-                setOfExpressionsToReturn.set(getNodeId(node).toString(), true);
+                setOfExpressionsToReturn.add(getNodeId(node));
                 // don't recurse here, since we won't refactor any children or arguments of the expression
             }
             else {
@@ -593,6 +593,6 @@ namespace ts.codefix {
     }
 
     function shouldReturn(expression: Expression, transformer: Transformer): boolean {
-        return !!expression.original && transformer.setOfExpressionsToReturn.has(getNodeId(expression.original).toString());
+        return !!expression.original && transformer.setOfExpressionsToReturn.has(getNodeId(expression.original));
     }
 }
diff --git a/src/services/codefixes/convertToEs6Module.ts b/src/services/codefixes/convertToEs6Module.ts
index cd23f55e47537..77f18a8b5cefa 100644
--- a/src/services/codefixes/convertToEs6Module.ts
+++ b/src/services/codefixes/convertToEs6Module.ts
@@ -40,7 +40,7 @@ namespace ts.codefix {
 
     /** @returns Whether we converted a `module.exports =` to a default export. */
     function convertFileToEs6Module(sourceFile: SourceFile, checker: TypeChecker, changes: textChanges.ChangeTracker, target: ScriptTarget, quotePreference: QuotePreference): ModuleExportsChanged {
-        const identifiers: Identifiers = { original: collectFreeIdentifiers(sourceFile), additional: createMap<true>() };
+        const identifiers: Identifiers = { original: collectFreeIdentifiers(sourceFile), additional: new Set() };
         const exports = collectExportRenames(sourceFile, checker, identifiers);
         convertExportsAccesses(sourceFile, exports, changes);
         let moduleExportsChangedToDefault = false;
@@ -429,7 +429,7 @@ namespace ts.codefix {
         while (identifiers.original.has(name) || identifiers.additional.has(name)) {
             name = `_${name}`;
         }
-        identifiers.additional.set(name, true);
+        identifiers.additional.add(name);
         return name;
     }
 
@@ -441,7 +441,7 @@ namespace ts.codefix {
     interface Identifiers {
         readonly original: FreeIdentifiers;
         // Additional identifiers we've added. Mutable!
-        readonly additional: Map<string, true>;
+        readonly additional: Set<string>;
     }
 
     type FreeIdentifiers = ReadonlyMap<string, readonly Identifier[]>;
diff --git a/src/services/codefixes/disableJsDiagnostics.ts b/src/services/codefixes/disableJsDiagnostics.ts
index 8a7e6c516cbc2..4469ffb6b716f 100644
--- a/src/services/codefixes/disableJsDiagnostics.ts
+++ b/src/services/codefixes/disableJsDiagnostics.ts
@@ -37,7 +37,7 @@ namespace ts.codefix {
         },
         fixIds: [fixId],
         getAllCodeActions: context => {
-            const seenLines = createMap<true>();
+            const seenLines = new Set<number>();
             return codeFixAll(context, errorCodes, (changes, diag) => {
                 if (textChanges.isValidLocationToAddComment(diag.file, diag.start)) {
                     makeChange(changes, diag.file, diag.start, seenLines);
@@ -46,10 +46,10 @@ namespace ts.codefix {
         },
     });
 
-    function makeChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, position: number, seenLines?: Map<string, true>) {
+    function makeChange(changes: textChanges.ChangeTracker, sourceFile: SourceFile, position: number, seenLines?: Set<number>) {
         const { line: lineNumber } = getLineAndCharacterOfPosition(sourceFile, position);
         // Only need to add `// @ts-ignore` for a line once.
-        if (!seenLines || addToSeen(seenLines, lineNumber)) {
+        if (!seenLines || tryAddToSet(seenLines, lineNumber)) {
             changes.insertCommentBeforeLine(sourceFile, lineNumber, position, " @ts-ignore");
         }
     }
diff --git a/src/services/completions.ts b/src/services/completions.ts
index c3e844317f2d9..cadc8f8daee65 100644
--- a/src/services/completions.ts
+++ b/src/services/completions.ts
@@ -2307,7 +2307,7 @@ namespace ts.Completions {
                 return contextualMemberSymbols;
             }
 
-            const membersDeclaredBySpreadAssignment = createMap<true>();
+            const membersDeclaredBySpreadAssignment = new Set<string>();
             const existingMemberNames = createUnderscoreEscapedMap<boolean>();
             for (const m of existingMembers) {
                 // Ignore omitted expressions for missing members
@@ -2354,14 +2354,14 @@ namespace ts.Completions {
             return filteredSymbols;
         }
 
-        function setMembersDeclaredBySpreadAssignment(declaration: SpreadAssignment | JsxSpreadAttribute, membersDeclaredBySpreadAssignment: Map<string, true>) {
+        function setMembersDeclaredBySpreadAssignment(declaration: SpreadAssignment | JsxSpreadAttribute, membersDeclaredBySpreadAssignment: Set<string>) {
             const expression = declaration.expression;
             const symbol = typeChecker.getSymbolAtLocation(expression);
             const type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression);
             const properties = type && (<ObjectType>type).properties;
             if (properties) {
                 properties.forEach(property => {
-                    membersDeclaredBySpreadAssignment.set(property.name, true);
+                    membersDeclaredBySpreadAssignment.add(property.name);
                 });
             }
         }
@@ -2376,7 +2376,7 @@ namespace ts.Completions {
         }
 
         // Set SortText to MemberDeclaredBySpreadAssignment if it is fulfilled by spread assignment
-        function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment: Map<string, true>, contextualMemberSymbols: Symbol[]): void {
+        function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment: Set<string>, contextualMemberSymbols: Symbol[]): void {
             if (membersDeclaredBySpreadAssignment.size === 0) {
                 return;
             }
@@ -2439,7 +2439,7 @@ namespace ts.Completions {
          */
         function filterJsxAttributes(symbols: Symbol[], attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>): Symbol[] {
             const seenNames = createUnderscoreEscapedMap<boolean>();
-            const membersDeclaredBySpreadAssignment = createMap<true>();
+            const membersDeclaredBySpreadAssignment = new Set<string>();
             for (const attr of attributes) {
                 // If this is the current item we are editing right now, do not filter it out
                 if (isCurrentlyEditingNode(attr)) {
diff --git a/src/services/documentHighlights.ts b/src/services/documentHighlights.ts
index 378739144110d..6ed27e2beeed8 100644
--- a/src/services/documentHighlights.ts
+++ b/src/services/documentHighlights.ts
@@ -28,7 +28,7 @@ namespace ts {
         }
 
         function getSemanticDocumentHighlights(position: number, node: Node, program: Program, cancellationToken: CancellationToken, sourceFilesToSearch: readonly SourceFile[]): DocumentHighlights[] | undefined {
-            const sourceFilesSet = arrayToSet(sourceFilesToSearch, f => f.fileName);
+            const sourceFilesSet = new Set(sourceFilesToSearch.map(f => f.fileName));
             const referenceEntries = FindAllReferences.getReferenceEntriesForNode(position, node, program, sourceFilesToSearch, cancellationToken, /*options*/ undefined, sourceFilesSet);
             if (!referenceEntries) return undefined;
             const map = arrayToMultiMap(referenceEntries.map(FindAllReferences.toHighlightSpan), e => e.fileName, e => e.span);
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
index 940e59acbfa6b..b1e98f240bd69 100644
--- a/src/services/findAllReferences.ts
+++ b/src/services/findAllReferences.ts
@@ -287,7 +287,7 @@ namespace ts.FindAllReferences {
         sourceFiles: readonly SourceFile[],
         cancellationToken: CancellationToken,
         options: Options = {},
-        sourceFilesSet: ReadonlyMap<string, true> = arrayToSet(sourceFiles, f => f.fileName),
+        sourceFilesSet: ReadonlySet<string> = new Set(sourceFiles.map(f => f.fileName)),
     ): readonly Entry[] | undefined {
         return flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet));
     }
@@ -594,7 +594,7 @@ namespace ts.FindAllReferences {
     /** Encapsulates the core find-all-references algorithm. */
     export namespace Core {
         /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */
-        export function getReferencedSymbolsForNode(position: number, node: Node, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options = {}, sourceFilesSet: ReadonlyMap<string, true> = arrayToSet(sourceFiles, f => f.fileName)): readonly SymbolAndEntries[] | undefined {
+        export function getReferencedSymbolsForNode(position: number, node: Node, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options = {}, sourceFilesSet: ReadonlySet<string> = new Set(sourceFiles.map(f => f.fileName))): readonly SymbolAndEntries[] | undefined {
             if (options.use === FindReferencesUse.References) {
                 node = getAdjustedReferenceLocation(node);
             }
@@ -651,7 +651,7 @@ namespace ts.FindAllReferences {
             return undefined;
         }
 
-        function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol: Symbol, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options, sourceFilesSet: ReadonlyMap<string, true>) {
+        function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol: Symbol, program: Program, sourceFiles: readonly SourceFile[], cancellationToken: CancellationToken, options: Options, sourceFilesSet: ReadonlySet<string>) {
             const moduleSourceFile = (symbol.flags & SymbolFlags.Module) && symbol.declarations && find(symbol.declarations, isSourceFile);
             if (!moduleSourceFile) return undefined;
             const exportEquals = symbol.exports!.get(InternalSymbolName.ExportEquals);
@@ -718,7 +718,7 @@ namespace ts.FindAllReferences {
             return program.getSourceFiles().indexOf(sourceFile);
         }
 
-        function getReferencedSymbolsForModule(program: Program, symbol: Symbol, excludeImportTypeOfExportEquals: boolean, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<string, true>): SymbolAndEntries[] {
+        function getReferencedSymbolsForModule(program: Program, symbol: Symbol, excludeImportTypeOfExportEquals: boolean, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlySet<string>): SymbolAndEntries[] {
             Debug.assert(!!symbol.valueDeclaration);
 
             const references = mapDefined<ModuleReference, Entry>(findModuleReferences(program, sourceFiles, symbol), reference => {
@@ -830,7 +830,7 @@ namespace ts.FindAllReferences {
         }
 
         /** Core find-all-references algorithm for a normal symbol. */
-        function getReferencedSymbolsForSymbol(originalSymbol: Symbol, node: Node | undefined, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<string, true>, checker: TypeChecker, cancellationToken: CancellationToken, options: Options): SymbolAndEntries[] {
+        function getReferencedSymbolsForSymbol(originalSymbol: Symbol, node: Node | undefined, sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlySet<string>, checker: TypeChecker, cancellationToken: CancellationToken, options: Options): SymbolAndEntries[] {
             const symbol = node && skipPastExportOrImportSpecifierOrUnion(originalSymbol, node, checker, /*useLocalSymbolForExportSpecifier*/ !isForRenameWithPrefixAndSuffixText(options)) || originalSymbol;
 
             // Compute the meaning from the location and the symbol it references
@@ -972,7 +972,7 @@ namespace ts.FindAllReferences {
 
             constructor(
                 readonly sourceFiles: readonly SourceFile[],
-                readonly sourceFilesSet: ReadonlyMap<string, true>,
+                readonly sourceFilesSet: ReadonlySet<string>,
                 readonly specialSearchKind: SpecialSearchKind,
                 readonly checker: TypeChecker,
                 readonly cancellationToken: CancellationToken,
@@ -1031,15 +1031,15 @@ namespace ts.FindAllReferences {
             }
 
             // Source file ID → symbol ID → Whether the symbol has been searched for in the source file.
-            private readonly sourceFileToSeenSymbols: Map<string, true>[] = [];
+            private readonly sourceFileToSeenSymbols: Set<number>[] = [];
             /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */
             markSearchedSymbols(sourceFile: SourceFile, symbols: readonly Symbol[]): boolean {
                 const sourceId = getNodeId(sourceFile);
-                const seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = createMap<true>());
+                const seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = new Set<number>());
 
                 let anyNewSymbols = false;
                 for (const sym of symbols) {
-                    anyNewSymbols = addToSeen(seenSymbols, getSymbolId(sym)) || anyNewSymbols;
+                    anyNewSymbols = tryAddToSet(seenSymbols, getSymbolId(sym)) || anyNewSymbols;
                 }
                 return anyNewSymbols;
             }
@@ -1093,7 +1093,7 @@ namespace ts.FindAllReferences {
             isDefaultExport: boolean,
             cb: (ref: Identifier) => void,
         ): void {
-            const importTracker = createImportTracker(sourceFiles, arrayToSet(sourceFiles, f => f.fileName), checker, cancellationToken);
+            const importTracker = createImportTracker(sourceFiles, new Set(sourceFiles.map(f => f.fileName)), checker, cancellationToken);
             const { importSearches, indirectUsers } = importTracker(exportSymbol, { exportKind: isDefaultExport ? ExportKind.Default : ExportKind.Named, exportingModuleSymbol }, /*isForRename*/ false);
             for (const [importLocation] of importSearches) {
                 cb(importLocation);
diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts
index 54cfc352781a8..b783532b85976 100644
--- a/src/services/importTracker.ts
+++ b/src/services/importTracker.ts
@@ -12,7 +12,7 @@ namespace ts.FindAllReferences {
     export type ImportTracker = (exportSymbol: Symbol, exportInfo: ExportInfo, isForRename: boolean) => ImportsResult;
 
     /** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily.  */
-    export function createImportTracker(sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlyMap<string, true>, checker: TypeChecker, cancellationToken: CancellationToken | undefined): ImportTracker {
+    export function createImportTracker(sourceFiles: readonly SourceFile[], sourceFilesSet: ReadonlySet<string>, checker: TypeChecker, cancellationToken: CancellationToken | undefined): ImportTracker {
         const allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken);
         return (exportSymbol, exportInfo, isForRename) => {
             const { directImports, indirectUsers } = getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, exportInfo, checker, cancellationToken);
@@ -39,7 +39,7 @@ namespace ts.FindAllReferences {
     /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */
     function getImportersForExport(
         sourceFiles: readonly SourceFile[],
-        sourceFilesSet: ReadonlyMap<string, true>,
+        sourceFilesSet: ReadonlySet<string>,
         allDirectImports: Map<string, ImporterOrCallExpression[]>,
         { exportingModuleSymbol, exportKind }: ExportInfo,
         checker: TypeChecker,
diff --git a/src/testRunner/unittests/tsbuild/helpers.ts b/src/testRunner/unittests/tsbuild/helpers.ts
index 95b22ff8900ed..e2efa72efcd7b 100644
--- a/src/testRunner/unittests/tsbuild/helpers.ts
+++ b/src/testRunner/unittests/tsbuild/helpers.ts
@@ -186,7 +186,7 @@ interface Symbol {
         }
     }
 
-    export function generateSourceMapBaselineFiles(sys: System & { writtenFiles: Map<string, any>; }) {
+    export function generateSourceMapBaselineFiles(sys: System & { writtenFiles: ReadonlyCollection<string>; }) {
         const mapFileNames = mapDefinedIterator(sys.writtenFiles.keys(), f => f.endsWith(".map") ? f : undefined);
         while (true) {
             const { value: mapFile, done } = mapFileNames.next();
@@ -237,7 +237,7 @@ interface Symbol {
 
     export function baselineBuildInfo(
         options: CompilerOptions,
-        sys: System & { writtenFiles: Map<string, any>; },
+        sys: System & { writtenFiles: ReadonlyCollection<string>; },
         originalReadCall?: System["readFile"]
     ) {
         const out = outFile(options);
diff --git a/src/testRunner/unittests/tsc/helpers.ts b/src/testRunner/unittests/tsc/helpers.ts
index 88c33ca0eb648..d2698e0b42b1e 100644
--- a/src/testRunner/unittests/tsc/helpers.ts
+++ b/src/testRunner/unittests/tsc/helpers.ts
@@ -1,6 +1,6 @@
 namespace ts {
     export type TscCompileSystem = fakes.System & {
-        writtenFiles: Map<string, true>;
+        writtenFiles: Set<string>;
         baseLine(): { file: string; text: string; };
     };
 
@@ -44,7 +44,7 @@ namespace ts {
         return !!(program as Program | EmitAndSemanticDiagnosticsBuilderProgram).getCompilerOptions;
     }
     export function commandLineCallbacks(
-        sys: System & { writtenFiles: Map<string, any>; },
+        sys: System & { writtenFiles: ReadonlyCollection<string>; },
         originalReadCall?: System["readFile"]
     ): CommandLineCallbacks {
         let programs: CommandLineProgram[] | undefined;
@@ -85,11 +85,11 @@ namespace ts {
         // Create system
         const sys = new fakes.System(fs, { executingFilePath: "/lib/tsc" }) as TscCompileSystem;
         fakes.patchHostForBuildInfoReadWrite(sys);
-        const writtenFiles = sys.writtenFiles = createMap<true>();
+        const writtenFiles = sys.writtenFiles = new Set<string>();
         const originalWriteFile = sys.writeFile;
         sys.writeFile = (fileName, content, writeByteOrderMark) => {
             assert.isFalse(writtenFiles.has(fileName));
-            writtenFiles.set(fileName, true);
+            writtenFiles.add(fileName);
             return originalWriteFile.call(sys, fileName, content, writeByteOrderMark);
         };
         const actualReadFileMap: MapLike<number> = {};
diff --git a/src/typingsInstallerCore/typingsInstaller.ts b/src/typingsInstallerCore/typingsInstaller.ts
index 821c001f62451..75aa4b58cad94 100644
--- a/src/typingsInstallerCore/typingsInstaller.ts
+++ b/src/typingsInstallerCore/typingsInstaller.ts
@@ -88,8 +88,8 @@ namespace ts.server.typingsInstaller {
 
     export abstract class TypingsInstaller {
         private readonly packageNameToTypingLocation: Map<string, JsTyping.CachedTyping> = createMap<JsTyping.CachedTyping>();
-        private readonly missingTypingsSet: Map<string, true> = createMap<true>();
-        private readonly knownCachesSet: Map<string, true> = createMap<true>();
+        private readonly missingTypingsSet = new Set<string>();
+        private readonly knownCachesSet = new Set<string>();
         private readonly projectWatchers = createMap<ProjectWatchers>();
         private safeList: JsTyping.SafeList | undefined;
         readonly pendingRunRequests: PendingRequest[] = [];
@@ -234,7 +234,7 @@ namespace ts.server.typingsInstaller {
                         }
                         const typingFile = typingToFileName(cacheLocation, packageName, this.installTypingHost, this.log);
                         if (!typingFile) {
-                            this.missingTypingsSet.set(packageName, true);
+                            this.missingTypingsSet.add(packageName);
                             continue;
                         }
                         const existingTypingFile = this.packageNameToTypingLocation.get(packageName);
@@ -264,20 +264,20 @@ namespace ts.server.typingsInstaller {
             if (this.log.isEnabled()) {
                 this.log.writeLine(`Finished processing cache location '${cacheLocation}'`);
             }
-            this.knownCachesSet.set(cacheLocation, true);
+            this.knownCachesSet.add(cacheLocation);
         }
 
         private filterTypings(typingsToInstall: readonly string[]): readonly string[] {
             return mapDefined(typingsToInstall, typing => {
                 const typingKey = mangleScopedPackageName(typing);
-                if (this.missingTypingsSet.get(typingKey)) {
+                if (this.missingTypingsSet.has(typingKey)) {
                     if (this.log.isEnabled()) this.log.writeLine(`'${typing}':: '${typingKey}' is in missingTypingsSet - skipping...`);
                     return undefined;
                 }
                 const validationResult = JsTyping.validatePackageName(typing);
                 if (validationResult !== JsTyping.NameValidationResult.Ok) {
                     // add typing name to missing set so we won't process it again
-                    this.missingTypingsSet.set(typingKey, true);
+                    this.missingTypingsSet.add(typingKey);
                     if (this.log.isEnabled()) this.log.writeLine(JsTyping.renderPackageNameValidationFailure(validationResult, typing));
                     return undefined;
                 }
@@ -343,7 +343,7 @@ namespace ts.server.typingsInstaller {
                             this.log.writeLine(`install request failed, marking packages as missing to prevent repeated requests: ${JSON.stringify(filteredTypings)}`);
                         }
                         for (const typing of filteredTypings) {
-                            this.missingTypingsSet.set(typing, true);
+                            this.missingTypingsSet.add(typing);
                         }
                         return;
                     }
@@ -356,7 +356,7 @@ namespace ts.server.typingsInstaller {
                     for (const packageName of filteredTypings) {
                         const typingFile = typingToFileName(cachePath, packageName, this.installTypingHost, this.log);
                         if (!typingFile) {
-                            this.missingTypingsSet.set(packageName, true);
+                            this.missingTypingsSet.add(packageName);
                             continue;
                         }
 

From d0b29e86f8aeea07627e18c7c99f90b9c54e1cb6 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Mon, 22 Jun 2020 14:51:44 -0700
Subject: [PATCH 06/10] PR Feedback

---
 src/compiler/binder.ts                        | 13 ++--
 src/compiler/builder.ts                       | 68 ++++++++---------
 src/compiler/builderState.ts                  | 76 ++++++++-----------
 src/compiler/commandLineParser.ts             |  2 +-
 src/compiler/core.ts                          | 17 ++---
 src/compiler/corePublic.ts                    |  8 --
 src/compiler/moduleNameResolver.ts            |  4 +-
 src/compiler/program.ts                       | 39 +++++-----
 src/compiler/resolutionCache.ts               | 14 ++--
 src/compiler/sourcemap.ts                     |  2 +-
 src/compiler/sys.ts                           | 10 +--
 src/compiler/tsbuildPublic.ts                 | 68 ++++++++---------
 src/compiler/types.ts                         |  4 +-
 src/compiler/utilities.ts                     |  2 +-
 src/compiler/watchPublic.ts                   |  6 +-
 src/compiler/watchUtilities.ts                |  2 +-
 src/harness/virtualFileSystemWithWatch.ts     | 20 ++---
 src/server/editorServices.ts                  | 32 ++++----
 src/server/project.ts                         | 18 ++---
 src/server/scriptInfo.ts                      |  4 +-
 src/server/session.ts                         |  6 +-
 src/services/documentRegistry.ts              |  4 +-
 src/services/services.ts                      |  4 +-
 .../unittests/tscWatch/incremental.ts         | 12 +--
 .../tsserver/projectReferenceCompileOnSave.ts |  4 +-
 .../reference/api/tsserverlibrary.d.ts        |  2 +-
 26 files changed, 202 insertions(+), 239 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index a95582b53859a..97e7d65dcfaae 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -15,7 +15,7 @@ namespace ts {
         referenced: boolean;
     }
 
-    export function getModuleInstanceState(node: ModuleDeclaration, visited?: Map<string, ModuleInstanceState | undefined>): ModuleInstanceState {
+    export function getModuleInstanceState(node: ModuleDeclaration, visited?: Map<number, ModuleInstanceState | undefined>): ModuleInstanceState {
         if (node.body && !node.body.parent) {
             // getModuleInstanceStateForAliasTarget needs to walk up the parent chain, so parent pointers must be set on this tree already
             setParent(node.body, node);
@@ -24,8 +24,8 @@ namespace ts {
         return node.body ? getModuleInstanceStateCached(node.body, visited) : ModuleInstanceState.Instantiated;
     }
 
-    function getModuleInstanceStateCached(node: Node, visited = createMap<ModuleInstanceState | undefined>()) {
-        const nodeId = "" + getNodeId(node);
+    function getModuleInstanceStateCached(node: Node, visited = new Map<number, ModuleInstanceState | undefined>()) {
+        const nodeId = getNodeId(node);
         if (visited.has(nodeId)) {
             return visited.get(nodeId) || ModuleInstanceState.NonInstantiated;
         }
@@ -35,7 +35,7 @@ namespace ts {
         return result;
     }
 
-    function getModuleInstanceStateWorker(node: Node, visited: Map<string, ModuleInstanceState | undefined>): ModuleInstanceState {
+    function getModuleInstanceStateWorker(node: Node, visited: Map<number, ModuleInstanceState | undefined>): ModuleInstanceState {
         // A module is uninstantiated if it contains only
         switch (node.kind) {
             // 1. interface declarations, type alias declarations
@@ -107,7 +107,7 @@ namespace ts {
         return ModuleInstanceState.Instantiated;
     }
 
-    function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: Map<string, ModuleInstanceState | undefined>) {
+    function getModuleInstanceStateForAliasTarget(specifier: ExportSpecifier, visited: Map<number, ModuleInstanceState | undefined>) {
         const name = specifier.propertyName || specifier.name;
         let p: Node | undefined = specifier.parent;
         while (p) {
@@ -2865,8 +2865,7 @@ namespace ts {
 
         function addLateBoundAssignmentDeclarationToSymbol(node: BinaryExpression | DynamicNamedDeclaration, symbol: Symbol | undefined) {
             if (symbol) {
-                const members = symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = createMap());
-                members.set("" + getNodeId(node), node);
+                (symbol.assignmentDeclarationMembers ??= new Map()).set(getNodeId(node), node);
             }
         }
 
diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
index 18acfdfe3f450..a821fb2227f34 100644
--- a/src/compiler/builder.ts
+++ b/src/compiler/builder.ts
@@ -24,11 +24,11 @@ namespace ts {
         /**
          * Cache of bind and check diagnostics for files with their Path being the key
          */
-        semanticDiagnosticsPerFile?: ReadonlyMap<string, readonly ReusableDiagnostic[] | readonly Diagnostic[]> | undefined;
+        semanticDiagnosticsPerFile?: ReadonlyMap<Path, readonly ReusableDiagnostic[] | readonly Diagnostic[]> | undefined;
         /**
          * The map has key by source file's path that has been changed
          */
-        changedFilesSet?: ReadonlySet<string>;
+        changedFilesSet?: ReadonlySet<Path>;
         /**
          * Set of affected files being iterated
          */
@@ -41,7 +41,7 @@ namespace ts {
          * Map of file signatures, with key being file path, calculated while getting current changed file's affected files
          * These will be committed whenever the iteration through affected files of current changed file is complete
          */
-        currentAffectedFilesSignatures?: ReadonlyMap<string, string> | undefined;
+        currentAffectedFilesSignatures?: ReadonlyMap<Path, string> | undefined;
         /**
          * Newly computed visible to outside referencedSet
          */
@@ -49,7 +49,7 @@ namespace ts {
         /**
          * True if the semantic diagnostics were copied from the old state
          */
-        semanticDiagnosticsFromOldState?: Set<string>;
+        semanticDiagnosticsFromOldState?: Set<Path>;
         /**
          * program corresponding to this state
          */
@@ -65,7 +65,7 @@ namespace ts {
         /**
          * Files pending to be emitted kind.
          */
-        affectedFilesPendingEmitKind?: ReadonlyMap<string, BuilderFileEmit> | undefined;
+        affectedFilesPendingEmitKind?: ReadonlyMap<Path, BuilderFileEmit> | undefined;
         /**
          * Current index to retrieve pending affected file
          */
@@ -89,11 +89,11 @@ namespace ts {
         /**
          * Cache of bind and check diagnostics for files with their Path being the key
          */
-        semanticDiagnosticsPerFile: Map<string, readonly Diagnostic[]> | undefined;
+        semanticDiagnosticsPerFile: Map<Path, readonly Diagnostic[]> | undefined;
         /**
          * The map has key by source file's path that has been changed
          */
-        changedFilesSet: Set<string>;
+        changedFilesSet: Set<Path>;
         /**
          * Set of affected files being iterated
          */
@@ -110,7 +110,7 @@ namespace ts {
          * Map of file signatures, with key being file path, calculated while getting current changed file's affected files
          * These will be committed whenever the iteration through affected files of current changed file is complete
          */
-        currentAffectedFilesSignatures: Map<string, string> | undefined;
+        currentAffectedFilesSignatures: Map<Path, string> | undefined;
         /**
          * Newly computed visible to outside referencedSet
          */
@@ -118,7 +118,7 @@ namespace ts {
         /**
          * Already seen affected files
          */
-        seenAffectedFiles: Set<string> | undefined;
+        seenAffectedFiles: Set<Path> | undefined;
         /**
          * whether this program has cleaned semantic diagnostics cache for lib files
          */
@@ -126,7 +126,7 @@ namespace ts {
         /**
          * True if the semantic diagnostics were copied from the old state
          */
-        semanticDiagnosticsFromOldState?: Set<string>;
+        semanticDiagnosticsFromOldState?: Set<Path>;
         /**
          * program corresponding to this state
          */
@@ -142,7 +142,7 @@ namespace ts {
         /**
          * Files pending to be emitted kind.
          */
-        affectedFilesPendingEmitKind: Map<string, BuilderFileEmit> | undefined;
+        affectedFilesPendingEmitKind: Map<Path, BuilderFileEmit> | undefined;
         /**
          * Current index to retrieve pending affected file
          */
@@ -154,7 +154,7 @@ namespace ts {
         /**
          * Already seen emitted files
          */
-        seenEmittedFiles: Map<string, BuilderFileEmit> | undefined;
+        seenEmittedFiles: Map<Path, BuilderFileEmit> | undefined;
         /**
          * true if program has been emitted
          */
@@ -176,7 +176,7 @@ namespace ts {
         state.compilerOptions = compilerOptions;
         // With --out or --outFile, any change affects all semantic diagnostics so no need to cache them
         if (!outFile(compilerOptions)) {
-            state.semanticDiagnosticsPerFile = createMap<readonly Diagnostic[]>();
+            state.semanticDiagnosticsPerFile = new Map();
         }
         state.changedFilesSet = new Set();
 
@@ -199,7 +199,7 @@ namespace ts {
             changedFilesSet?.forEach(value => state.changedFilesSet.add(value));
             if (!outFile(compilerOptions) && oldState!.affectedFilesPendingEmit) {
                 state.affectedFilesPendingEmit = oldState!.affectedFilesPendingEmit.slice();
-                state.affectedFilesPendingEmitKind = cloneMapOrUndefined(oldState!.affectedFilesPendingEmitKind);
+                state.affectedFilesPendingEmitKind = oldState!.affectedFilesPendingEmitKind && new Map(oldState!.affectedFilesPendingEmitKind);
                 state.affectedFilesPendingEmitIndex = oldState!.affectedFilesPendingEmitIndex;
                 state.seenAffectedFiles = new Set();
             }
@@ -305,22 +305,22 @@ namespace ts {
      */
     function cloneBuilderProgramState(state: Readonly<BuilderProgramState>): BuilderProgramState {
         const newState = BuilderState.clone(state) as BuilderProgramState;
-        newState.semanticDiagnosticsPerFile = cloneMapOrUndefined(state.semanticDiagnosticsPerFile);
+        newState.semanticDiagnosticsPerFile = state.semanticDiagnosticsPerFile && new Map(state.semanticDiagnosticsPerFile);
         newState.changedFilesSet = new Set(state.changedFilesSet);
         newState.affectedFiles = state.affectedFiles;
         newState.affectedFilesIndex = state.affectedFilesIndex;
         newState.currentChangedFilePath = state.currentChangedFilePath;
-        newState.currentAffectedFilesSignatures = cloneMapOrUndefined(state.currentAffectedFilesSignatures);
-        newState.currentAffectedFilesExportedModulesMap = cloneMapOrUndefined(state.currentAffectedFilesExportedModulesMap);
+        newState.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures && new Map(state.currentAffectedFilesSignatures);
+        newState.currentAffectedFilesExportedModulesMap = state.currentAffectedFilesExportedModulesMap && new Map(state.currentAffectedFilesExportedModulesMap);
         newState.seenAffectedFiles = state.seenAffectedFiles && new Set(state.seenAffectedFiles);
         newState.cleanedDiagnosticsOfLibFiles = state.cleanedDiagnosticsOfLibFiles;
         newState.semanticDiagnosticsFromOldState = state.semanticDiagnosticsFromOldState && new Set(state.semanticDiagnosticsFromOldState);
         newState.program = state.program;
         newState.compilerOptions = state.compilerOptions;
         newState.affectedFilesPendingEmit = state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice();
-        newState.affectedFilesPendingEmitKind = cloneMapOrUndefined(state.affectedFilesPendingEmitKind);
+        newState.affectedFilesPendingEmitKind = state.affectedFilesPendingEmitKind && new Map(state.affectedFilesPendingEmitKind);
         newState.affectedFilesPendingEmitIndex = state.affectedFilesPendingEmitIndex;
-        newState.seenEmittedFiles = cloneMapOrUndefined(state.seenEmittedFiles);
+        newState.seenEmittedFiles = state.seenEmittedFiles && new Map(state.seenEmittedFiles);
         newState.programEmitComplete = state.programEmitComplete;
         return newState;
     }
@@ -382,14 +382,14 @@ namespace ts {
             }
 
             // Get next batch of affected files
-            state.currentAffectedFilesSignatures = state.currentAffectedFilesSignatures || createMap();
+            state.currentAffectedFilesSignatures ??= new Map();
             if (state.exportedModulesMap) {
-                state.currentAffectedFilesExportedModulesMap = state.currentAffectedFilesExportedModulesMap || createMap<BuilderState.ReferencedSet | false>();
+                state.currentAffectedFilesExportedModulesMap ??= new Map();
             }
-            state.affectedFiles = BuilderState.getFilesAffectedBy(state, program, nextKey.value as Path, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
-            state.currentChangedFilePath = nextKey.value as Path;
+            state.affectedFiles = BuilderState.getFilesAffectedBy(state, program, nextKey.value, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
+            state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
-            state.seenAffectedFiles = state.seenAffectedFiles || new Set();
+            state.seenAffectedFiles ??= new Set();
         }
     }
 
@@ -399,7 +399,7 @@ namespace ts {
     function getNextAffectedFilePendingEmit(state: BuilderProgramState) {
         const { affectedFilesPendingEmit } = state;
         if (affectedFilesPendingEmit) {
-            const seenEmittedFiles = state.seenEmittedFiles || (state.seenEmittedFiles = createMap());
+            const seenEmittedFiles = (state.seenEmittedFiles ??= new Map());
             for (let i = state.affectedFilesPendingEmitIndex!; i < affectedFilesPendingEmit.length; i++) {
                 const affectedFile = Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]);
                 if (affectedFile) {
@@ -514,7 +514,7 @@ namespace ts {
         // Since isolated modules dont change js files, files affected by change in signature is itself
         // But we need to cleanup semantic diagnostics and queue dts emit for affected files
         if (state.compilerOptions.isolatedModules) {
-            const seenFileNamesMap = createMap<true>();
+            const seenFileNamesMap = new Map<Path, true>();
             seenFileNamesMap.set(affectedFile.resolvedPath, true);
             const queue = BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath);
             while (queue.length > 0) {
@@ -622,7 +622,7 @@ namespace ts {
         else {
             state.seenAffectedFiles!.add((affected as SourceFile).resolvedPath);
             if (emitKind !== undefined) {
-                (state.seenEmittedFiles || (state.seenEmittedFiles = createMap())).set((affected as SourceFile).resolvedPath, emitKind);
+                (state.seenEmittedFiles ??= new Map()).set((affected as SourceFile).resolvedPath, emitKind);
             }
             if (isPendingEmit) {
                 state.affectedFilesPendingEmitIndex!++;
@@ -758,9 +758,9 @@ namespace ts {
 
         if (state.affectedFilesPendingEmit) {
             const affectedFilesPendingEmit: ProgramBuilderInfoFilePendingEmit[] = [];
-            const seenFiles = createMap<true>();
+            const seenFiles = new Set<Path>();
             for (const path of state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(compareStringsCaseSensitive)) {
-                if (addToSeen(seenFiles, path)) {
+                if (tryAddToSet(seenFiles, path)) {
                     affectedFilesPendingEmit.push([relativeToBuildInfo(path), state.affectedFilesPendingEmitKind!.get(path)!]);
                 }
             }
@@ -1124,8 +1124,8 @@ namespace ts {
     }
 
     function addToAffectedFilesPendingEmit(state: BuilderProgramState, affectedFilePendingEmit: Path, kind: BuilderFileEmit) {
-        if (!state.affectedFilesPendingEmit) state.affectedFilesPendingEmit = [];
-        if (!state.affectedFilesPendingEmitKind) state.affectedFilesPendingEmitKind = createMap();
+        state.affectedFilesPendingEmit ??= [];
+        state.affectedFilesPendingEmitKind ??= new Map();
 
         const existingKind = state.affectedFilesPendingEmitKind.get(affectedFilePendingEmit);
         state.affectedFilesPendingEmit.push(affectedFilePendingEmit);
@@ -1140,9 +1140,9 @@ namespace ts {
         }
     }
 
-    function getMapOfReferencedSet(mapLike: MapLike<readonly string[]> | undefined, toPath: (path: string) => Path): ReadonlyMap<string, BuilderState.ReferencedSet> | undefined {
+    function getMapOfReferencedSet(mapLike: MapLike<readonly string[]> | undefined, toPath: (path: string) => Path): ReadonlyMap<Path, BuilderState.ReferencedSet> | undefined {
         if (!mapLike) return undefined;
-        const map = createMap<BuilderState.ReferencedSet>();
+        const map = new Map<Path, BuilderState.ReferencedSet>();
         // Copies keys/values from template. Note that for..in will not throw if
         // template is undefined, and instead will just exit the loop.
         for (const key in mapLike) {
@@ -1157,7 +1157,7 @@ namespace ts {
         const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
 
-        const fileInfos = createMap<BuilderState.FileInfo>();
+        const fileInfos = new Map<Path, BuilderState.FileInfo>();
         for (const key in program.fileInfos) {
             if (hasProperty(program.fileInfos, key)) {
                 fileInfos.set(toPath(key), program.fileInfos[key]);
diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index 15a0df20f7286..b3a2de59063cf 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -15,42 +15,42 @@ namespace ts {
         /**
          * Information of the file eg. its version, signature etc
          */
-        fileInfos: ReadonlyMap<string, BuilderState.FileInfo>;
+        fileInfos: ReadonlyMap<Path, BuilderState.FileInfo>;
         /**
          * Contains the map of ReferencedSet=Referenced files of the file if module emit is enabled
          * Otherwise undefined
          * Thus non undefined value indicates, module emit
          */
-        readonly referencedMap?: ReadonlyMap<string, BuilderState.ReferencedSet> | undefined;
+        readonly referencedMap?: ReadonlyMap<Path, BuilderState.ReferencedSet> | undefined;
         /**
          * Contains the map of exported modules ReferencedSet=exported module files from the file if module emit is enabled
          * Otherwise undefined
          */
-        readonly exportedModulesMap?: ReadonlyMap<string, BuilderState.ReferencedSet> | undefined;
+        readonly exportedModulesMap?: ReadonlyMap<Path, BuilderState.ReferencedSet> | undefined;
     }
 
     export interface BuilderState {
         /**
          * Information of the file eg. its version, signature etc
          */
-        fileInfos: Map<string, BuilderState.FileInfo>;
+        fileInfos: Map<Path, BuilderState.FileInfo>;
         /**
          * Contains the map of ReferencedSet=Referenced files of the file if module emit is enabled
          * Otherwise undefined
          * Thus non undefined value indicates, module emit
          */
-        readonly referencedMap: ReadonlyMap<string, BuilderState.ReferencedSet> | undefined;
+        readonly referencedMap: ReadonlyMap<Path, BuilderState.ReferencedSet> | undefined;
         /**
          * Contains the map of exported modules ReferencedSet=exported module files from the file if module emit is enabled
          * Otherwise undefined
          */
-        readonly exportedModulesMap: Map<string, BuilderState.ReferencedSet> | undefined;
+        readonly exportedModulesMap: Map<Path, BuilderState.ReferencedSet> | undefined;
         /**
          * Map of files that have already called update signature.
          * That means hence forth these files are assumed to have
          * no change in their signature for this version of the program
          */
-        hasCalledUpdateShapeSignature: Set<string>;
+        hasCalledUpdateShapeSignature: Set<Path>;
         /**
          * Cache of all files excluding default library file for the current program
          */
@@ -73,7 +73,7 @@ namespace ts {
         /**
          * Referenced files with values for the keys as referenced file's path to be true
          */
-        export type ReferencedSet = ReadonlySet<string>;
+        export type ReferencedSet = ReadonlySet<Path>;
         /**
          * Compute the hash to store the shape of the file
          */
@@ -83,7 +83,7 @@ namespace ts {
          * Exported modules to from declaration emit being computed.
          * This can contain false in the affected file path to specify that there are no exported module(types from other modules) for this file
          */
-        export type ComputingExportedModulesMap = Map<string, ReferencedSet | false>;
+        export type ComputingExportedModulesMap = Map<Path, ReferencedSet | false>;
 
         /**
          * Get the referencedFile from the imported module symbol
@@ -113,8 +113,8 @@ namespace ts {
         /**
          * Gets the referenced files for a file from the program with values for the keys as referenced file's path to be true
          */
-        function getReferencedFiles(program: Program, sourceFile: SourceFile, getCanonicalFileName: GetCanonicalFileName): Set<string> | undefined {
-            let referencedFiles: Set<string> | undefined;
+        function getReferencedFiles(program: Program, sourceFile: SourceFile, getCanonicalFileName: GetCanonicalFileName): Set<Path> | undefined {
+            let referencedFiles: Set<Path> | undefined;
 
             // We need to use a set here since the code can contain the same import twice,
             // but that will only be one dependency.
@@ -185,17 +185,14 @@ namespace ts {
             }
 
             function addReferencedFile(referencedPath: Path) {
-                if (!referencedFiles) {
-                    referencedFiles = new Set<string>();
-                }
-                referencedFiles.add(referencedPath);
+                (referencedFiles ??= new Set()).add(referencedPath);
             }
         }
 
         /**
          * Returns true if oldState is reusable, that is the emitKind = module/non module has not changed
          */
-        export function canReuseOldState(newReferencedMap: ReadonlyMap<string, ReferencedSet> | undefined, oldState: Readonly<ReusableBuilderState> | undefined) {
+        export function canReuseOldState(newReferencedMap: ReadonlyMap<Path, ReferencedSet> | undefined, oldState: Readonly<ReusableBuilderState> | undefined) {
             return oldState && !oldState.referencedMap === !newReferencedMap;
         }
 
@@ -203,10 +200,10 @@ namespace ts {
          * Creates the state of file references and signature for the new program from oldState if it is safe
          */
         export function create(newProgram: Program, getCanonicalFileName: GetCanonicalFileName, oldState?: Readonly<ReusableBuilderState>): BuilderState {
-            const fileInfos = createMap<FileInfo>();
-            const referencedMap = newProgram.getCompilerOptions().module !== ModuleKind.None ? createMap<ReferencedSet>() : undefined;
-            const exportedModulesMap = referencedMap ? createMap<ReferencedSet>() : undefined;
-            const hasCalledUpdateShapeSignature = new Set<string>();
+            const fileInfos = new Map<Path, FileInfo>();
+            const referencedMap = newProgram.getCompilerOptions().module !== ModuleKind.None ? new Map<Path, ReferencedSet>() : undefined;
+            const exportedModulesMap = referencedMap ? new Map<Path, ReferencedSet>() : undefined;
+            const hasCalledUpdateShapeSignature = new Set<Path>();
             const useOldState = canReuseOldState(referencedMap, oldState);
 
             // Create the reference map, and set the file infos
@@ -249,15 +246,11 @@ namespace ts {
          * Creates a clone of the state
          */
         export function clone(state: Readonly<BuilderState>): BuilderState {
-            const fileInfos = createMap<FileInfo>();
-            state.fileInfos.forEach((value, key) => {
-                fileInfos.set(key, { ...value });
-            });
             // Dont need to backup allFiles info since its cache anyway
             return {
-                fileInfos,
-                referencedMap: cloneMapOrUndefined(state.referencedMap),
-                exportedModulesMap: cloneMapOrUndefined(state.exportedModulesMap),
+                fileInfos: new Map(state.fileInfos),
+                referencedMap: state.referencedMap && new Map(state.referencedMap),
+                exportedModulesMap: state.exportedModulesMap && new Map(state.exportedModulesMap),
                 hasCalledUpdateShapeSignature: new Set(state.hasCalledUpdateShapeSignature),
             };
         }
@@ -265,12 +258,12 @@ namespace ts {
         /**
          * Gets the files affected by the path from the program
          */
-        export function getFilesAffectedBy(state: BuilderState, programOfThisState: Program, path: Path, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, cacheToUpdateSignature?: Map<string, string>, exportedModulesMapCache?: ComputingExportedModulesMap): readonly SourceFile[] {
+        export function getFilesAffectedBy(state: BuilderState, programOfThisState: Program, path: Path, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, cacheToUpdateSignature?: Map<Path, string>, exportedModulesMapCache?: ComputingExportedModulesMap): readonly SourceFile[] {
             // Since the operation could be cancelled, the signatures are always stored in the cache
             // They will be committed once it is safe to use them
             // eg when calling this api from tsserver, if there is no cancellation of the operation
             // In the other cases the affected files signatures are committed only after the iteration through the result is complete
-            const signatureCache = cacheToUpdateSignature || createMap();
+            const signatureCache = cacheToUpdateSignature || new Map();
             const sourceFile = programOfThisState.getSourceFileByPath(path);
             if (!sourceFile) {
                 return emptyArray;
@@ -292,8 +285,8 @@ namespace ts {
          * Updates the signatures from the cache into state's fileinfo signatures
          * This should be called whenever it is safe to commit the state of the builder
          */
-        export function updateSignaturesFromCache(state: BuilderState, signatureCache: Map<string, string>) {
-            signatureCache.forEach((signature, path) => updateSignatureOfFile(state, signature, path as Path));
+        export function updateSignaturesFromCache(state: BuilderState, signatureCache: Map<Path, string>) {
+            signatureCache.forEach((signature, path) => updateSignatureOfFile(state, signature, path));
         }
 
         export function updateSignatureOfFile(state: BuilderState, signature: string | undefined, path: Path) {
@@ -304,7 +297,7 @@ namespace ts {
         /**
          * Returns if the shape of the signature has changed since last emit
          */
-        export function updateShapeSignature(state: Readonly<BuilderState>, programOfThisState: Program, sourceFile: SourceFile, cacheToUpdateSignature: Map<string, string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, exportedModulesMapCache?: ComputingExportedModulesMap) {
+        export function updateShapeSignature(state: Readonly<BuilderState>, programOfThisState: Program, sourceFile: SourceFile, cacheToUpdateSignature: Map<Path, string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash, exportedModulesMapCache?: ComputingExportedModulesMap) {
             Debug.assert(!!sourceFile);
             Debug.assert(!exportedModulesMapCache || !!state.exportedModulesMap, "Compute visible to outside map only if visibleToOutsideReferencedMap present in the state");
 
@@ -365,7 +358,7 @@ namespace ts {
                 return;
             }
 
-            let exportedModules: Set<string> | undefined;
+            let exportedModules: Set<Path> | undefined;
             exportedModulesFromDeclarationEmit.forEach(symbol => addExportedModule(getReferencedFileFromImportedModuleSymbol(symbol)));
             exportedModulesMapCache.set(sourceFile.resolvedPath, exportedModules || false);
 
@@ -413,12 +406,12 @@ namespace ts {
             }
 
             // Get the references, traversing deep from the referenceMap
-            const seenMap = createMap<true>();
+            const seenMap = new Set<Path>();
             const queue = [sourceFile.resolvedPath];
             while (queue.length) {
                 const path = queue.pop()!;
                 if (!seenMap.has(path)) {
-                    seenMap.set(path, true);
+                    seenMap.add(path);
                     const references = state.referencedMap.get(path);
                     if (references) {
                         const iterator = references.keys();
@@ -429,10 +422,7 @@ namespace ts {
                 }
             }
 
-            return arrayFrom(mapDefinedIterator(seenMap.keys(), path => {
-                const file = programOfThisState.getSourceFileByPath(path as Path);
-                return file ? file.fileName : path;
-            }));
+            return arrayFrom(mapDefinedIterator(seenMap.keys(), path => programOfThisState.getSourceFileByPath(path)?.fileName ?? path));
         }
 
         /**
@@ -528,7 +518,7 @@ namespace ts {
         /**
          * When program emits modular code, gets the files affected by the sourceFile whose shape has changed
          */
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state: BuilderState, programOfThisState: Program, sourceFileWithUpdatedShape: SourceFile, cacheToUpdateSignature: Map<string, string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash | undefined, exportedModulesMapCache: ComputingExportedModulesMap | undefined) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state: BuilderState, programOfThisState: Program, sourceFileWithUpdatedShape: SourceFile, cacheToUpdateSignature: Map<Path, string>, cancellationToken: CancellationToken | undefined, computeHash: ComputeHash | undefined, exportedModulesMapCache: ComputingExportedModulesMap | undefined) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -541,7 +531,7 @@ namespace ts {
             // Now we need to if each file in the referencedBy list has a shape change as well.
             // Because if so, its own referencedBy files need to be saved as well to make the
             // emitting result consistent with files on disk.
-            const seenFileNamesMap = createMap<SourceFile>();
+            const seenFileNamesMap = new Map<Path, SourceFile>();
 
             // Start with the paths this file was referenced by
             seenFileNamesMap.set(sourceFileWithUpdatedShape.resolvedPath, sourceFileWithUpdatedShape);
@@ -562,8 +552,4 @@ namespace ts {
             return arrayFrom(mapDefinedIterator(seenFileNamesMap.values(), value => value));
         }
     }
-
-    export function cloneMapOrUndefined<T>(map: ReadonlyMap<string, T> | undefined) {
-        return map ? cloneMap(map) : undefined;
-    }
 }
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index c6d310f3c68bb..0cc7eaf7fc303 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -76,7 +76,7 @@ namespace ts {
      * option as well as for resolving lib reference directives.
      */
     /* @internal */
-    export const libMap = createMapFromEntries(libEntries);
+    export const libMap = new Map(libEntries);
 
     // Watch related options
     /* @internal */
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 73c77251f7720..568f8008e022e 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -42,17 +42,12 @@ namespace ts {
     export const emptyArray: never[] = [] as never[];
 
     /** Create a new map. */
-    export function createMap<T>(): Map<string, T>;
     export function createMap<K, V>(): Map<K, V>;
+    export function createMap<T>(): Map<string, T>;
     export function createMap<K, V>(): Map<K, V> {
         return new Map<K, V>();
     }
 
-    /** Create a new map from an array of entries. */
-    export function createMapFromEntries<K, V>(entries: readonly [K, V][]): Map<K, V> {
-        return new Map(entries);
-    }
-
     /** Create a new map from a template object is provided, the map will copy entries from it. */
     export function createMapFromTemplate<T>(template: MapLike<T>): Map<string, T> {
         const map: Map<string, T> = new Map<string, T>();
@@ -1339,10 +1334,10 @@ namespace ts {
      * the same key with the given 'makeKey' function, then the element with the higher
      * index in the array will be the one associated with the produced key.
      */
-    export function arrayToMap<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<string, T>;
-    export function arrayToMap<T, U>(array: readonly T[], makeKey: (value: T) => string | undefined, makeValue: (value: T) => U): Map<string, U>;
     export function arrayToMap<K, V>(array: readonly V[], makeKey: (value: V) => K | undefined): Map<K, V>;
     export function arrayToMap<K, V1, V2>(array: readonly V1[], makeKey: (value: V1) => K | undefined, makeValue: (value: V1) => V2): Map<K, V2>;
+    export function arrayToMap<T>(array: readonly T[], makeKey: (value: T) => string | undefined): Map<string, T>;
+    export function arrayToMap<T, U>(array: readonly T[], makeKey: (value: T) => string | undefined, makeValue: (value: T) => U): Map<string, U>;
     export function arrayToMap<K, V1, V2>(array: readonly V1[], makeKey: (value: V1) => K | undefined, makeValue: (value: V1) => V1 | V2 = identity): Map<K, V1 | V2> {
         const result = new Map<K, V1 | V2>();
         for (const value of array) {
@@ -1436,8 +1431,8 @@ namespace ts {
         remove(key: K, value: V): void;
     }
 
-    export function createMultiMap<V>(): MultiMap<string, V>;
     export function createMultiMap<K, V>(): MultiMap<K, V>;
+    export function createMultiMap<V>(): MultiMap<string, V>;
     export function createMultiMap<K, V>(): MultiMap<K, V> {
         const map = new Map<K, V[]>() as MultiMap<K, V>;
         map.add = multiMapAdd;
@@ -1662,7 +1657,7 @@ namespace ts {
      * Case-sensitive comparisons compare both strings one code-point at a time using the integer
      * value of each code-point after applying `toUpperCase` to each string. We always map both
      * strings to their upper-case form as some unicode characters do not properly round-trip to
-     * lowercase (such as `ẞ` (German sharp capital s)).
+     * lowercase (such as `ẞ` (German sharp capital s)).
      */
     export function equateStringsCaseInsensitive(a: string, b: string) {
         return a === b
@@ -1720,7 +1715,7 @@ namespace ts {
      * Case-insensitive comparisons compare both strings one code-point at a time using the integer
      * value of each code-point after applying `toUpperCase` to each string. We always map both
      * strings to their upper-case form as some unicode characters do not properly round-trip to
-     * lowercase (such as `ẞ` (German sharp capital s)).
+     * lowercase (such as `ẞ` (German sharp capital s)).
      */
     export function compareStringsCaseInsensitive(a: string, b: string) {
         if (a === b) return Comparison.EqualTo;
diff --git a/src/compiler/corePublic.ts b/src/compiler/corePublic.ts
index bd935bb22844b..f580dc5b92451 100644
--- a/src/compiler/corePublic.ts
+++ b/src/compiler/corePublic.ts
@@ -43,10 +43,6 @@ namespace ts {
         forEach(action: (value: V, key: K) => void): void;
     }
 
-    /* @internal */
-    export interface ReadonlyMap<K, V> {
-    }
-
     /** ES6 Map interface. */
     export interface Map<K, V> extends ReadonlyMap<K, V>, Collection<K> {
         set(key: K, value: V): this;
@@ -66,10 +62,6 @@ namespace ts {
         forEach(action: (value: T, key: T) => void): void;
     }
 
-    /* @internal */
-    export interface ReadonlySet<T> {
-    }
-
     /** ES6 Set interface. */
     export interface Set<T> extends ReadonlySet<T>, Collection<T> {
         add(value: T): this;
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
index 61f6ccd8332b7..50d7e9a4d0f53 100644
--- a/src/compiler/moduleNameResolver.ts
+++ b/src/compiler/moduleNameResolver.ts
@@ -473,7 +473,7 @@ namespace ts {
     /*@internal*/
     export interface CacheWithRedirects<T> {
         ownMap: Map<string, T>;
-        redirectsMap: Map<string, Map<string, T>>;
+        redirectsMap: Map<Path, Map<string, T>>;
         getOrCreateMapOfCacheRedirects(redirectedReference: ResolvedProjectReference | undefined): Map<string, T>;
         clear(): void;
         setOwnOptions(newOptions: CompilerOptions): void;
@@ -483,7 +483,7 @@ namespace ts {
     /*@internal*/
     export function createCacheWithRedirects<T>(options?: CompilerOptions): CacheWithRedirects<T> {
         let ownMap: Map<string, T> = createMap();
-        const redirectsMap: Map<string, Map<string, T>> = createMap();
+        const redirectsMap = new Map<Path, Map<string, T>>();
         return {
             ownMap,
             redirectsMap,
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index aadfeefb6f140..4fdb999bb6b29 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -533,7 +533,7 @@ namespace ts {
     export const inferredTypesContainingFile = "__inferred type names__.ts";
 
     interface DiagnosticCache<T extends Diagnostic> {
-        perFile?: Map<string, readonly T[]>;
+        perFile?: Map<Path, readonly T[]>;
         allDiagnostics?: readonly T[];
     }
 
@@ -709,7 +709,7 @@ namespace ts {
         let classifiableNames: UnderscoreEscapedMap<true>;
         const ambientModuleNameToUnmodifiedFileName = createMap<string>();
         // Todo:: Use this to report why file was included in --extendedDiagnostics
-        let refFileMap: MultiMap<string, ts.RefFile> | undefined;
+        let refFileMap: MultiMap<Path, ts.RefFile> | undefined;
 
         const cachedBindAndCheckDiagnosticsForFile: DiagnosticCache<Diagnostic> = {};
         const cachedDeclarationDiagnosticsForFile: DiagnosticCache<DiagnosticWithLocation> = {};
@@ -803,9 +803,9 @@ namespace ts {
 
         // A parallel array to projectReferences storing the results of reading in the referenced tsconfig files
         let resolvedProjectReferences: readonly (ResolvedProjectReference | undefined)[] | undefined;
-        let projectReferenceRedirects: Map<string, ResolvedProjectReference | false> | undefined;
-        let mapFromFileToProjectReferenceRedirects: Map<string, Path> | undefined;
-        let mapFromToProjectReferenceRedirectSource: Map<string, SourceOfProjectReferenceRedirect> | undefined;
+        let projectReferenceRedirects: Map<Path, ResolvedProjectReference | false> | undefined;
+        let mapFromFileToProjectReferenceRedirects: Map<Path, Path> | undefined;
+        let mapFromToProjectReferenceRedirectSource: Map<Path, SourceOfProjectReferenceRedirect> | undefined;
 
         const useSourceOfProjectReferenceRedirect = !!host.useSourceOfProjectReferenceRedirect?.() &&
             !options.disableSourceOfProjectReferenceRedirect;
@@ -2028,7 +2028,7 @@ namespace ts {
         ): readonly U[] {
 
             const cachedResult = sourceFile
-                ? cache.perFile && cache.perFile.get(sourceFile.path)
+                ? cache.perFile?.get(sourceFile.path)
                 : cache.allDiagnostics;
 
             if (cachedResult) {
@@ -2036,10 +2036,7 @@ namespace ts {
             }
             const result = getDiagnostics(sourceFile, cancellationToken);
             if (sourceFile) {
-                if (!cache.perFile) {
-                    cache.perFile = createMap();
-                }
-                cache.perFile.set(sourceFile.path, result);
+                (cache.perFile ??= new Map()).set(sourceFile.path, result);
             }
             else {
                 cache.allDiagnostics = result;
@@ -2498,7 +2495,7 @@ namespace ts {
 
         function addFileToRefFileMap(referencedFileName: string, file: SourceFile | undefined, refFile: RefFile | undefined) {
             if (refFile && file) {
-                (refFileMap || (refFileMap = createMultiMap())).add(file.path, {
+                (refFileMap ??= createMultiMap()).add(file.path, {
                     referencedFileName,
                     kind: refFile.kind,
                     index: refFile.index,
@@ -2546,7 +2543,7 @@ namespace ts {
          */
         function getResolvedProjectReferenceToRedirect(fileName: string) {
             if (mapFromFileToProjectReferenceRedirects === undefined) {
-                mapFromFileToProjectReferenceRedirects = createMap();
+                mapFromFileToProjectReferenceRedirects = new Map();
                 forEachResolvedProjectReference((referencedProject, referenceProjectPath) => {
                     // not input file from the referenced project, ignore
                     if (referencedProject &&
@@ -2892,7 +2889,7 @@ namespace ts {
         function checkSourceFilesBelongToPath(sourceFiles: readonly SourceFile[], rootDirectory: string): boolean {
             let allFilesBelongToPath = true;
             const absoluteRootDirectoryPath = host.getCanonicalFileName(getNormalizedAbsolutePath(rootDirectory, currentDirectory));
-            let rootPaths: Set<string> | undefined;
+            let rootPaths: Set<Path> | undefined;
 
             for (const sourceFile of sourceFiles) {
                 if (!sourceFile.isDeclarationFile) {
@@ -2916,7 +2913,7 @@ namespace ts {
 
         function parseProjectReferenceConfigFile(ref: ProjectReference): ResolvedProjectReference | undefined {
             if (!projectReferenceRedirects) {
-                projectReferenceRedirects = createMap<ResolvedProjectReference | false>();
+                projectReferenceRedirects = new Map();
             }
 
             // The actual filename (i.e. add "/tsconfig.json" if necessary)
@@ -3262,8 +3259,8 @@ namespace ts {
             return createFileDiagnostic(refFile, pos, end - pos, message, ...args);
         }
 
-        function addProgramDiagnosticAtRefPath(file: SourceFile, rootPaths: Set<string>, message: DiagnosticMessage, ...args: (string | number | undefined)[]) {
-            const refPaths = refFileMap && refFileMap.get(file.path);
+        function addProgramDiagnosticAtRefPath(file: SourceFile, rootPaths: Set<Path>, message: DiagnosticMessage, ...args: (string | number | undefined)[]) {
+            const refPaths = refFileMap?.get(file.path);
             const refPathToReportErrorOn = forEach(refPaths, refPath => rootPaths.has(refPath.file) ? refPath : undefined) ||
                 elementAt(refPaths, 0);
             programDiagnostics.add(
@@ -3481,9 +3478,9 @@ namespace ts {
     }
 
     function updateHostForUseSourceOfProjectReferenceRedirect(host: HostForUseSourceOfProjectReferenceRedirect) {
-        let setOfDeclarationDirectories: Set<string> | undefined;
-        let symlinkedDirectories: Map<string, SymlinkedDirectory | false> | undefined;
-        let symlinkedFiles: Map<string, string> | undefined;
+        let setOfDeclarationDirectories: Set<Path> | undefined;
+        let symlinkedDirectories: Map<Path, SymlinkedDirectory | false> | undefined;
+        let symlinkedFiles: Map<Path, string> | undefined;
 
         const originalFileExists = host.compilerHost.fileExists;
         const originalDirectoryExists = host.compilerHost.directoryExists;
@@ -3590,7 +3587,7 @@ namespace ts {
 
             // Because we already watch node_modules, handle symlinks in there
             if (!originalRealpath || !stringContains(directory, nodeModulesPathPart)) return;
-            if (!symlinkedDirectories) symlinkedDirectories = createMap();
+            if (!symlinkedDirectories) symlinkedDirectories = new Map();
             const directoryPath = ensureTrailingDirectorySeparator(host.toPath(directory));
             if (symlinkedDirectories.has(directoryPath)) return;
 
@@ -3629,7 +3626,7 @@ namespace ts {
                     if (!symlinkedDirectory || !startsWith(fileOrDirectoryPath, directoryPath)) return undefined;
                     const result = fileOrDirectoryExistsUsingSource(fileOrDirectoryPath.replace(directoryPath, symlinkedDirectory.realPath));
                     if (isFile && result) {
-                        if (!symlinkedFiles) symlinkedFiles = createMap();
+                        if (!symlinkedFiles) symlinkedFiles = new Map();
                         // Store the real path for the file'
                         const absolutePath = getNormalizedAbsolutePath(fileOrDirectory, host.compilerHost.getCurrentDirectory());
                         symlinkedFiles.set(
diff --git a/src/compiler/resolutionCache.ts b/src/compiler/resolutionCache.ts
index 9f2c023c6872b..dc79fe0fabff9 100644
--- a/src/compiler/resolutionCache.ts
+++ b/src/compiler/resolutionCache.ts
@@ -13,7 +13,7 @@ namespace ts {
         invalidateResolutionOfFile(filePath: Path): void;
         removeResolutionsOfFile(filePath: Path): void;
         removeResolutionsFromProjectReferenceRedirects(filePath: Path): void;
-        setFilesWithInvalidatedNonRelativeUnresolvedImports(filesWithUnresolvedImports: Map<string, readonly string[]>): void;
+        setFilesWithInvalidatedNonRelativeUnresolvedImports(filesWithUnresolvedImports: Map<Path, readonly string[]>): void;
         createHasInvalidatedResolution(forceAllFilesAsInvalidated?: boolean): HasInvalidatedResolution;
         hasChangedAutomaticTypeDirectiveNames(): boolean;
 
@@ -143,8 +143,8 @@ namespace ts {
 
     export function createResolutionCache(resolutionHost: ResolutionCacheHost, rootDirForResolution: string | undefined, logChangesWhenResolvingModule: boolean): ResolutionCache {
         let filesWithChangedSetOfUnresolvedImports: Path[] | undefined;
-        let filesWithInvalidatedResolutions: Set<string> | undefined;
-        let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<string, readonly string[]> | undefined;
+        let filesWithInvalidatedResolutions: Set<Path> | undefined;
+        let filesWithInvalidatedNonRelativeUnresolvedImports: ReadonlyMap<Path, readonly string[]> | undefined;
         const nonRelativeExternalModuleResolutions = createMultiMap<ResolutionWithFailedLookupLocations>();
 
         const resolutionsWithFailedLookups: ResolutionWithFailedLookupLocations[] = [];
@@ -161,7 +161,7 @@ namespace ts {
         // The resolvedModuleNames and resolvedTypeReferenceDirectives are the cache of resolutions per file.
         // The key in the map is source file's path.
         // The values are Map of resolutions with key being name lookedup.
-        const resolvedModuleNames = createMap<Map<string, CachedResolvedModuleWithFailedLookupLocations>>();
+        const resolvedModuleNames = new Map<Path, Map<string, CachedResolvedModuleWithFailedLookupLocations>>();
         const perDirectoryResolvedModuleNames: CacheWithRedirects<Map<string, CachedResolvedModuleWithFailedLookupLocations>> = createCacheWithRedirects();
         const nonRelativeModuleNameCache: CacheWithRedirects<PerModuleNameCache> = createCacheWithRedirects();
         const moduleResolutionCache = createModuleResolutionCacheWithMaps(
@@ -171,7 +171,7 @@ namespace ts {
             resolutionHost.getCanonicalFileName
         );
 
-        const resolvedTypeReferenceDirectives = createMap<Map<string, CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
+        const resolvedTypeReferenceDirectives = new Map<Path, Map<string, CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>>();
         const perDirectoryResolvedTypeReferenceDirectives: CacheWithRedirects<Map<string, CachedResolvedTypeReferenceDirectiveWithFailedLookupLocations>> = createCacheWithRedirects();
 
         /**
@@ -334,7 +334,7 @@ namespace ts {
             names: readonly string[];
             containingFile: string;
             redirectedReference: ResolvedProjectReference | undefined;
-            cache: Map<string, Map<string, T>>;
+            cache: Map<Path, Map<string, T>>;
             perDirectoryCacheWithRedirects: CacheWithRedirects<Map<string, T>>;
             loader: (name: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference) => T;
             getResolutionWithResolvedFileName: GetResolutionWithResolvedFileName<T, R>;
@@ -741,7 +741,7 @@ namespace ts {
             }
         }
 
-        function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap: ReadonlyMap<string, readonly string[]>) {
+        function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap: ReadonlyMap<Path, readonly string[]>) {
             Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined);
             filesWithInvalidatedNonRelativeUnresolvedImports = filesMap;
         }
diff --git a/src/compiler/sourcemap.ts b/src/compiler/sourcemap.ts
index 8cac9cde667cf..3e70d335566bb 100644
--- a/src/compiler/sourcemap.ts
+++ b/src/compiler/sourcemap.ts
@@ -622,7 +622,7 @@ namespace ts {
         const generatedAbsoluteFilePath = getNormalizedAbsolutePath(map.file, mapDirectory);
         const generatedFile = host.getSourceFileLike(generatedAbsoluteFilePath);
         const sourceFileAbsolutePaths = map.sources.map(source => getNormalizedAbsolutePath(source, sourceRoot));
-        const sourceToSourceIndexMap = createMapFromEntries(sourceFileAbsolutePaths.map((source, i) => [host.getCanonicalFileName(source), i] as [string, number]));
+        const sourceToSourceIndexMap = new Map(sourceFileAbsolutePaths.map((source, i) => [host.getCanonicalFileName(source), i]));
         let decodedMappings: readonly MappedPosition[] | undefined;
         let generatedMappings: SortedReadonlyArray<MappedPosition> | undefined;
         let sourceMappings: readonly SortedReadonlyArray<SourceMappedPosition>[] | undefined;
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index d096f7dd66358..083b3d368e530 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -474,8 +474,8 @@ namespace ts {
         }
 
         const cache = new Map<string, HostDirectoryWatcher>();
-        const callbackCache = createMultiMap<{ dirName: string; callback: DirectoryWatcherCallback; }>();
-        const cacheToUpdateChildWatches = new Map<string, { dirName: string; options: WatchOptions | undefined; fileNames: string[]; }>();
+        const callbackCache = createMultiMap<Path, { dirName: string; callback: DirectoryWatcherCallback; }>();
+        const cacheToUpdateChildWatches = new Map<Path, { dirName: string; options: WatchOptions | undefined; fileNames: string[]; }>();
         let timerToUpdateChildWatches: any;
 
         const filePathComparer = getStringComparer(!host.useCaseSensitiveFileNames);
@@ -538,7 +538,7 @@ namespace ts {
             };
         }
 
-        type InvokeMap = Map<string, string[] | true>;
+        type InvokeMap = Map<Path, string[] | true>;
         function invokeCallbacks(dirPath: Path, fileName: string): void;
         function invokeCallbacks(dirPath: Path, invokeMap: InvokeMap, fileNames: string[] | undefined): void;
         function invokeCallbacks(dirPath: Path, fileNameOrInvokeMap: string | InvokeMap, fileNames?: string[]) {
@@ -608,7 +608,7 @@ namespace ts {
             timerToUpdateChildWatches = undefined;
             sysLog(`sysLog:: onTimerToUpdateChildWatches:: ${cacheToUpdateChildWatches.size}`);
             const start = timestamp();
-            const invokeMap = new Map<string, string[]>();
+            const invokeMap = new Map<Path, string[]>();
 
             while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) {
                 const { value: [dirPath, { dirName, options, fileNames }], done } = cacheToUpdateChildWatches.entries().next();
@@ -617,7 +617,7 @@ namespace ts {
                 // Because the child refresh is fresh, we would need to invalidate whole root directory being watched
                 // to ensure that all the changes are reflected at this time
                 const hasChanges = updateChildWatches(dirName, dirPath as Path, options);
-                invokeCallbacks(dirPath as Path, invokeMap, hasChanges ? undefined : fileNames);
+                invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames);
             }
 
             sysLog(`sysLog:: invokingWatchers:: ${timestamp() - start}ms:: ${cacheToUpdateChildWatches.size}`);
diff --git a/src/compiler/tsbuildPublic.ts b/src/compiler/tsbuildPublic.ts
index fab6453ce73e3..a552c6f559c12 100644
--- a/src/compiler/tsbuildPublic.ts
+++ b/src/compiler/tsbuildPublic.ts
@@ -51,14 +51,8 @@ namespace ts {
 
     /*@internal*/
     export type ResolvedConfigFilePath = ResolvedConfigFileName & Path;
-    interface FileMap<T, U extends Path = Path> extends Map<U, T> {
-    }
-    type ConfigFileMap<T> = FileMap<T, ResolvedConfigFilePath>;
-    function createConfigFileMap<T>(): ConfigFileMap<T> {
-        return createMap() as ConfigFileMap<T>;
-    }
 
-    function getOrCreateValueFromConfigFileMap<T>(configFileMap: ConfigFileMap<T>, resolved: ResolvedConfigFilePath, createT: () => T): T {
+    function getOrCreateValueFromConfigFileMap<T>(configFileMap: Map<ResolvedConfigFilePath, T>, resolved: ResolvedConfigFilePath, createT: () => T): T {
         const existingValue = configFileMap.get(resolved);
         let newValue: T | undefined;
         if (!existingValue) {
@@ -68,7 +62,7 @@ namespace ts {
         return existingValue || newValue!;
     }
 
-    function getOrCreateValueMapFromConfigFileMap<T>(configFileMap: ConfigFileMap<Map<string, T>>, resolved: ResolvedConfigFilePath): Map<string, T> {
+    function getOrCreateValueMapFromConfigFileMap<T>(configFileMap: Map<ResolvedConfigFilePath, Map<string, T>>, resolved: ResolvedConfigFilePath): Map<string, T> {
         return getOrCreateValueFromConfigFileMap<Map<string, T>>(configFileMap, resolved, createMap);
     }
 
@@ -229,16 +223,16 @@ namespace ts {
         readonly baseWatchOptions: WatchOptions | undefined;
 
         readonly resolvedConfigFilePaths: Map<string, ResolvedConfigFilePath>;
-        readonly configFileCache: ConfigFileMap<ConfigFileCacheEntry>;
+        readonly configFileCache: Map<ResolvedConfigFilePath, ConfigFileCacheEntry>;
         /** Map from config file name to up-to-date status */
-        readonly projectStatus: ConfigFileMap<UpToDateStatus>;
-        readonly buildInfoChecked: ConfigFileMap<true>;
+        readonly projectStatus: Map<ResolvedConfigFilePath, UpToDateStatus>;
+        readonly buildInfoChecked: Map<ResolvedConfigFilePath, true>;
         readonly extendedConfigCache: Map<string, ExtendedConfigCacheEntry>;
 
-        readonly builderPrograms: ConfigFileMap<T>;
-        readonly diagnostics: ConfigFileMap<readonly Diagnostic[]>;
-        readonly projectPendingBuild: ConfigFileMap<ConfigFileProgramReloadLevel>;
-        readonly projectErrorsReported: ConfigFileMap<true>;
+        readonly builderPrograms: Map<ResolvedConfigFilePath, T>;
+        readonly diagnostics: Map<ResolvedConfigFilePath, readonly Diagnostic[]>;
+        readonly projectPendingBuild: Map<ResolvedConfigFilePath, ConfigFileProgramReloadLevel>;
+        readonly projectErrorsReported: Map<ResolvedConfigFilePath, true>;
 
         readonly compilerHost: CompilerHost;
         readonly moduleResolutionCache: ModuleResolutionCache | undefined;
@@ -255,9 +249,9 @@ namespace ts {
 
         // Watch state
         readonly watch: boolean;
-        readonly allWatchedWildcardDirectories: ConfigFileMap<Map<string, WildcardDirectoryWatcher>>;
-        readonly allWatchedInputFiles: ConfigFileMap<Map<string, FileWatcher>>;
-        readonly allWatchedConfigFiles: ConfigFileMap<FileWatcher>;
+        readonly allWatchedWildcardDirectories: Map<ResolvedConfigFilePath, Map<string, WildcardDirectoryWatcher>>;
+        readonly allWatchedInputFiles: Map<ResolvedConfigFilePath, Map<Path, FileWatcher>>;
+        readonly allWatchedConfigFiles: Map<ResolvedConfigFilePath, FileWatcher>;
 
         timerToBuildInvalidatedProject: any;
         reportFileChangeDetected: boolean;
@@ -303,16 +297,16 @@ namespace ts {
             rootNames,
             baseWatchOptions,
 
-            resolvedConfigFilePaths: createMap(),
-            configFileCache: createConfigFileMap(),
-            projectStatus: createConfigFileMap(),
-            buildInfoChecked: createConfigFileMap(),
-            extendedConfigCache: createMap(),
+            resolvedConfigFilePaths: new Map(),
+            configFileCache: new Map(),
+            projectStatus: new Map(),
+            buildInfoChecked: new Map(),
+            extendedConfigCache: new Map(),
 
-            builderPrograms: createConfigFileMap(),
-            diagnostics: createConfigFileMap(),
-            projectPendingBuild: createConfigFileMap(),
-            projectErrorsReported: createConfigFileMap(),
+            builderPrograms: new Map(),
+            diagnostics: new Map(),
+            projectPendingBuild: new Map(),
+            projectErrorsReported: new Map(),
 
             compilerHost,
             moduleResolutionCache,
@@ -329,9 +323,9 @@ namespace ts {
 
             // Watch state
             watch,
-            allWatchedWildcardDirectories: createConfigFileMap(),
-            allWatchedInputFiles: createConfigFileMap(),
-            allWatchedConfigFiles: createConfigFileMap(),
+            allWatchedWildcardDirectories: new Map(),
+            allWatchedInputFiles: new Map(),
+            allWatchedConfigFiles: new Map(),
 
             timerToBuildInvalidatedProject: undefined,
             reportFileChangeDetected: false,
@@ -390,8 +384,8 @@ namespace ts {
     }
 
     function createBuildOrder(state: SolutionBuilderState, roots: readonly ResolvedConfigFileName[]): AnyBuildOrder {
-        const temporaryMarks = createMap() as ConfigFileMap<true>;
-        const permanentMarks = createMap() as ConfigFileMap<true>;
+        const temporaryMarks = new Map() as Map<ResolvedConfigFilePath, true>;
+        const permanentMarks = new Map() as Map<ResolvedConfigFilePath, true>;
         const circularityReportStack: string[] = [];
         let buildOrder: ResolvedConfigFileName[] | undefined;
         let circularDiagnostics: Diagnostic[] | undefined;
@@ -448,7 +442,7 @@ namespace ts {
         const currentProjects = arrayToSet(
             getBuildOrderFromAnyBuildOrder(buildOrder),
             resolved => toResolvedConfigFilePath(state, resolved)
-        ) as ConfigFileMap<true>;
+        ) as Map<ResolvedConfigFilePath, true>;
 
         const noopOnDelete = { onDeleteValue: noop };
         // Config file cache
@@ -930,7 +924,7 @@ namespace ts {
             let newestDeclarationFileContentChangedTime = minimumDate;
             let anyDtsChanged = false;
             const emitterDiagnostics = createDiagnosticCollection();
-            const emittedOutputs = createMap() as FileMap<string>;
+            const emittedOutputs = new Map() as Map<Path, string>;
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
                 let priorChangeTime: Date | undefined;
                 if (!anyDtsChanged && isDeclarationFile(name)) {
@@ -982,7 +976,7 @@ namespace ts {
 
         function finishEmit(
             emitterDiagnostics: DiagnosticCollection,
-            emittedOutputs: FileMap<string>,
+            emittedOutputs: Map<Path, string>,
             priorNewestUpdateTime: Date,
             newestDeclarationFileContentChangedTimeIsMaximumDate: boolean,
             oldestOutputFileName: string,
@@ -1063,7 +1057,7 @@ namespace ts {
             // Actual Emit
             Debug.assert(!!outputFiles.length);
             const emitterDiagnostics = createDiagnosticCollection();
-            const emittedOutputs = createMap() as FileMap<string>;
+            const emittedOutputs = new Map() as Map<Path, string>;
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
                 emittedOutputs.set(toPath(state, name), name);
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
@@ -1550,7 +1544,7 @@ namespace ts {
         return actual;
     }
 
-    function updateOutputTimestampsWorker(state: SolutionBuilderState, proj: ParsedCommandLine, priorNewestUpdateTime: Date, verboseMessage: DiagnosticMessage, skipOutputs?: FileMap<string>) {
+    function updateOutputTimestampsWorker(state: SolutionBuilderState, proj: ParsedCommandLine, priorNewestUpdateTime: Date, verboseMessage: DiagnosticMessage, skipOutputs?: Map<Path, string>) {
         const { host } = state;
         const outputs = getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 1566d4b2d6523..c70b9d05fe640 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -3682,7 +3682,7 @@ namespace ts {
         /* @internal */
         getMissingFilePaths(): readonly Path[];
         /* @internal */
-        getRefFileMap(): MultiMap<string, RefFile> | undefined;
+        getRefFileMap(): MultiMap<Path, RefFile> | undefined;
         /* @internal */
         getFilesByNameMap(): Map<string, SourceFile | false | undefined>;
 
@@ -4590,7 +4590,7 @@ namespace ts {
         /* @internal */ isReferenced?: SymbolFlags; // True if the symbol is referenced elsewhere. Keeps track of the meaning of a reference in case a symbol is both a type parameter and parameter.
         /* @internal */ isReplaceableByMethod?: boolean; // Can this Javascript class property be replaced by a method symbol?
         /* @internal */ isAssigned?: boolean;   // True if the symbol is a parameter with assignments
-        /* @internal */ assignmentDeclarationMembers?: Map<string, Declaration>; // detected late-bound assignment declarations associated with the symbol
+        /* @internal */ assignmentDeclarationMembers?: Map<number, Declaration>; // detected late-bound assignment declarations associated with the symbol
     }
 
     /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index b2306437107f0..7a0b36517d8e7 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -466,7 +466,7 @@ namespace ts {
     }
 
     export function createCommentDirectivesMap(sourceFile: SourceFile, commentDirectives: CommentDirective[]): CommentDirectivesMap {
-        const directivesByLine = createMapFromEntries(
+        const directivesByLine = new Map(
             commentDirectives.map(commentDirective => ([
                 `${getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line}`,
                 commentDirective,
diff --git a/src/compiler/watchPublic.ts b/src/compiler/watchPublic.ts
index 4083b0fa90673..55ab2cba5961b 100644
--- a/src/compiler/watchPublic.ts
+++ b/src/compiler/watchPublic.ts
@@ -246,8 +246,8 @@ namespace ts {
 
         let builderProgram: T;
         let reloadLevel: ConfigFileProgramReloadLevel;                      // level to indicate if the program needs to be reloaded from config file/just filenames etc
-        let missingFilesMap: Map<string, FileWatcher>;                              // Map of file watchers for the missing files
-        let watchedWildcardDirectories: Map<string, WildcardDirectoryWatcher>;      // map of watchers for the wild card directories in the config file
+        let missingFilesMap: Map<Path, FileWatcher>;                        // Map of file watchers for the missing files
+        let watchedWildcardDirectories: Map<string, WildcardDirectoryWatcher>; // map of watchers for the wild card directories in the config file
         let timerToUpdateProgram: any;                                      // timer callback to recompile the program
         let timerToInvalidateFailedLookupResolutions: any;                  // timer callback to invalidate resolutions for changes in failed lookup locations
 
@@ -419,7 +419,7 @@ namespace ts {
             resolutionCache.finishCachingPerDirectoryResolution();
 
             // Update watches
-            updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = createMap()), watchMissingFilePath);
+            updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new Map()), watchMissingFilePath);
             if (needsUpdateInTypeRootWatch) {
                 resolutionCache.updateTypeRootsWatch();
             }
diff --git a/src/compiler/watchUtilities.ts b/src/compiler/watchUtilities.ts
index cb5508718c9d0..f6fd12e29e5a8 100644
--- a/src/compiler/watchUtilities.ts
+++ b/src/compiler/watchUtilities.ts
@@ -262,7 +262,7 @@ namespace ts {
      */
     export function updateMissingFilePathsWatch(
         program: Program,
-        missingFileWatches: Map<string, FileWatcher>,
+        missingFileWatches: Map<Path, FileWatcher>,
         createMissingFileWatch: (missingFilePath: Path) => FileWatcher,
     ) {
         const missingFilePaths = program.getMissingFilePaths();
diff --git a/src/harness/virtualFileSystemWithWatch.ts b/src/harness/virtualFileSystemWithWatch.ts
index e9a2adc1148b2..57f3816fe7499 100644
--- a/src/harness/virtualFileSystemWithWatch.ts
+++ b/src/harness/virtualFileSystemWithWatch.ts
@@ -122,7 +122,7 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
     }
 
-    function createWatcher<T>(map: MultiMap<string, T>, path: string, callback: T): FileWatcher {
+    function createWatcher<T>(map: MultiMap<Path, T>, path: Path, callback: T): FileWatcher {
         map.add(path, callback);
         return { close: () => map.remove(path, callback) };
     }
@@ -376,7 +376,7 @@ interface Array<T> { length: number; [n: number]: T; }`
 
         private readonly output: string[] = [];
 
-        private fs: Map<string, FSEntry> = createMap<FSEntry>();
+        private fs: Map<Path, FSEntry> = new Map();
         private time = timeIncrements;
         getCanonicalFileName: (s: string) => string;
         private toPath: (f: string) => Path;
@@ -384,9 +384,9 @@ interface Array<T> { length: number; [n: number]: T; }`
         private immediateCallbacks = new Callbacks();
         readonly screenClears: number[] = [];
 
-        readonly watchedFiles = createMultiMap<TestFileWatcher>();
-        readonly fsWatches = createMultiMap<TestFsWatcher>();
-        readonly fsWatchesRecursive = createMultiMap<TestFsWatcher>();
+        readonly watchedFiles = createMultiMap<Path, TestFileWatcher>();
+        readonly fsWatches = createMultiMap<Path, TestFsWatcher>();
+        readonly fsWatchesRecursive = createMultiMap<Path, TestFsWatcher>();
         runWithFallbackPolling: boolean;
         public readonly useCaseSensitiveFileNames: boolean;
         public readonly newLine: string;
@@ -1042,8 +1042,8 @@ interface Array<T> { length: number; [n: number]: T; }`
             this.clearOutput();
         }
 
-        snap(): Map<string, FSEntry> {
-            const result = new Map<string, FSEntry>();
+        snap(): Map<Path, FSEntry> {
+            const result = new Map<Path, FSEntry>();
             this.fs.forEach((value, key) => {
                 const cloneValue = clone(value);
                 if (isFsFolder(cloneValue)) {
@@ -1055,7 +1055,7 @@ interface Array<T> { length: number; [n: number]: T; }`
             return result;
         }
 
-        writtenFiles?: Map<string, number>;
+        writtenFiles?: Map<Path, number>;
         diff(baseline: string[], base: Map<string, FSEntry> = new Map()) {
             this.fs.forEach(newFsEntry => {
                 diffFsEntry(baseline, base.get(newFsEntry.path), newFsEntry, this.writtenFiles);
@@ -1208,12 +1208,12 @@ interface Array<T> { length: number; [n: number]: T; }`
         }
     }
 
-    export type TestServerHostTrackingWrittenFiles = TestServerHost & { writtenFiles: Map<string, number>; };
+    export type TestServerHostTrackingWrittenFiles = TestServerHost & { writtenFiles: Map<Path, number>; };
 
     export function changeToHostTrackingWrittenFiles(inputHost: TestServerHost) {
         const host = inputHost as TestServerHostTrackingWrittenFiles;
         const originalWriteFile = host.writeFile;
-        host.writtenFiles = createMap<number>();
+        host.writtenFiles = new Map<Path, number>();
         host.writeFile = (fileName, content) => {
             originalWriteFile.call(host, fileName, content);
             const path = host.toFullPath(fileName);
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 98460aa42b079..794274cb9cea8 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -379,7 +379,7 @@ namespace ts.server {
          * It is false when the open file that would still be impacted by existence of
          *   this config file but it is not the root of inferred project
          */
-        openFilesImpactedByConfigFile: Map<string, boolean>;
+        openFilesImpactedByConfigFile: Map<Path, boolean>;
         /**
          * The file watcher watching the config file because there is open script info that is root of
          * inferred project and will be impacted by change in the status of the config file
@@ -592,7 +592,7 @@ namespace ts.server {
          * Map to the real path of the infos
          */
         /* @internal */
-        readonly realpathToScriptInfos: MultiMap<string, ScriptInfo> | undefined;
+        readonly realpathToScriptInfos: MultiMap<Path, ScriptInfo> | undefined;
         /**
          * maps external project file name to list of config files that were the part of this project
          */
@@ -613,7 +613,7 @@ namespace ts.server {
         /**
          * Open files: with value being project root path, and key being Path of the file that is open
          */
-        readonly openFiles = createMap<NormalizedPath | undefined>();
+        readonly openFiles = new Map<Path, NormalizedPath | undefined>();
         /**
          * Map of open files that are opened without complete path but have projectRoot as current directory
          */
@@ -1119,9 +1119,9 @@ namespace ts.server {
             }
         }
 
-        private delayUpdateSourceInfoProjects(sourceInfos: Set<string> | undefined) {
+        private delayUpdateSourceInfoProjects(sourceInfos: Set<Path> | undefined) {
             if (sourceInfos) {
-                sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path as Path));
+                sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path));
             }
         }
 
@@ -1491,7 +1491,7 @@ namespace ts.server {
 
             // Cache the host value of file exists and add the info to map of open files impacted by this config file
             const exists = this.host.fileExists(configFileName);
-            const openFilesImpactedByConfigFile = createMap<boolean>();
+            const openFilesImpactedByConfigFile = new Map<Path, boolean>();
             if (isOpenScriptInfo(info)) {
                 openFilesImpactedByConfigFile.set(info.path, false);
             }
@@ -1519,7 +1519,7 @@ namespace ts.server {
                 // Since that route doesnt check if the config file is present or not
                 this.configFileExistenceInfoCache.set(project.canonicalConfigFilePath, {
                     exists: true,
-                    openFilesImpactedByConfigFile: createMap<boolean>()
+                    openFilesImpactedByConfigFile: new Map<Path, boolean>()
                 });
             }
         }
@@ -1655,7 +1655,7 @@ namespace ts.server {
                     // Create the cache
                     configFileExistenceInfo = {
                         exists: this.host.fileExists(configFileName),
-                        openFilesImpactedByConfigFile: createMap<boolean>()
+                        openFilesImpactedByConfigFile: new Map<Path, boolean>()
                     };
                     this.configFileExistenceInfoCache.set(canonicalConfigFilePath, configFileExistenceInfo);
                 }
@@ -2296,8 +2296,8 @@ namespace ts.server {
          * Note that this does not return projects in info.containingProjects
          */
         /*@internal*/
-        getSymlinkedProjects(info: ScriptInfo): MultiMap<string, Project> | undefined {
-            let projects: MultiMap<string, Project> | undefined;
+        getSymlinkedProjects(info: ScriptInfo): MultiMap<Path, Project> | undefined {
+            let projects: MultiMap<Path, Project> | undefined;
             if (this.realpathToScriptInfos) {
                 const realpath = info.getRealpathIfDifferent();
                 if (realpath) {
@@ -2592,7 +2592,7 @@ namespace ts.server {
             return documentPositionMapper;
         }
 
-        private addSourceInfoToSourceMap(sourceFileName: string | undefined, project: Project, sourceInfos?: Set<string>) {
+        private addSourceInfoToSourceMap(sourceFileName: string | undefined, project: Project, sourceInfos?: Set<Path>) {
             if (sourceFileName) {
                 // Attach as source
                 const sourceInfo = this.getOrCreateScriptInfoNotOpenedByClient(sourceFileName, project.currentDirectory, project.directoryStructureHost)!;
@@ -2761,7 +2761,7 @@ namespace ts.server {
          * If the there is no existing project it just opens the configured project for the config file
          * reloadForInfo provides a way to filter out files to reload configured project for
          */
-        private reloadConfiguredProjectForFiles<T>(openFiles: Map<string, T>, delayReload: boolean, shouldReloadProjectFor: (openFileValue: T) => boolean, reason: string) {
+        private reloadConfiguredProjectForFiles<T>(openFiles: Map<Path, T>, delayReload: boolean, shouldReloadProjectFor: (openFileValue: T) => boolean, reason: string) {
             const updatedProjects = createMap<true>();
             // try to reload config file for all open files
             openFiles.forEach((openFileValue, path) => {
@@ -3081,7 +3081,7 @@ namespace ts.server {
                 (key, project) => !project.isInitialLoadPending() ? [key, true] : undefined
             );
 
-            const seenProjects = new Set<string>();
+            const seenProjects = new Set<NormalizedPath>();
             // Work on array copy as we could add more projects as part of callback
             for (const project of arrayFrom(this.configuredProjects.values())) {
                 // If this project has potential project reference for any of the project we are loading ancestor tree for
@@ -3099,7 +3099,7 @@ namespace ts.server {
             }
         }
 
-        private ensureProjectChildren(project: ConfiguredProject, seenProjects: Set<string>) {
+        private ensureProjectChildren(project: ConfiguredProject, seenProjects: Set<NormalizedPath>) {
             if (!tryAddToSet(seenProjects, project.canonicalConfigFilePath)) return;
             // Update the project
             updateProjectIfDirty(project);
@@ -3204,7 +3204,7 @@ namespace ts.server {
                 if (!info.isScriptOpen() && info.isOrphan()) {
                     // Otherwise if there is any source info that is alive, this alive too
                     if (!info.sourceMapFilePath) return;
-                    let sourceInfos: Set<string> | undefined;
+                    let sourceInfos: Set<Path> | undefined;
                     if (isString(info.sourceMapFilePath)) {
                         const sourceMapInfo = this.getScriptInfoForPath(info.sourceMapFilePath);
                         sourceInfos = sourceMapInfo && sourceMapInfo.sourceInfos;
@@ -3224,7 +3224,7 @@ namespace ts.server {
                 // Retain this script info
                 toRemoveScriptInfos.delete(info.path);
                 if (info.sourceMapFilePath) {
-                    let sourceInfos: Set<string> | undefined;
+                    let sourceInfos: Set<Path> | undefined;
                     if (isString(info.sourceMapFilePath)) {
                         // And map file info and source infos
                         toRemoveScriptInfos.delete(info.sourceMapFilePath);
diff --git a/src/server/project.ts b/src/server/project.ts
index 9efa434e7baf1..642607807d711 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -113,7 +113,7 @@ namespace ts.server {
         generatedFilePath: Path;
         watcher: FileWatcher;
     }
-    type GeneratedFileWatcherMap = GeneratedFileWatcher | Map<string, GeneratedFileWatcher>;
+    type GeneratedFileWatcherMap = GeneratedFileWatcher | Map<Path, GeneratedFileWatcher>;
     function isGeneratedFileWatcher(watch: GeneratedFileWatcherMap): watch is GeneratedFileWatcher {
         return (watch as GeneratedFileWatcher).generatedFilePath !== undefined;
     }
@@ -129,12 +129,12 @@ namespace ts.server {
         private rootFilesMap = createMap<ProjectRootFile>();
         private program: Program | undefined;
         private externalFiles: SortedReadonlyArray<string> | undefined;
-        private missingFilesMap: Map<string, FileWatcher> | undefined;
+        private missingFilesMap: Map<Path, FileWatcher> | undefined;
         private generatedFilesMap: GeneratedFileWatcherMap | undefined;
         private plugins: PluginModuleWithName[] = [];
 
         /*@internal*/
-        private packageJsonFilesMap: Map<string, FileWatcher> | undefined;
+        private packageJsonFilesMap: Map<Path, FileWatcher> | undefined;
 
         /*@internal*/
         /**
@@ -142,7 +142,7 @@ namespace ts.server {
          * Maop does not contain entries for files that do not have unresolved imports
          * This helps in containing the set of files to invalidate
          */
-        cachedUnresolvedImportsPerFile = createMap<readonly string[]>();
+        cachedUnresolvedImportsPerFile = new Map<Path, readonly string[]>();
 
         /*@internal*/
         lastCachedUnresolvedImportsList: SortedReadonlyArray<string> | undefined;
@@ -200,7 +200,7 @@ namespace ts.server {
         typingFiles: SortedReadonlyArray<string> = emptyArray;
 
         /*@internal*/
-        originalConfiguredProjects: Set<string> | undefined;
+        originalConfiguredProjects: Set<NormalizedPath> | undefined;
 
         /*@internal*/
         getResolvedProjectReferenceToRedirect(_fileName: string): ResolvedProjectReference | undefined {
@@ -246,7 +246,7 @@ namespace ts.server {
         /*@internal*/
         private importSuggestionsCache = Completions.createImportSuggestionsForFileCache();
         /*@internal*/
-        private dirtyFilesForSuggestions: Set<string> | undefined;
+        private dirtyFilesForSuggestions: Set<Path> | undefined;
         /*@internal*/
         private symlinks: ReadonlyMap<string, string> | undefined;
 
@@ -1055,7 +1055,7 @@ namespace ts.server {
                 // Update the missing file paths watcher
                 updateMissingFilePathsWatch(
                     this.program,
-                    this.missingFilesMap || (this.missingFilesMap = createMap()),
+                    this.missingFilesMap ??= new Map(),
                     // Watch the missing files
                     missingFilePath => this.addMissingFileWatcher(missingFilePath)
                 );
@@ -1638,12 +1638,12 @@ namespace ts.server {
         }
     }
 
-    function getUnresolvedImports(program: Program, cachedUnresolvedImportsPerFile: Map<string, readonly string[]>): SortedReadonlyArray<string> {
+    function getUnresolvedImports(program: Program, cachedUnresolvedImportsPerFile: Map<Path, readonly string[]>): SortedReadonlyArray<string> {
         const ambientModules = program.getTypeChecker().getAmbientModules().map(mod => stripQuotes(mod.getName()));
         return sortAndDeduplicate(flatMap(program.getSourceFiles(), sourceFile =>
             extractUnresolvedImportsFromSourceFile(sourceFile, ambientModules, cachedUnresolvedImportsPerFile)));
     }
-    function extractUnresolvedImportsFromSourceFile(file: SourceFile, ambientModules: readonly string[], cachedUnresolvedImportsPerFile: Map<string, readonly string[]>): readonly string[] {
+    function extractUnresolvedImportsFromSourceFile(file: SourceFile, ambientModules: readonly string[], cachedUnresolvedImportsPerFile: Map<Path, readonly string[]>): readonly string[] {
         return getOrUpdate(cachedUnresolvedImportsPerFile, file.path, () => {
             if (!file.resolvedModules) return emptyArray;
             let unresolvedImports: string[] | undefined;
diff --git a/src/server/scriptInfo.ts b/src/server/scriptInfo.ts
index 0b0c5f409b816..1cd615d2a27ca 100644
--- a/src/server/scriptInfo.ts
+++ b/src/server/scriptInfo.ts
@@ -286,7 +286,7 @@ namespace ts.server {
     /*@internal*/
     export interface SourceMapFileWatcher {
         watcher: FileWatcher;
-        sourceInfos?: Set<string>;
+        sourceInfos?: Set<Path>;
     }
 
     export class ScriptInfo {
@@ -324,7 +324,7 @@ namespace ts.server {
         /*@internal*/
         declarationInfoPath?: Path;
         /*@internal*/
-        sourceInfos?: Set<string>;
+        sourceInfos?: Set<Path>;
         /*@internal*/
         documentPositionMapper?: DocumentPositionMapper | false;
 
diff --git a/src/server/session.ts b/src/server/session.ts
index d92ea4c9c9f4e..bdc4eb02805b8 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -262,7 +262,7 @@ namespace ts.server {
 
     type Projects = readonly Project[] | {
         readonly projects: readonly Project[];
-        readonly symLinkedProjects: MultiMap<string, Project>;
+        readonly symLinkedProjects: MultiMap<Path, Project>;
     };
 
     /**
@@ -517,7 +517,7 @@ namespace ts.server {
             if (symlinkedProjectsMap) {
                 symlinkedProjectsMap.forEach((symlinkedProjects, symlinkedPath) => {
                     for (const symlinkedProject of symlinkedProjects) {
-                        addToTodo(symlinkedProject, { fileName: symlinkedPath, pos: originalLocation.pos } as TLocation, toDo!, seenProjects);
+                        addToTodo(symlinkedProject, { fileName: symlinkedPath as string, pos: originalLocation.pos } as TLocation, toDo!, seenProjects);
                     }
                 });
             }
@@ -1355,7 +1355,7 @@ namespace ts.server {
 
         private getProjects(args: protocol.FileRequestArgs, getScriptInfoEnsuringProjectsUptoDate?: boolean, ignoreNoProjectError?: boolean): Projects {
             let projects: readonly Project[] | undefined;
-            let symLinkedProjects: MultiMap<string, Project> | undefined;
+            let symLinkedProjects: MultiMap<Path, Project> | undefined;
             if (args.projectFileName) {
                 const project = this.getProject(args.projectFileName);
                 if (project) {
diff --git a/src/services/documentRegistry.ts b/src/services/documentRegistry.ts
index 1f299cdc00043..2e97689bfbf9a 100644
--- a/src/services/documentRegistry.ts
+++ b/src/services/documentRegistry.ts
@@ -118,7 +118,7 @@ namespace ts {
     export function createDocumentRegistryInternal(useCaseSensitiveFileNames?: boolean, currentDirectory = "", externalCache?: ExternalDocumentCache): DocumentRegistry {
         // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have
         // for those settings.
-        const buckets = createMap<Map<string, DocumentRegistryEntry>>();
+        const buckets = new Map<string, Map<Path, DocumentRegistryEntry>>();
         const getCanonicalFileName = createGetCanonicalFileName(!!useCaseSensitiveFileNames);
 
         function reportStats() {
@@ -170,7 +170,7 @@ namespace ts {
             acquiring: boolean,
             scriptKind?: ScriptKind): SourceFile {
 
-            const bucket = getOrUpdate<Map<string, DocumentRegistryEntry>>(buckets, key, createMap);
+            const bucket = getOrUpdate<Map<Path, DocumentRegistryEntry>>(buckets, key, createMap);
             let entry = bucket.get(path);
             const scriptTarget = scriptKind === ScriptKind.JSON ? ScriptTarget.JSON : compilationSettings.target || ScriptTarget.ES5;
             if (!entry && externalCache) {
diff --git a/src/services/services.ts b/src/services/services.ts
index 40a7095e822e2..6ee3c7a7e10f0 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -937,14 +937,14 @@ namespace ts {
     // at each language service public entry point, since we don't know when
     // the set of scripts handled by the host changes.
     class HostCache {
-        private fileNameToEntry: Map<string, CachedHostFileInformation>;
+        private fileNameToEntry: Map<Path, CachedHostFileInformation>;
         private _compilationSettings: CompilerOptions;
         private currentDirectory: string;
 
         constructor(private host: LanguageServiceHost, getCanonicalFileName: GetCanonicalFileName) {
             // script id => script index
             this.currentDirectory = host.getCurrentDirectory();
-            this.fileNameToEntry = createMap<CachedHostFileInformation>();
+            this.fileNameToEntry = new Map();
 
             // Initialize the list with the root file names
             const rootFileNames = host.getScriptFileNames();
diff --git a/src/testRunner/unittests/tscWatch/incremental.ts b/src/testRunner/unittests/tscWatch/incremental.ts
index d7737b9bd5776..f4b7fa13ed413 100644
--- a/src/testRunner/unittests/tscWatch/incremental.ts
+++ b/src/testRunner/unittests/tscWatch/incremental.ts
@@ -157,17 +157,17 @@ namespace ts.tscWatch {
                     assert.equal(state.changedFilesSet!.size, 0, "changes");
 
                     assert.equal(state.fileInfos.size, 3, "FileInfo size");
-                    assert.deepEqual(state.fileInfos.get(libFile.path), {
+                    assert.deepEqual(state.fileInfos.get(libFile.path as Path), {
                         version: system.createHash(libFile.content),
                         signature: system.createHash(libFile.content),
                         affectsGlobalScope: true,
                     });
-                    assert.deepEqual(state.fileInfos.get(file1.path), {
+                    assert.deepEqual(state.fileInfos.get(file1.path as Path), {
                         version: system.createHash(file1.content),
                         signature: system.createHash(`${file1.content.replace("export ", "export declare ")}\n`),
                         affectsGlobalScope: false,
                     });
-                    assert.deepEqual(state.fileInfos.get(file2.path), {
+                    assert.deepEqual(state.fileInfos.get(file2.path as Path), {
                         version: system.createHash(fileModified.content),
                         signature: system.createHash("export declare const y: string;\n"),
                         affectsGlobalScope: false,
@@ -183,9 +183,9 @@ namespace ts.tscWatch {
                     assert.equal(state.exportedModulesMap!.size, 0);
 
                     assert.equal(state.semanticDiagnosticsPerFile!.size, 3);
-                    assert.deepEqual(state.semanticDiagnosticsPerFile!.get(libFile.path), emptyArray);
-                    assert.deepEqual(state.semanticDiagnosticsPerFile!.get(file1.path), emptyArray);
-                    assert.deepEqual(state.semanticDiagnosticsPerFile!.get(file2.path), [{
+                    assert.deepEqual(state.semanticDiagnosticsPerFile!.get(libFile.path as Path), emptyArray);
+                    assert.deepEqual(state.semanticDiagnosticsPerFile!.get(file1.path as Path), emptyArray);
+                    assert.deepEqual(state.semanticDiagnosticsPerFile!.get(file2.path as Path), [{
                         file: state.program!.getSourceFileByPath(file2.path as Path)!,
                         start: 13,
                         length: 1,
diff --git a/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts b/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts
index e4301b3c271f7..55847f2e22837 100644
--- a/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts
+++ b/src/testRunner/unittests/tsserver/projectReferenceCompileOnSave.ts
@@ -58,7 +58,7 @@ fn2();
                         arguments: { file: dependencyTs.path }
                     });
                     const { file, insertString } = change();
-                    if (session.getProjectService().openFiles.has(file.path)) {
+                    if (session.getProjectService().openFiles.has(file.path as Path)) {
                         const toLocation = protocolToLocation(file.content);
                         const location = toLocation(file.content.length);
                         session.executeCommandSeq<protocol.ChangeRequest>({
@@ -95,7 +95,7 @@ fn2();
                 assert.equal(host.writtenFiles.size, expectedFiles.length);
                 for (const file of expectedFiles) {
                     assert.equal(host.readFile(file.path), file.content, `Expected to write ${file.path}`);
-                    assert.isTrue(host.writtenFiles.has(file.path), `${file.path} is newly written`);
+                    assert.isTrue(host.writtenFiles.has(file.path as Path), `${file.path} is newly written`);
                 }
 
                 // Verify EmitOutput
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index f9eb40340cbf5..dfccd7d640786 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -9436,7 +9436,7 @@ declare namespace ts.server {
         /**
          * Open files: with value being project root path, and key being Path of the file that is open
          */
-        readonly openFiles: Map<string, NormalizedPath | undefined>;
+        readonly openFiles: Map<Path, NormalizedPath | undefined>;
         /**
          * Map of open files that are opened without complete path but have projectRoot as current directory
          */

From 92626a60fc3360b5fde36d1fde2623e27764d082 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Mon, 22 Jun 2020 18:53:38 -0700
Subject: [PATCH 07/10] Fix lint issues

---
 src/compiler/binder.ts                       |  2 +-
 src/compiler/builder.ts                      | 28 ++++++++++----------
 src/compiler/builderState.ts                 |  6 ++---
 src/compiler/program.ts                      |  4 +--
 src/compiler/sys.ts                          |  2 +-
 src/compiler/tsbuildPublic.ts                |  8 +++---
 src/server/editorServices.ts                 | 14 +++++-----
 src/server/project.ts                        |  8 +++---
 src/server/session.ts                        |  2 +-
 src/testRunner/unittests/tsserver/helpers.ts |  2 +-
 10 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 97e7d65dcfaae..a55ac9a385aba 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -2865,7 +2865,7 @@ namespace ts {
 
         function addLateBoundAssignmentDeclarationToSymbol(node: BinaryExpression | DynamicNamedDeclaration, symbol: Symbol | undefined) {
             if (symbol) {
-                (symbol.assignmentDeclarationMembers ??= new Map()).set(getNodeId(node), node);
+                (symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = new Map())).set(getNodeId(node), node);
             }
         }
 
diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
index a821fb2227f34..ea92c99c5172f 100644
--- a/src/compiler/builder.ts
+++ b/src/compiler/builder.ts
@@ -228,7 +228,7 @@ namespace ts {
                 state.changedFilesSet.add(sourceFilePath);
             }
             else if (canCopySemanticDiagnostics) {
-                const sourceFile = newProgram.getSourceFileByPath(sourceFilePath as Path)!;
+                const sourceFile = newProgram.getSourceFileByPath(sourceFilePath)!;
 
                 if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics) { return; }
                 if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics) { return; }
@@ -382,14 +382,14 @@ namespace ts {
             }
 
             // Get next batch of affected files
-            state.currentAffectedFilesSignatures ??= new Map();
+            if (!state.currentAffectedFilesSignatures) state.currentAffectedFilesSignatures = new Map();
             if (state.exportedModulesMap) {
-                state.currentAffectedFilesExportedModulesMap ??= new Map();
+                if (!state.currentAffectedFilesExportedModulesMap) state.currentAffectedFilesExportedModulesMap = new Map();
             }
             state.affectedFiles = BuilderState.getFilesAffectedBy(state, program, nextKey.value, cancellationToken, computeHash, state.currentAffectedFilesSignatures, state.currentAffectedFilesExportedModulesMap);
             state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
-            state.seenAffectedFiles ??= new Set();
+            if (!state.seenAffectedFiles) state.seenAffectedFiles = new Set();
         }
     }
 
@@ -399,7 +399,7 @@ namespace ts {
     function getNextAffectedFilePendingEmit(state: BuilderProgramState) {
         const { affectedFilesPendingEmit } = state;
         if (affectedFilesPendingEmit) {
-            const seenEmittedFiles = (state.seenEmittedFiles ??= new Map());
+            const seenEmittedFiles = (state.seenEmittedFiles || (state.seenEmittedFiles = new Map()));
             for (let i = state.affectedFilesPendingEmitIndex!; i < affectedFilesPendingEmit.length; i++) {
                 const affectedFile = Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]);
                 if (affectedFile) {
@@ -537,7 +537,7 @@ namespace ts {
         if (forEachEntry(state.currentAffectedFilesExportedModulesMap, (exportedModules, exportedFromPath) =>
             exportedModules &&
             exportedModules.has(affectedFile.resolvedPath) &&
-            forEachFilesReferencingPath(state, exportedFromPath as Path, seenFileAndExportsOfFile, fn)
+            forEachFilesReferencingPath(state, exportedFromPath, seenFileAndExportsOfFile, fn)
         )) {
             return;
         }
@@ -546,7 +546,7 @@ namespace ts {
         forEachEntry(state.exportedModulesMap, (exportedModules, exportedFromPath) =>
             !state.currentAffectedFilesExportedModulesMap!.has(exportedFromPath) && // If we already iterated this through cache, ignore it
             exportedModules.has(affectedFile.resolvedPath) &&
-            forEachFilesReferencingPath(state, exportedFromPath as Path, seenFileAndExportsOfFile, fn)
+            forEachFilesReferencingPath(state, exportedFromPath, seenFileAndExportsOfFile, fn)
         );
     }
 
@@ -555,7 +555,7 @@ namespace ts {
      */
     function forEachFilesReferencingPath(state: BuilderProgramState, referencedPath: Path, seenFileAndExportsOfFile: Set<string>, fn: (state: BuilderProgramState, filePath: Path) => boolean) {
         return forEachEntry(state.referencedMap!, (referencesInFile, filePath) =>
-            referencesInFile.has(referencedPath) && forEachFileAndExportsOfFile(state, filePath as Path, seenFileAndExportsOfFile, fn)
+            referencesInFile.has(referencedPath) && forEachFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, fn)
         );
     }
 
@@ -578,7 +578,7 @@ namespace ts {
         if (forEachEntry(state.currentAffectedFilesExportedModulesMap, (exportedModules, exportedFromPath) =>
             exportedModules &&
             exportedModules.has(filePath) &&
-            forEachFileAndExportsOfFile(state, exportedFromPath as Path, seenFileAndExportsOfFile, fn)
+            forEachFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, fn)
         )) {
             return true;
         }
@@ -587,7 +587,7 @@ namespace ts {
         if (forEachEntry(state.exportedModulesMap!, (exportedModules, exportedFromPath) =>
             !state.currentAffectedFilesExportedModulesMap!.has(exportedFromPath) && // If we already iterated this through cache, ignore it
             exportedModules.has(filePath) &&
-            forEachFileAndExportsOfFile(state, exportedFromPath as Path, seenFileAndExportsOfFile, fn)
+            forEachFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, fn)
         )) {
             return true;
         }
@@ -596,7 +596,7 @@ namespace ts {
         return !!forEachEntry(state.referencedMap!, (referencesInFile, referencingFilePath) =>
             referencesInFile.has(filePath) &&
             !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
-            fn(state, referencingFilePath as Path) // Dont add to seen since this is not yet done with the export removal
+            fn(state, referencingFilePath) // Dont add to seen since this is not yet done with the export removal
         );
     }
 
@@ -622,7 +622,7 @@ namespace ts {
         else {
             state.seenAffectedFiles!.add((affected as SourceFile).resolvedPath);
             if (emitKind !== undefined) {
-                (state.seenEmittedFiles ??= new Map()).set((affected as SourceFile).resolvedPath, emitKind);
+                (state.seenEmittedFiles || (state.seenEmittedFiles = new Map())).set((affected as SourceFile).resolvedPath, emitKind);
             }
             if (isPendingEmit) {
                 state.affectedFilesPendingEmitIndex!++;
@@ -1124,8 +1124,8 @@ namespace ts {
     }
 
     function addToAffectedFilesPendingEmit(state: BuilderProgramState, affectedFilePendingEmit: Path, kind: BuilderFileEmit) {
-        state.affectedFilesPendingEmit ??= [];
-        state.affectedFilesPendingEmitKind ??= new Map();
+        if (!state.affectedFilesPendingEmit) state.affectedFilesPendingEmit = [];
+        if (!state.affectedFilesPendingEmitKind) state.affectedFilesPendingEmitKind = new Map();
 
         const existingKind = state.affectedFilesPendingEmitKind.get(affectedFilePendingEmit);
         state.affectedFilesPendingEmit.push(affectedFilePendingEmit);
diff --git a/src/compiler/builderState.ts b/src/compiler/builderState.ts
index b3a2de59063cf..311f92ceabe12 100644
--- a/src/compiler/builderState.ts
+++ b/src/compiler/builderState.ts
@@ -185,7 +185,7 @@ namespace ts {
             }
 
             function addReferencedFile(referencedPath: Path) {
-                (referencedFiles ??= new Set()).add(referencedPath);
+                (referencedFiles || (referencedFiles = new Set())).add(referencedPath);
             }
         }
 
@@ -416,7 +416,7 @@ namespace ts {
                     if (references) {
                         const iterator = references.keys();
                         for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {
-                            queue.push(iterResult.value as Path);
+                            queue.push(iterResult.value);
                         }
                     }
                 }
@@ -441,7 +441,7 @@ namespace ts {
          */
         export function getReferencedByPaths(state: Readonly<BuilderState>, referencedFilePath: Path) {
             return arrayFrom(mapDefinedIterator(state.referencedMap!.entries(), ([filePath, referencesInFile]) =>
-                referencesInFile.has(referencedFilePath) ? filePath as Path : undefined
+                referencesInFile.has(referencedFilePath) ? filePath : undefined
             ));
         }
 
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index 4fdb999bb6b29..8cee3aae854d7 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -2036,7 +2036,7 @@ namespace ts {
             }
             const result = getDiagnostics(sourceFile, cancellationToken);
             if (sourceFile) {
-                (cache.perFile ??= new Map()).set(sourceFile.path, result);
+                (cache.perFile || (cache.perFile = new Map())).set(sourceFile.path, result);
             }
             else {
                 cache.allDiagnostics = result;
@@ -2495,7 +2495,7 @@ namespace ts {
 
         function addFileToRefFileMap(referencedFileName: string, file: SourceFile | undefined, refFile: RefFile | undefined) {
             if (refFile && file) {
-                (refFileMap ??= createMultiMap()).add(file.path, {
+                (refFileMap || (refFileMap = createMultiMap())).add(file.path, {
                     referencedFileName,
                     kind: refFile.kind,
                     index: refFile.index,
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index 083b3d368e530..fcbaddb966ed2 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -616,7 +616,7 @@ namespace ts {
                 cacheToUpdateChildWatches.delete(dirPath);
                 // Because the child refresh is fresh, we would need to invalidate whole root directory being watched
                 // to ensure that all the changes are reflected at this time
-                const hasChanges = updateChildWatches(dirName, dirPath as Path, options);
+                const hasChanges = updateChildWatches(dirName, dirPath, options);
                 invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames);
             }
 
diff --git a/src/compiler/tsbuildPublic.ts b/src/compiler/tsbuildPublic.ts
index a552c6f559c12..25b80515563d7 100644
--- a/src/compiler/tsbuildPublic.ts
+++ b/src/compiler/tsbuildPublic.ts
@@ -384,8 +384,8 @@ namespace ts {
     }
 
     function createBuildOrder(state: SolutionBuilderState, roots: readonly ResolvedConfigFileName[]): AnyBuildOrder {
-        const temporaryMarks = new Map() as Map<ResolvedConfigFilePath, true>;
-        const permanentMarks = new Map() as Map<ResolvedConfigFilePath, true>;
+        const temporaryMarks = new Map<ResolvedConfigFilePath, true>();
+        const permanentMarks = new Map<ResolvedConfigFilePath, true>();
         const circularityReportStack: string[] = [];
         let buildOrder: ResolvedConfigFileName[] | undefined;
         let circularDiagnostics: Diagnostic[] | undefined;
@@ -924,7 +924,7 @@ namespace ts {
             let newestDeclarationFileContentChangedTime = minimumDate;
             let anyDtsChanged = false;
             const emitterDiagnostics = createDiagnosticCollection();
-            const emittedOutputs = new Map() as Map<Path, string>;
+            const emittedOutputs = new Map<Path, string>();
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
                 let priorChangeTime: Date | undefined;
                 if (!anyDtsChanged && isDeclarationFile(name)) {
@@ -1057,7 +1057,7 @@ namespace ts {
             // Actual Emit
             Debug.assert(!!outputFiles.length);
             const emitterDiagnostics = createDiagnosticCollection();
-            const emittedOutputs = new Map() as Map<Path, string>;
+            const emittedOutputs = new Map<Path, string>();
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
                 emittedOutputs.set(toPath(state, name), name);
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index 794274cb9cea8..acfb5b806e3b7 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -874,7 +874,7 @@ namespace ts.server {
             const event: ProjectsUpdatedInBackgroundEvent = {
                 eventName: ProjectsUpdatedInBackgroundEvent,
                 data: {
-                    openFiles: arrayFrom(this.openFiles.keys(), path => this.getScriptInfoForPath(path as Path)!.fileName)
+                    openFiles: arrayFrom(this.openFiles.keys(), path => this.getScriptInfoForPath(path)!.fileName)
                 }
             };
             this.eventHandler(event);
@@ -1373,7 +1373,7 @@ namespace ts.server {
         private assignOrphanScriptInfosToInferredProject() {
             // collect orphaned files and assign them to inferred project just like we treat open of a file
             this.openFiles.forEach((projectRootPath, path) => {
-                const info = this.getScriptInfoForPath(path as Path)!;
+                const info = this.getScriptInfoForPath(path)!;
                 // collect all orphaned script infos from open files
                 if (info.isOrphan()) {
                     this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
@@ -1557,7 +1557,7 @@ namespace ts.server {
             const inferredRoots: string[] = [];
             const otherFiles: string[] = [];
             configFileExistenceInfo.openFilesImpactedByConfigFile.forEach((isRootOfInferredProject, key) => {
-                const info = this.getScriptInfoForPath(key as Path)!;
+                const info = this.getScriptInfoForPath(key)!;
                 (isRootOfInferredProject ? inferredRoots : otherFiles).push(info.fileName);
             });
 
@@ -1796,7 +1796,7 @@ namespace ts.server {
 
             this.logger.info("Open files: ");
             this.openFiles.forEach((projectRootPath, path) => {
-                const info = this.getScriptInfoForPath(path as Path)!;
+                const info = this.getScriptInfoForPath(path)!;
                 this.logger.info(`\tFileName: ${info.fileName} ProjectRootPath: ${projectRootPath}`);
                 this.logger.info(`\t\tProjects: ${info.containingProjects.map(p => p.getProjectName())}`);
             });
@@ -2770,7 +2770,7 @@ namespace ts.server {
                     return;
                 }
 
-                const info = this.getScriptInfoForPath(path as Path)!; // TODO: GH#18217
+                const info = this.getScriptInfoForPath(path)!; // TODO: GH#18217
                 Debug.assert(info.isScriptOpen());
                 // This tries to search for a tsconfig.json for the given file. If we found it,
                 // we first detect if there is already a configured project created for it: if so,
@@ -2850,7 +2850,7 @@ namespace ts.server {
             this.printProjects();
 
             this.openFiles.forEach((projectRootPath, path) => {
-                const info = this.getScriptInfoForPath(path as Path)!;
+                const info = this.getScriptInfoForPath(path)!;
                 // collect all orphaned script infos from open files
                 if (info.isOrphan()) {
                     this.assignOrphanScriptInfoToInferredProject(info, projectRootPath);
@@ -3214,7 +3214,7 @@ namespace ts.server {
                     }
                     if (!sourceInfos) return;
                     if (!forEachKey(sourceInfos, path => {
-                        const info = this.getScriptInfoForPath(path as Path);
+                        const info = this.getScriptInfoForPath(path);
                         return !!info && (info.isScriptOpen() || !info.isOrphan());
                     })) {
                         return;
diff --git a/src/server/project.ts b/src/server/project.ts
index 642607807d711..859a9c2db6bf5 100644
--- a/src/server/project.ts
+++ b/src/server/project.ts
@@ -1055,7 +1055,7 @@ namespace ts.server {
                 // Update the missing file paths watcher
                 updateMissingFilePathsWatch(
                     this.program,
-                    this.missingFilesMap ??= new Map(),
+                    this.missingFilesMap || (this.missingFilesMap = new Map()),
                     // Watch the missing files
                     missingFilePath => this.addMissingFileWatcher(missingFilePath)
                 );
@@ -1078,7 +1078,7 @@ namespace ts.server {
                         }
                         else {
                             this.generatedFilesMap.forEach((watcher, source) => {
-                                const sourceFile = this.program!.getSourceFileByPath(source as Path);
+                                const sourceFile = this.program!.getSourceFileByPath(source);
                                 if (!sourceFile ||
                                     sourceFile.resolvedPath !== source ||
                                     !this.isValidGeneratedFileWatcher(
@@ -2093,8 +2093,8 @@ namespace ts.server {
             return forEachEntry(
                 configFileExistenceInfo.openFilesImpactedByConfigFile,
                 (_value, infoPath) => isSolution ?
-                    !!this.getDefaultChildProjectFromSolution(this.projectService.getScriptInfoForPath(infoPath as Path)!) :
-                    this.containsScriptInfo(this.projectService.getScriptInfoForPath(infoPath as Path)!)
+                    !!this.getDefaultChildProjectFromSolution(this.projectService.getScriptInfoForPath(infoPath)!) :
+                    this.containsScriptInfo(this.projectService.getScriptInfoForPath(infoPath)!)
             ) || false;
         }
 
diff --git a/src/server/session.ts b/src/server/session.ts
index bdc4eb02805b8..3a8148680c98c 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -277,7 +277,7 @@ namespace ts.server {
         const outputs = flatMapToMutable(isArray(projects) ? projects : projects.projects, project => action(project, defaultValue));
         if (!isArray(projects) && projects.symLinkedProjects) {
             projects.symLinkedProjects.forEach((projects, path) => {
-                const value = getValue(path as Path);
+                const value = getValue(path);
                 outputs.push(...flatMap(projects, project => action(project, value)));
             });
         }
diff --git a/src/testRunner/unittests/tsserver/helpers.ts b/src/testRunner/unittests/tsserver/helpers.ts
index 2523c8c724fd8..5a1cdee81d654 100644
--- a/src/testRunner/unittests/tsserver/helpers.ts
+++ b/src/testRunner/unittests/tsserver/helpers.ts
@@ -489,7 +489,7 @@ namespace ts.projectSystem {
     }
 
     export function checkOpenFiles(projectService: server.ProjectService, expectedFiles: File[]) {
-        checkArray("Open files", arrayFrom(projectService.openFiles.keys(), path => projectService.getScriptInfoForPath(path as Path)!.fileName), expectedFiles.map(file => file.path));
+        checkArray("Open files", arrayFrom(projectService.openFiles.keys(), path => projectService.getScriptInfoForPath(path)!.fileName), expectedFiles.map(file => file.path));
     }
 
     export function checkScriptInfos(projectService: server.ProjectService, expectedFiles: readonly string[], additionInfo?: string) {

From d76ce7b66ea7b2e658edbe9dae85265f7756fb64 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Wed, 24 Jun 2020 15:55:16 -0700
Subject: [PATCH 08/10] Change key in fsWatchCallback

---
 src/harness/virtualFileSystemWithWatch.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/harness/virtualFileSystemWithWatch.ts b/src/harness/virtualFileSystemWithWatch.ts
index 57f3816fe7499..d20e847d57d06 100644
--- a/src/harness/virtualFileSystemWithWatch.ts
+++ b/src/harness/virtualFileSystemWithWatch.ts
@@ -750,7 +750,7 @@ interface Array<T> { length: number; [n: number]: T; }`
             invokeWatcherCallbacks(this.watchedFiles.get(this.toPath(fileFullPath)), ({ cb, fileName }) => cb(useFileNameInCallback ? fileName : fileFullPath, eventKind));
         }
 
-        private fsWatchCallback(map: MultiMap<string, TestFsWatcher>, fullPath: string, eventName: "rename" | "change", entryFullPath?: string) {
+        private fsWatchCallback(map: MultiMap<Path, TestFsWatcher>, fullPath: string, eventName: "rename" | "change", entryFullPath?: string) {
             invokeWatcherCallbacks(map.get(this.toPath(fullPath)), ({ cb }) => cb(eventName, entryFullPath ? this.getRelativePathToDirectory(fullPath, entryFullPath) : ""));
         }
 

From fc50c27d57250c6acab5fb6d01aa6841c5eb2a46 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Thu, 25 Jun 2020 15:46:23 -0700
Subject: [PATCH 09/10] Simpler shim, more tests

---
 src/shims/collectionShims.ts              | 370 ++++++----------------
 src/testRunner/unittests/createMapShim.ts | 166 +++++++++-
 src/testRunner/unittests/createSetShim.ts | 167 +++++++++-
 3 files changed, 418 insertions(+), 285 deletions(-)

diff --git a/src/shims/collectionShims.ts b/src/shims/collectionShims.ts
index 349d712a2193e..545054bbef963 100644
--- a/src/shims/collectionShims.ts
+++ b/src/shims/collectionShims.ts
@@ -52,335 +52,165 @@ namespace ts {
 
     interface MapData<K, V> {
         size: number;
-        strings?: Record<string, MapEntry<K, V>>;
-        numbers?: MapEntry<K, V>[];
-        nan?: MapEntry<K, V>;
-        positiveInfinity?: MapEntry<K, V>;
-        negativeInfinity?: MapEntry<K, V>;
-        list?: MapEntry<K, V>;
-        true?: MapEntry<K, V>;
-        false?: MapEntry<K, V>;
-        null?: MapEntry<K, V>;
-        undefined?: MapEntry<K, V>;
-
-        // Linked list references for iterators.
-        // See https://github.com/Microsoft/TypeScript/pull/27292
-        // for more information.
-
-        /**
-         * The first entry in the linked list.
-         * Note that this is only a stub that serves as starting point
-         * for iterators and doesn't contain a key and a value.
-         */
-        readonly first: MapEntry<K, V>;
-        last: MapEntry<K, V>;
+        readonly head: MapEntry<K, V>;
+        tail: MapEntry<K, V>;
     }
 
     interface MapEntry<K, V> {
         readonly key?: K;
         value?: V;
-
-        // Linked list references for non-primitive keys
+        /**
+         * Specifies the next entry in the linked list.
+         */
         next?: MapEntry<K, V>;
-
-        // Linked list references for iterators.
-        nextIterationEntry?: MapEntry<K, V>;
-        previousIterationEntry?: MapEntry<K, V>;
-
         /**
-         * Specifies if iterators should skip the next entry.
-         * This will be set when an entry is deleted.
+         * Specifies the previous entry in the linked list.
+         * Must be set when the entry is part of a Map/Set.
+         * When 'undefined', iterators should skip the next entry.
+         * This will be set to 'undefined' when an entry is deleted.
          * See https://github.com/Microsoft/TypeScript/pull/27292 for more information.
          */
-        skipNextIteration?: boolean;
+        prev?: MapEntry<K, V>;
     }
 
     interface IteratorData<K, V, U extends (K | V | [K, V])> {
-        currentEntry?: MapEntry<K, V>;
+        current?: MapEntry<K, V>;
         selector: (key: K, value: V) => U;
     }
 
-    function createDictionaryObject<T>(): Record<string, T> {
-        const map = Object.create(/*prototype*/ null); // eslint-disable-line no-null/no-null
-
-        // Using 'delete' on an object causes V8 to put the object in dictionary mode.
-        // This disables creation of hidden classes, which are expensive when an object is
-        // constantly changing shape.
-        map.__ = undefined;
-        delete map.__;
-        return map;
-    }
-
     function createMapData<K, V>(): MapData<K, V> {
-        const entry: MapEntry<K, V> = {};
-        return { first: entry, last: entry, size: 0 };
+        const sentinel: MapEntry<K, V> = {};
+        sentinel.prev = sentinel;
+        return { head: sentinel, tail: sentinel, size: 0 };
     }
 
     function createMapEntry<K, V>(key: K, value: V): MapEntry<K, V> {
-        return { key, value, nextIterationEntry: undefined, previousIterationEntry: undefined, skipNextIteration: false };
-    }
-
-    function createListMapEntry<K, V>(key: K, value: V, next?: MapEntry<K, V>): MapEntry<K, V> {
-        const entry = createMapEntry(key, value);
-        entry.next = next;
-        return entry;
+        return { key, value, next: undefined, prev: undefined };
     }
 
-    function getSingletonBucket(key: unknown) {
-        /* eslint-disable no-null/no-null */
-        if (key === true) return "true";
-        if (key === false) return "false";
-        if (key === null) return "null";
-        if (key === undefined) return "undefined";
-        if (typeof key === "number") {
-            if (isNaN(key)) return "nan";
-            if (!isFinite(key)) return key < 0 ? "negativeInfinity" : "positiveInfinity";
-        }
-        /* eslint-enable no-null/no-null */
+    function sameValueZero(x: unknown, y: unknown) {
+        // Treats -0 === 0 and NaN === NaN
+        return x === y || x !== x && y !== y;
     }
 
-    function getEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
-        const bucket = getSingletonBucket(key);
-        return bucket ? data[bucket] :
-            typeof key === "string" ? data.strings?.[key] :
-            typeof key === "number" ? data.numbers?.[key] :
-            getListEntry(data, key);
+    function getPrev<K, V>(entry: MapEntry<K, V>) {
+        const prev = entry.prev;
+        // Entries without a 'prev' have been removed from the map.
+        // An entry whose 'prev' points to itself is the head of the list and is invalid here.
+        if (!prev || prev === entry) throw new Error("Illegal state");
+        return prev;
     }
 
-    function getListEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
-        for (let node = data.list; node; node = node.next) {
-            if (node.key === key) {
-                return node;
+    function getNext<K, V>(entry: MapEntry<K, V> | undefined) {
+        while (entry) {
+            // Entries without a 'prev' have been removed from the map. Their 'next'
+            // pointer should point to the previous entry prior to deletion and
+            // that entry should be skipped to resume iteration.
+            const skipNext = !entry.prev;
+            entry = entry.next;
+            if (skipNext) {
+                continue;
             }
+            return entry;
         }
     }
 
-    function addOrUpdateEntry<K, V>(data: MapData<K, V>, key: K, value: V): MapEntry<K, V> | undefined {
-        const bucket = getSingletonBucket(key);
-        const entry = bucket ? addOrUpdateSingletonEntry(data, bucket, key, value) :
-            typeof key === "string" ? addOrUpdateStringsEntry(data, key, value) :
-            typeof key === "number" ? addOrUpdateNumbersEntry(data, key, value) :
-            addOrUpdateListEntry(data, key, value);
-        if (entry) {
-            addToIteration(data, entry);
-            data.size++;
-        }
-        return entry;
-    }
-
-    function addOrUpdateSingletonEntry<K, V>(data: MapData<K, V>, prop: "nan" | "negativeInfinity" | "positiveInfinity" | "true" | "false" | "null" | "undefined", key: K, value: V) {
-        const entry = data[prop];
-        if (!entry) {
-            return data[prop] = createMapEntry(key, value);
-        }
-        else {
-            entry.value = value;
-        }
-    }
-
-    function addOrUpdateStringsEntry<K, V>(data: MapData<K, V>, key: K & string, value: V) {
-        if (!data.strings) data.strings = createDictionaryObject();
-        if (!data.strings[key]) {
-            return data.strings[key] = createMapEntry(key, value);
-        }
-        else {
-            data.strings[key].value = value;
+    function getEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        // We walk backwards from 'tail' to prioritize recently added entries.
+        // We skip 'head' because it is an empty entry used to track iteration start.
+        for (let entry = data.tail; entry !== data.head; entry = getPrev(entry)) {
+            if (sameValueZero(entry.key, key)) {
+                return entry;
+            }
         }
     }
 
-    function addOrUpdateNumbersEntry<K, V>(data: MapData<K, V>, key: K & number, value: V) {
-        if (!data.numbers) data.numbers = [];
-        if (!data.numbers[key]) {
-            return data.numbers[key] = createMapEntry(key, value);
-        }
-        else {
-            data.numbers[key].value = value;
+    function addOrUpdateEntry<K, V>(data: MapData<K, V>, key: K, value: V): MapEntry<K, V> | undefined {
+        const existing = getEntry(data, key);
+        if (existing) {
+            existing.value = value;
+            return;
         }
-    }
-
-    function addOrUpdateListEntry<K, V>(data: MapData<K, V>, key: K, value: V): MapEntry<K, V> | undefined {
-        if (!data.list) return data.list = createListMapEntry(key, value, /*next*/ undefined);
-        const existing = getListEntry(data, key);
-        if (!existing) return data.list = createListMapEntry(key, value, data.list);
-        existing.value = value;
-    }
 
-    function deleteEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
-        const bucket = getSingletonBucket(key);
-        let entry: MapEntry<K, V> | undefined;
-        if (bucket) {
-            if (entry = data[bucket]) {
-                delete data[bucket];
-            }
-        }
-        else if (typeof key === "string") {
-            if (entry = data.strings?.[key]) {
-                delete data.strings[key];
-            }
-        }
-        else if (typeof key === "number") {
-            if (entry = data.numbers?.[key]) {
-                delete data.numbers[key];
-            }
-        }
-        else {
-            entry = deleteListEntry(data, key);
-        }
-        if (entry) {
-            removeFromIteration(data, entry);
-            data.size--;
-        }
+        const entry = createMapEntry(key, value);
+        entry.prev = data.tail;
+        data.tail.next = entry;
+        data.tail = entry;
+        data.size++;
         return entry;
     }
 
-    function deleteListEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
-        let prev: MapEntry<K, V> | undefined;
-        for (let node = data.list; node; prev = node, node = node.next) {
-            if (node.key === key) {
-                if (prev) {
-                    prev.next = node.next;
+    function deleteEntry<K, V>(data: MapData<K, V>, key: K): MapEntry<K, V> | undefined {
+        // We walk backwards from 'tail' to prioritize recently added entries.
+        // We skip 'head' because it is an empty entry used to track iteration start.
+        for (let entry = data.tail; entry !== data.head; entry = getPrev(entry)) {
+            // all entries in the map should have a 'prev' pointer.
+            if (entry.prev === undefined) throw new Error("Illegal state");
+            if (sameValueZero(entry.key, key)) {
+                if (entry.next) {
+                    entry.next.prev = entry.prev;
                 }
                 else {
-                    data.list = node.next;
+                    // an entry in the map without a 'next' pointer must be the 'tail'.
+                    if (data.tail !== entry) throw new Error("Illegal state");
+                    data.tail = entry.prev;
                 }
-                node.next = undefined;
-                return node;
-            }
-        }
-    }
-
-    function clearEntries<K, V>(data: MapData<K, V>) {
-        if (data.strings) data.strings = undefined;
-        if (data.numbers) data.numbers = undefined;
-        if (data.true) data.true = undefined;
-        if (data.false) data.false = undefined;
-        if (data.null) data.null = undefined;
-        if (data.undefined) data.undefined = undefined;
-        clearListEntries(data);
-        removeAllFromIteration(data);
-        data.size = 0;
-    }
 
-    function clearListEntries<K, V>(data: MapData<K, V>) {
-        if (data.list) {
-            let node = data.list;
-            data.list = undefined;
-            while (node) {
-                const next = node.next!;
-                node.next = undefined;
-                node = next;
+                entry.prev.next = entry.next;
+                entry.next = entry.prev;
+                entry.prev = undefined;
+                data.size--;
+                return entry;
             }
         }
     }
 
-    function addToIteration<K, V>(data: MapData<K, V>, newEntry: MapEntry<K, V>) {
-        // Adjust the references.
-        const previousLastEntry = data.last;
-        previousLastEntry.nextIterationEntry = newEntry;
-        newEntry.previousIterationEntry = previousLastEntry;
-        data.last = newEntry;
-    }
-
-    function removeFromIteration<K, V>(data: MapData<K, V>, entry: MapEntry<K, V>) {
-        // Adjust the linked list references of the neighbor entries.
-        const previousEntry = entry.previousIterationEntry!;
-        previousEntry.nextIterationEntry = entry.nextIterationEntry;
-        if (entry.nextIterationEntry) {
-            entry.nextIterationEntry.previousIterationEntry = previousEntry;
-        }
-
-        // When the deleted entry was the last one, we need to
-        // adjust the lastEntry reference.
-        if (data.last === entry) {
-            data.last = previousEntry;
-        }
-
-        // Adjust the forward reference of the deleted entry
-        // in case an iterator still references it. This allows us
-        // to throw away the entry, but when an active iterator
-        // (which points to the current entry) continues, it will
-        // navigate to the entry that originally came before the
-        // current one and skip it.
-        entry.previousIterationEntry = undefined;
-        entry.nextIterationEntry = previousEntry;
-        entry.skipNextIteration = true;
-    }
-
-    function removeAllFromIteration<K, V>(data: MapData<K, V>) {
-        // Reset the linked list. Note that we must adjust the forward
-        // references of the deleted entries to ensure iterators stuck
-        // in the middle of the list don't continue with deleted entries,
-        // but can continue with new entries added after the clear()
-        // operation.
-        const firstEntry = data.first;
-        let currentEntry = firstEntry.nextIterationEntry;
-        while (currentEntry) {
-            const nextEntry = currentEntry.nextIterationEntry;
-            currentEntry.previousIterationEntry = undefined;
-            currentEntry.nextIterationEntry = firstEntry;
-            currentEntry.skipNextIteration = true;
-            currentEntry = nextEntry;
+    function clearEntries<K, V>(data: MapData<K, V>) {
+        let node = data.tail;
+        while (node !== data.head) {
+            const prev = getPrev(node);
+            node.next = data.head;
+            node.prev = undefined;
+            node = prev;
         }
-
-        firstEntry.nextIterationEntry = undefined;
-        data.last = firstEntry;
+        data.head.next = undefined;
+        data.tail = data.head;
+        data.size = 0;
     }
 
     function forEachEntry<K, V>(data: MapData<K, V>, action: (value: V, key: K) => void) {
-        let currentEntry: MapEntry<K, V> | undefined = data.first;
-        while (currentEntry) {
-            const skipNext = !!currentEntry.skipNextIteration;
-            currentEntry = currentEntry.nextIterationEntry;
-            if (skipNext) {
-                continue;
-            }
-            if (currentEntry) {
-                action(currentEntry.value!, currentEntry.key!);
+        let entry: MapEntry<K, V> | undefined = data.head;
+        while (entry) {
+            entry = getNext(entry);
+            if (entry) {
+                action(entry.value!, entry.key!);
             }
         }
     }
 
-    function fill<T, O extends ReadonlyMapShim<any, any> | ReadonlySetShim<any>>(object: O, iterator: Iterator<T> | undefined, add: (object: O, value: any) => void) {
+    function forEachIteration<T>(iterator: Iterator<T> | undefined, action: (value: any) => void) {
         if (iterator) {
             for (let step = iterator.next(); !step.done; step = iterator.next()) {
-                add(object, step.value);
+                action(step.value);
             }
         }
     }
 
     function createIteratorData<K, V, U extends (K | V | [K, V])>(data: MapData<K, V>, selector: (key: K, value: V) => U): IteratorData<K, V, U> {
-        return { currentEntry: data.first, selector };
+        return { current: data.head, selector };
     }
 
     function iteratorNext<K, V, U extends (K | V | [K, V])>(data: IteratorData<K, V, U>): IteratorResultShim<U> {
         // Navigate to the next entry.
-        while (data.currentEntry) {
-            const skipNext = !!data.currentEntry.skipNextIteration;
-            data.currentEntry = data.currentEntry.nextIterationEntry;
-            if (!skipNext) {
-                break;
-            }
-        }
-        if (data.currentEntry) {
-            return { value: data.selector(data.currentEntry.key!, data.currentEntry.value!), done: false };
+        data.current = getNext(data.current);
+        if (data.current) {
+            return { value: data.selector(data.current.key!, data.current.value!), done: false };
         }
         else {
             return { value: undefined as never, done: true };
         }
     }
 
-    function pickKey<K, V>(key: K, _value: V) {
-        return key;
-    }
-
-    function pickValue<K, V>(_key: K, value: V) {
-        return value;
-    }
-
-    function pickEntry<K, V>(key: K, value: V) {
-        return [key, value] as [K, V];
-    }
-
     /* @internal */
     export namespace ShimCollections {
         export function createMapShim(getIterator: GetIteratorCallback): MapShimConstructor {
@@ -391,13 +221,10 @@ namespace ts {
                 }
                 next() { return iteratorNext(this._data); }
             }
-            function fillMap<K, V>(object: MapShim<K, V>, [key, value]: readonly [K, V]) {
-                object.set(key, value);
-            }
             return class Map<K, V> implements MapShim<K, V> {
                 private _mapData = createMapData<K, V>();
                 constructor(iterable?: readonly (readonly [K, V])[] | ReadonlyMapShim<K, V>) {
-                    fill(this, getIterator(iterable), fillMap);
+                    forEachIteration(getIterator(iterable), ([key, value]) => this.set(key, value));
                 }
                 get size() { return this._mapData.size; }
                 get(key: K): V | undefined { return getEntry(this._mapData, key)?.value; }
@@ -405,9 +232,9 @@ namespace ts {
                 has(key: K): boolean { return !!getEntry(this._mapData, key); }
                 delete(key: K): boolean { return !!deleteEntry(this._mapData, key); }
                 clear(): void { clearEntries(this._mapData); }
-                keys(): IteratorShim<K> { return new MapIterator(this._mapData, pickKey); }
-                values(): IteratorShim<V> { return new MapIterator(this._mapData, pickValue); }
-                entries(): IteratorShim<[K, V]> { return new MapIterator(this._mapData, pickEntry); }
+                keys(): IteratorShim<K> { return new MapIterator(this._mapData, (key, _value) => key); }
+                values(): IteratorShim<V> { return new MapIterator(this._mapData, (_key, value) => value); }
+                entries(): IteratorShim<[K, V]> { return new MapIterator(this._mapData, (key, value) => [key, value]); }
                 forEach(action: (value: V, key: K) => void): void { forEachEntry(this._mapData, action); }
             };
         }
@@ -420,22 +247,19 @@ namespace ts {
                 }
                 next() { return iteratorNext(this._data); }
             }
-            function fillSet<T>(object: SetShim<T>, value: T) {
-                object.add(value);
-            }
             return class Set<T> implements SetShim<T> {
                 private _mapData = createMapData<T, T>();
                 constructor(iterable?: readonly T[] | ReadonlySetShim<T>) {
-                    fill(this, getIterator(iterable), fillSet);
+                    forEachIteration(getIterator(iterable), value => this.add(value));
                 }
                 get size() { return this._mapData.size; }
                 add(value: T): this { return addOrUpdateEntry(this._mapData, value, value), this; }
                 has(value: T): boolean { return !!getEntry(this._mapData, value); }
                 delete(value: T): boolean { return !!deleteEntry(this._mapData, value); }
                 clear(): void { clearEntries(this._mapData); }
-                keys(): IteratorShim<T> { return new SetIterator(this._mapData, pickKey); }
-                values(): IteratorShim<T> { return new SetIterator(this._mapData, pickValue); }
-                entries(): IteratorShim<[T, T]> { return new SetIterator(this._mapData, pickEntry); }
+                keys(): IteratorShim<T> { return new SetIterator(this._mapData, (key, _value) => key); }
+                values(): IteratorShim<T> { return new SetIterator(this._mapData, (_key, value) => value); }
+                entries(): IteratorShim<[T, T]> { return new SetIterator(this._mapData, (key, value) => [key, value]); }
                 forEach(action: (value: T, key: T) => void): void { forEachEntry(this._mapData, action); }
             };
         }
diff --git a/src/testRunner/unittests/createMapShim.ts b/src/testRunner/unittests/createMapShim.ts
index aee5c48b5859e..039372ab2746c 100644
--- a/src/testRunner/unittests/createMapShim.ts
+++ b/src/testRunner/unittests/createMapShim.ts
@@ -115,6 +115,26 @@ namespace ts {
             return resultString;
         }
 
+        let MapShim!: MapConstructor;
+        beforeEach(() => {
+            function getIterator<I extends readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined>(iterable: I): Iterator<
+                I extends ReadonlyMap<infer K, infer V> ? [K, V] :
+                I extends ReadonlySet<infer T> ? T :
+                I extends readonly (infer T)[] ? T :
+                I extends undefined ? undefined :
+                never>;
+            function getIterator(iterable: readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined): Iterator<any> | undefined {
+                // override `ts.getIterator` with a version that allows us to iterate over a `MapShim` in an environment with a native `Map`.
+                if (iterable instanceof MapShim) return iterable.entries();
+                return ts.getIterator(iterable);
+            }
+
+            MapShim = ShimCollections.createMapShim(getIterator);
+            afterEach(() => {
+                MapShim = undefined!;
+            });
+        });
+
         it("iterates values in insertion order and handles changes with string keys", () => {
             const expectedResult = "1:1;3:3;2:Y2;4:X4;0:X0;3:Y3;999:999;A:A;Z:Z;X:X;Y:Y;";
 
@@ -128,7 +148,6 @@ namespace ts {
             assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
 
             // Then, test the map shim.
-            const MapShim = ShimCollections.createMapShim(getIterator); // tslint:disable-line variable-name
             let localShimMap = new MapShim<string, string>();
             const shimMapForEachResult = testMapIterationAddedValues(stringKeys, localShimMap, /* useForEach */ true);
             assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
@@ -151,7 +170,6 @@ namespace ts {
             assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
 
             // Then, test the map shim.
-            const MapShim = ShimCollections.createMapShim(getIterator); // tslint:disable-line variable-name
             let localShimMap = new MapShim<any, string>();
             const shimMapForEachResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ true);
             assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
@@ -160,5 +178,149 @@ namespace ts {
             const shimMapIteratorResult = testMapIterationAddedValues(mixedKeys, localShimMap, /* useForEach */ false);
             assert.equal(shimMapIteratorResult, expectedResult, "shimMap-iterator");
         });
+
+        it("create from Array", () => {
+            const map = new MapShim([["a", "b"]]);
+            assert.equal(map.size, 1);
+            assert.isTrue(map.has("a"));
+            assert.equal(map.get("a"), "b");
+        });
+
+        it("create from Map", () => {
+            const map1 = new MapShim([["a", "b"]]);
+            const map2 = new MapShim(map1);
+            assert.equal(map1.size, 1);
+            assert.equal(map2.size, 1);
+            assert.isTrue(map2.has("a"));
+            assert.equal(map2.get("a"), "b");
+        });
+
+        it("set when not present", () => {
+            const map = new MapShim<string, string>();
+            const result = map.set("a", "b");
+            assert.equal(map.size, 1);
+            assert.strictEqual(result, map);
+            assert.isTrue(map.has("a"));
+            assert.equal(map.get("a"), "b");
+        });
+
+        it("set when present", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "z");
+            const result = map.set("a", "b");
+            assert.equal(map.size, 1);
+            assert.strictEqual(result, map);
+            assert.isTrue(map.has("a"));
+            assert.equal(map.get("a"), "b");
+        });
+
+        it("has when not present", () => {
+            const map = new MapShim<string, string>();
+            assert.isFalse(map.has("a"));
+        });
+
+        it("has when present", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            assert.isTrue(map.has("a"));
+        });
+
+        it("get when not present", () => {
+            const map = new MapShim<string, string>();
+            assert.isUndefined(map.get("a"));
+        });
+
+        it("get when present", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            assert.equal(map.get("a"), "b");
+        });
+
+        it("delete when not present", () => {
+            const map = new MapShim<string, string>();
+            assert.isFalse(map.delete("a"));
+        });
+
+        it("delete when present", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            assert.isTrue(map.delete("a"));
+        });
+
+        it("delete twice when present", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            assert.isTrue(map.delete("a"));
+            assert.isFalse(map.delete("a"));
+        });
+
+        it("remove only item and iterate", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            map.delete("a");
+            const actual = arrayFrom(map.keys());
+            assert.deepEqual(actual, []);
+        });
+
+        it("remove first item and iterate", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            map.set("c", "d");
+            map.delete("a");
+            assert.deepEqual(arrayFrom(map.keys()), ["c"]);
+            assert.deepEqual(arrayFrom(map.values()), ["d"]);
+            assert.deepEqual(arrayFrom(map.entries()), [["c", "d"]]);
+        });
+
+        it("remove last item and iterate", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            map.set("c", "d");
+            map.delete("c");
+            assert.deepEqual(arrayFrom(map.keys()), ["a"]);
+            assert.deepEqual(arrayFrom(map.values()), ["b"]);
+            assert.deepEqual(arrayFrom(map.entries()), [["a", "b"]]);
+        });
+
+        it("remove middle item and iterate", () => {
+            const map = new MapShim<string, string>();
+            map.set("a", "b");
+            map.set("c", "d");
+            map.set("e", "f");
+            map.delete("c");
+            assert.deepEqual(arrayFrom(map.keys()), ["a", "e"]);
+            assert.deepEqual(arrayFrom(map.values()), ["b", "f"]);
+            assert.deepEqual(arrayFrom(map.entries()), [["a", "b"], ["e", "f"]]);
+        });
+
+        it("keys", () => {
+            const map = new MapShim<string, string>();
+            map.set("c", "d");
+            map.set("a", "b");
+            assert.deepEqual(arrayFrom(map.keys()), ["c", "a"]);
+        });
+
+        it("values", () => {
+            const map = new MapShim<string, string>();
+            map.set("c", "d");
+            map.set("a", "b");
+            assert.deepEqual(arrayFrom(map.values()), ["d", "b"]);
+        });
+
+        it("entries", () => {
+            const map = new MapShim<string, string>();
+            map.set("c", "d");
+            map.set("a", "b");
+            assert.deepEqual(arrayFrom(map.entries()), [["c", "d"], ["a", "b"]]);
+        });
+
+        it("forEach", () => {
+            const map = new MapShim<string, string>();
+            map.set("c", "d");
+            map.set("a", "b");
+            const actual: [string, string][] = [];
+            map.forEach((value, key) => { actual.push([key, value]); });
+            assert.deepEqual(actual, [["c", "d"], ["a", "b"]]);
+        });
     });
 }
diff --git a/src/testRunner/unittests/createSetShim.ts b/src/testRunner/unittests/createSetShim.ts
index f21cdd4e7f84d..2efdf850efb81 100644
--- a/src/testRunner/unittests/createSetShim.ts
+++ b/src/testRunner/unittests/createSetShim.ts
@@ -46,7 +46,7 @@ namespace ts {
             const doForEach = (key: K) => {
                 resultString += `${key};`;
 
-                // Add a new key ("0") - the map should provide this
+                // Add a new key ("0") - the set should provide this
                 // one in the next iteration.
                 if (key === keys[0]) {
                     set.add(keys[0]);
@@ -57,12 +57,12 @@ namespace ts {
                     if (!addedThree) {
                         addedThree = true;
 
-                        // Remove and re-add key "3"; the map should
+                        // Remove and re-add key "3"; the set should
                         // visit it after "0".
                         set.delete(keys[1]);
                         set.add(keys[1]);
 
-                        // Change the value of "2"; the map should provide
+                        // Change the value of "2"; the set should provide
                         // it when visiting the key.
                         set.add(keys[2]);
                     }
@@ -83,7 +83,7 @@ namespace ts {
                     set.add(keys[9]);
                 }
                 else if (key === keys[9]) {
-                    // Check that the map behaves correctly when two items are
+                    // Check that the set behaves correctly when two items are
                     // added and removed immediately.
                     set.add(keys[10]);
                     set.add(keys[11]);
@@ -113,10 +113,30 @@ namespace ts {
             return resultString;
         }
 
+        let SetShim!: SetConstructor;
+        beforeEach(() => {
+            function getIterator<I extends readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined>(iterable: I): Iterator<
+                I extends ReadonlyMap<infer K, infer V> ? [K, V] :
+                I extends ReadonlySet<infer T> ? T :
+                I extends readonly (infer T)[] ? T :
+                I extends undefined ? undefined :
+                never>;
+            function getIterator(iterable: readonly any[] | ReadonlySet<any> | ReadonlyMap<any, any> | undefined): Iterator<any> | undefined {
+                // override `ts.getIterator` with a version that allows us to iterate over a `SetShim` in an environment with a native `Set`.
+                if (iterable instanceof SetShim) return iterable.values();
+                return ts.getIterator(iterable);
+            }
+
+            SetShim = ShimCollections.createSetShim(getIterator);
+            afterEach(() => {
+                SetShim = undefined!;
+            });
+        });
+
         it("iterates values in insertion order and handles changes with string keys", () => {
             const expectedResult = "1;3;2;4;0;3;999;A;Z;X;Y;";
 
-            // First, ensure the test actually has the same behavior as a native Map.
+            // First, ensure the test actually has the same behavior as a native Set.
             let nativeSet = new Set<string>();
             const nativeSetForEachResult = testSetIterationAddedValues(stringKeys, nativeSet, /* useForEach */ true);
             assert.equal(nativeSetForEachResult, expectedResult, "nativeSet-forEach");
@@ -125,8 +145,7 @@ namespace ts {
             const nativeSetIteratorResult = testSetIterationAddedValues(stringKeys, nativeSet, /* useForEach */ false);
             assert.equal(nativeSetIteratorResult, expectedResult, "nativeSet-iterator");
 
-            // Then, test the map shim.
-            const SetShim = ShimCollections.createSetShim(getIterator);
+            // Then, test the set shim.
             let localShimSet = new SetShim<string>();
             const shimSetForEachResult = testSetIterationAddedValues(stringKeys, localShimSet, /* useForEach */ true);
             assert.equal(shimSetForEachResult, expectedResult, "shimSet-forEach");
@@ -139,7 +158,7 @@ namespace ts {
         it("iterates values in insertion order and handles changes with mixed-type keys", () => {
             const expectedResult = "true;3;2;4;false;3;null;undefined;Z;X;Y;";
 
-            // First, ensure the test actually has the same behavior as a native Map.
+            // First, ensure the test actually has the same behavior as a native Set.
             let nativeSet = new Set<any>();
             const nativeSetForEachResult = testSetIterationAddedValues(mixedKeys, nativeSet, /* useForEach */ true);
             assert.equal(nativeSetForEachResult, expectedResult, "nativeSet-forEach");
@@ -148,8 +167,7 @@ namespace ts {
             const nativeSetIteratorResult = testSetIterationAddedValues(mixedKeys, nativeSet, /* useForEach */ false);
             assert.equal(nativeSetIteratorResult, expectedResult, "nativeSet-iterator");
 
-            // Then, test the map shim.
-            const SetShim = ShimCollections.createSetShim(getIterator); // tslint:disable-line variable-name
+            // Then, test the set shim.
             let localshimSet = new SetShim<any>();
             const shimSetForEachResult = testSetIterationAddedValues(mixedKeys, localshimSet, /* useForEach */ true);
             assert.equal(shimSetForEachResult, expectedResult, "shimSet-forEach");
@@ -158,5 +176,134 @@ namespace ts {
             const shimSetIteratorResult = testSetIterationAddedValues(mixedKeys, localshimSet, /* useForEach */ false);
             assert.equal(shimSetIteratorResult, expectedResult, "shimSet-iterator");
         });
+
+        it("create from Array", () => {
+            const set = new SetShim(["a"]);
+            assert.equal(set.size, 1);
+            assert.isTrue(set.has("a"));
+        });
+
+        it("create from set", () => {
+            const set1 = new SetShim(["a"]);
+            const set2 = new SetShim(set1);
+            assert.equal(set1.size, 1);
+            assert.equal(set2.size, 1);
+            assert.isTrue(set2.has("a"));
+        });
+
+        it("add when not present", () => {
+            const set = new SetShim<string>();
+            const result = set.add("a");
+            assert.equal(set.size, 1);
+            assert.strictEqual(result, set);
+            assert.isTrue(set.has("a"));
+        });
+
+        it("add when present", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            const result = set.add("a");
+            assert.equal(set.size, 1);
+            assert.strictEqual(result, set);
+            assert.isTrue(set.has("a"));
+        });
+
+        it("has when not present", () => {
+            const set = new SetShim<string>();
+            assert.isFalse(set.has("a"));
+        });
+
+        it("has when present", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            assert.isTrue(set.has("a"));
+        });
+
+        it("delete when not present", () => {
+            const set = new SetShim<string>();
+            assert.isFalse(set.delete("a"));
+        });
+
+        it("delete when present", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            assert.isTrue(set.delete("a"));
+        });
+
+        it("delete twice when present", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            assert.isTrue(set.delete("a"));
+            assert.isFalse(set.delete("a"));
+        });
+
+        it("remove only item and iterate", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            set.delete("a");
+            const actual = arrayFrom(set.keys());
+            assert.deepEqual(actual, []);
+        });
+
+        it("remove first item and iterate", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            set.add("c");
+            set.delete("a");
+            assert.deepEqual(arrayFrom(set.keys()), ["c"]);
+            assert.deepEqual(arrayFrom(set.values()), ["c"]);
+            assert.deepEqual(arrayFrom(set.entries()), [["c", "c"]]);
+        });
+
+        it("remove last item and iterate", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            set.add("c");
+            set.delete("c");
+            assert.deepEqual(arrayFrom(set.keys()), ["a"]);
+            assert.deepEqual(arrayFrom(set.values()), ["a"]);
+            assert.deepEqual(arrayFrom(set.entries()), [["a", "a"]]);
+        });
+
+        it("remove middle item and iterate", () => {
+            const set = new SetShim<string>();
+            set.add("a");
+            set.add("c");
+            set.add("e");
+            set.delete("c");
+            assert.deepEqual(arrayFrom(set.keys()), ["a", "e"]);
+            assert.deepEqual(arrayFrom(set.values()), ["a", "e"]);
+            assert.deepEqual(arrayFrom(set.entries()), [["a", "a"], ["e", "e"]]);
+        });
+
+        it("keys", () => {
+            const set = new SetShim<string>();
+            set.add("c");
+            set.add("a");
+            assert.deepEqual(arrayFrom(set.keys()), ["c", "a"]);
+        });
+
+        it("values", () => {
+            const set = new SetShim<string>();
+            set.add("c");
+            set.add("a");
+            assert.deepEqual(arrayFrom(set.values()), ["c", "a"]);
+        });
+
+        it("entries", () => {
+            const set = new SetShim<string>();
+            set.add("c");
+            set.add("a");
+            assert.deepEqual(arrayFrom(set.entries()), [["c", "c"], ["a", "a"]]);
+        });
+
+        it("forEach", () => {
+            const set = new SetShim<string>();
+            set.add("c");
+            set.add("a");
+            const actual: [string, string][] = [];
+            set.forEach((value, key) => { actual.push([key, value]); });
+            assert.deepEqual(actual, [["c", "c"], ["a", "a"]]);
+        });
     });
 }

From 661fa61decb5d014b3cacd5430aac427de8c7230 Mon Sep 17 00:00:00 2001
From: Ron Buckton <ron.buckton@microsoft.com>
Date: Thu, 25 Jun 2020 15:54:09 -0700
Subject: [PATCH 10/10] Fix typo in collection shim

---
 src/shims/collectionShims.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/shims/collectionShims.ts b/src/shims/collectionShims.ts
index 545054bbef963..65845e9dc73c7 100644
--- a/src/shims/collectionShims.ts
+++ b/src/shims/collectionShims.ts
@@ -1,6 +1,6 @@
 /* @internal */
 namespace ts {
-    type GetIteratorCallback = <I extends readonly any[] | ReadonlySetShim<any> | ReadonlyMapShim<any, any> | undefined>(iterable: I) => Iterator<
+    type GetIteratorCallback = <I extends readonly any[] | ReadonlySetShim<any> | ReadonlyMapShim<any, any> | undefined>(iterable: I) => IteratorShim<
         I extends ReadonlyMapShim<infer K, infer V> ? [K, V] :
         I extends ReadonlySetShim<infer T> ? T :
         I extends readonly (infer T)[] ? T :
@@ -188,7 +188,7 @@ namespace ts {
         }
     }
 
-    function forEachIteration<T>(iterator: Iterator<T> | undefined, action: (value: any) => void) {
+    function forEachIteration<T>(iterator: IteratorShim<T> | undefined, action: (value: any) => void) {
         if (iterator) {
             for (let step = iterator.next(); !step.done; step = iterator.next()) {
                 action(step.value);