Merge remote-tracking branch 'upstream/master' into es2019

Jakefile.js

@@ -23,6 +23,10 @@ else if (process.env.PATH !== undefined) {
 const host = process.env.TYPESCRIPT_HOST || process.env.host || "node";
 
 const defaultTestTimeout = 40000;
+const useBuilt =
+    process.env.USE_BUILT === "true" ? true :
+    process.env.LKG === "true" ? false :
+    false;
 
 let useDebugMode = true;
 
@@ -296,7 +300,7 @@ task(TaskNames.buildFoldEnd, [], function () {
 
 desc("Compiles tslint rules to js");
 task(TaskNames.buildRules, [], function () {
-    tsbuild(ConfigFileFor.lint, false, () => complete());
+    tsbuild(ConfigFileFor.lint, !useBuilt, () => complete());
 }, { async: true });
 
 desc("Cleans the compiler output, declare files, and tests");
@@ -368,7 +372,7 @@ file(ConfigFileFor.tsserverLibrary, [], function () {
 // tsserverlibrary.js
 // tsserverlibrary.d.ts
 file(Paths.tsserverLibraryFile, [TaskNames.coreBuild, ConfigFileFor.tsserverLibrary], function() {
-    tsbuild(ConfigFileFor.tsserverLibrary, false, () => {
+    tsbuild(ConfigFileFor.tsserverLibrary, !useBuilt, () => {
         if (needsUpdate([Paths.tsserverLibraryOutFile, Paths.tsserverLibraryDefinitionOutFile], [Paths.tsserverLibraryFile, Paths.tsserverLibraryDefinitionFile])) {
             const copyright = readFileSync(Paths.copyright);
 
@@ -427,7 +431,7 @@ file(ConfigFileFor.typescriptServices, [], function () {
 // typescriptServices.js
 // typescriptServices.d.ts
 file(Paths.servicesFile, [TaskNames.coreBuild, ConfigFileFor.typescriptServices], function() {
-    tsbuild(ConfigFileFor.typescriptServices, false, () => {
+    tsbuild(ConfigFileFor.typescriptServices, !useBuilt, () => {
         if (needsUpdate([Paths.servicesOutFile, Paths.servicesDefinitionOutFile], [Paths.servicesFile, Paths.servicesDefinitionFile])) {
             const copyright = readFileSync(Paths.copyright);
 

src/compiler/commandLineParser.ts

@@ -39,6 +39,7 @@ namespace ts {
         ["es2017.string", "lib.es2017.string.d.ts"],
         ["es2017.intl", "lib.es2017.intl.d.ts"],
         ["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"],
+        ["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["es2018.intl", "lib.es2018.intl.d.ts"],
         ["es2018.promise", "lib.es2018.promise.d.ts"],
         ["es2018.regexp", "lib.es2018.regexp.d.ts"],
@@ -47,7 +48,7 @@ namespace ts {
         ["es2019.symbol", "lib.es2019.symbol.d.ts"],
         ["esnext.array", "lib.es2019.array.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
-        ["esnext.asynciterable", "lib.esnext.asynciterable.d.ts"],
+        ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["esnext.intl", "lib.esnext.intl.d.ts"],
         ["esnext.bigint", "lib.esnext.bigint.d.ts"]
     ];

src/compiler/core.ts

@@ -118,42 +118,105 @@ namespace ts {
     export const MapCtr = typeof Map !== "undefined" && "entries" in Map.prototype ? Map : shimMap();
 
     // Keep the class inside a function so it doesn't get compiled if it's not used.
-    function shimMap(): new <T>() => Map<T> {
+    export function shimMap(): new <T>() => Map<T> {
+
+        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 data: MapLike<T>;
-            private keys: ReadonlyArray<string>;
-            private index = 0;
-            private selector: (data: MapLike<T>, key: string) => U;
-            constructor(data: MapLike<T>, selector: (data: MapLike<T>, key: string) => U) {
-                this.data = data;
+            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;
-                this.keys = Object.keys(data);
             }
 
             public next(): { value: U, done: false } | { value: never, done: true } {
-                const index = this.index;
-                if (index < this.keys.length) {
-                    this.index++;
-                    return { value: this.selector(this.data, this.keys[index]), done: false };
+                // 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 { value: undefined as never, done: true };
             }
         }
 
         return class <T> implements Map<T> {
-            private data = createDictionaryObject<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 {
-                return this.data[key];
+                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;
                 }
-                this.data[key] = value;
+                else {
+                    this.data[key].value = value;
+                }
+
                 return this;
             }
 
@@ -165,32 +228,81 @@ namespace ts {
             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
+                    // adust 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<T>();
+                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(): Iterator<string> {
-                return new MapIterator(this.data, (_data, key) => key);
+                return new MapIterator(this.firstEntry, key => key);
             }
 
             values(): Iterator<T> {
-                return new MapIterator(this.data, (data, key) => data[key]);
+                return new MapIterator(this.firstEntry, (_key, value) => value);
             }
 
             entries(): Iterator<[string, T]> {
-                return new MapIterator(this.data, (data, key) => [key, data[key]] as [string, T]);
+                return new MapIterator(this.firstEntry, (key, value) => [key, value] as [string, T]);
             }
 
             forEach(action: (value: T, key: string) => void): void {
-                for (const key in this.data) {
-                    action(this.data[key], key);
+                const iterator = this.entries();
+                while (true) {
+                    const { value: entry, done } = iterator.next();
+                    if (done) {
+                        break;
+                    }
+
+                    action(entry[1], entry[0]);
                 }
             }
         };

src/compiler/types.ts

@@ -609,7 +609,7 @@ namespace ts {
     export interface Node extends TextRange {
         kind: SyntaxKind;
         flags: NodeFlags;
-        /* @internal */ modifierFlagsCache?: ModifierFlags;
+        /* @internal */ modifierFlagsCache: ModifierFlags;
         /* @internal */ transformFlags: TransformFlags;       // Flags for transforms, possibly undefined
         decorators?: NodeArray<Decorator>;                    // Array of decorators (in document order)
         modifiers?: ModifiersArray;                           // Array of modifiers

src/compiler/utilities.ts

@@ -3792,8 +3792,8 @@ namespace ts {
     }
 
     export function getModifierFlags(node: Node): ModifierFlags {
-        if (node.modifierFlagsCache! & ModifierFlags.HasComputedFlags) {
-            return node.modifierFlagsCache! & ~ModifierFlags.HasComputedFlags;
+        if (node.modifierFlagsCache & ModifierFlags.HasComputedFlags) {
+            return node.modifierFlagsCache & ~ModifierFlags.HasComputedFlags;
         }
 
         const flags = getModifierFlagsNoCache(node);

src/lib/es2018.d.ts

@@ -1,4 +1,5 @@
 /// <reference lib="es2017" />
+/// <reference lib="es2018.asynciterable" />
 /// <reference lib="es2018.promise" />
 /// <reference lib="es2018.regexp" />
 /// <reference lib="es2018.intl" />

src/lib/esnext.d.ts

@@ -1,5 +1,3 @@
 /// <reference lib="es2019" />
-/// <reference lib="esnext.asynciterable" />
-/// <reference lib="esnext.array" />
 /// <reference lib="esnext.bigint" />
 /// <reference lib="esnext.intl" />

src/lib/libs.json

@@ -30,13 +30,13 @@
         "es2017.string",
         "es2017.intl",
         "es2017.typedarrays",
+        "es2018.asynciterable",
         "es2018.regexp",
         "es2018.promise",
         "es2018.intl",
         "es2019.array",
         "es2019.string",
         "es2019.symbol",
-        "esnext.asynciterable",
         "esnext.bigint",
         "esnext.intl",
         // Default libraries

src/services/services.ts

@@ -16,18 +16,20 @@ namespace ts {
         public pos: number;
         public end: number;
         public flags: NodeFlags;
+        public modifierFlagsCache: ModifierFlags;
+        public transformFlags: TransformFlags;
         public parent: Node;
         public symbol!: Symbol; // Actually optional, but it was too annoying to access `node.symbol!` everywhere since in many cases we know it must be defined
         public jsDoc?: JSDoc[];
         public original?: Node;
-        public transformFlags: TransformFlags;
         private _children: Node[] | undefined;
 
         constructor(kind: SyntaxKind, pos: number, end: number) {
             this.pos = pos;
             this.end = end;
             this.flags = NodeFlags.None;
-            this.transformFlags = undefined!; // TODO: GH#18217
+            this.modifierFlagsCache = ModifierFlags.None;
+            this.transformFlags = TransformFlags.None;
             this.parent = undefined!;
             this.kind = kind;
         }
@@ -200,16 +202,19 @@ namespace ts {
         public pos: number;
         public end: number;
         public flags: NodeFlags;
+        public modifierFlagsCache: ModifierFlags;
+        public transformFlags: TransformFlags;
         public parent: Node;
         public symbol!: Symbol;
         public jsDocComments?: JSDoc[];
-        public transformFlags!: TransformFlags;
 
         constructor(pos: number, end: number) {
             // Set properties in same order as NodeObject
             this.pos = pos;
             this.end = end;
             this.flags = NodeFlags.None;
+            this.modifierFlagsCache = ModifierFlags.None;
+            this.transformFlags = TransformFlags.None;
             this.parent = undefined!;
         }
 

src/testRunner/tsconfig.json

@@ -58,6 +58,7 @@
         "unittests/publicApi.ts",
         "unittests/reuseProgramStructure.ts",
         "unittests/semver.ts",
+        "unittests/shimMap.ts",
         "unittests/transform.ts",
         "unittests/tsbuild.ts",
         "unittests/tsbuildWatchMode.ts",

src/testRunner/unittests/config/commandLineParsing.ts

@@ -57,7 +57,7 @@ namespace ts {
             assertParseResult(["--lib", "es5,invalidOption", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.string', 'es2019.symbol', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.string', 'es2019.symbol', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         file: undefined,
@@ -259,7 +259,7 @@ namespace ts {
             assertParseResult(["--lib", "es5,", "es7", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.string', 'es2019.symbol', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.string', 'es2019.symbol', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         file: undefined,
@@ -278,7 +278,7 @@ namespace ts {
             assertParseResult(["--lib", "es5, ", "es7", "0.ts"],
                 {
                     errors: [{
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.string', 'es2019.symbol', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'es2019', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'es2019.array', 'es2019.string', 'es2019.symbol', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category,
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         file: undefined,

src/testRunner/unittests/config/convertCompilerOptionsFromJson.ts

@@ -295,7 +295,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.intl', 'esnext.bigint'.",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -326,7 +326,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.intl', 'esnext.bigint'.",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -357,7 +357,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.intl', 'esnext.bigint'.",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]
@@ -388,7 +388,7 @@ namespace ts {
                         file: undefined,
                         start: 0,
                         length: 0,
-                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.asynciterable', 'esnext.intl', 'esnext.bigint'.",
+                        messageText: "Argument for '--lib' option must be: 'es5', 'es6', 'es2015', 'es7', 'es2016', 'es2017', 'es2018', 'esnext', 'dom', 'dom.iterable', 'webworker', 'webworker.importscripts', 'scripthost', 'es2015.core', 'es2015.collection', 'es2015.generator', 'es2015.iterable', 'es2015.promise', 'es2015.proxy', 'es2015.reflect', 'es2015.symbol', 'es2015.symbol.wellknown', 'es2016.array.include', 'es2017.object', 'es2017.sharedmemory', 'es2017.string', 'es2017.intl', 'es2017.typedarrays', 'es2018.asynciterable', 'es2018.intl', 'es2018.promise', 'es2018.regexp', 'esnext.array', 'esnext.symbol', 'esnext.intl', 'esnext.bigint'.",
                         code: Diagnostics.Argument_for_0_option_must_be_Colon_1.code,
                         category: Diagnostics.Argument_for_0_option_must_be_Colon_1.category
                     }]

src/testRunner/unittests/shimMap.ts

@@ -0,0 +1,106 @@
+namespace ts {
+    describe("unittests:: shimMap", () => {
+
+        function testMapIterationAddedValues(map: Map<string>, useForEach: boolean): string {
+            let resultString = "";
+
+            map.set("1", "1");
+            map.set("3", "3");
+            map.set("2", "2");
+            map.set("4", "4");
+
+            let addedThree = false;
+            const doForEach = (value: string, key: string) => {
+                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");
+                }
+                else if (key === "3") {
+                    if (!addedThree) {
+                        addedThree = true;
+
+                        // Remove and re-add key "3"; the map should
+                        // visit it after "0".
+                        map.delete("3");
+                        map.set("3", "Y3");
+
+                        // Change the value of "2"; the map should provide
+                        // it when visiting the key.
+                        map.set("2", "Y2");
+                    }
+                    else {
+                        // Check that an entry added when we visit the
+                        // currently last entry will still be visited.
+                        map.set("999", "999");
+                    }
+                }
+                else if (key === "999") {
+                    // Ensure that clear() behaves correctly same as removing all keys.
+                    map.set("A", "A");
+                    map.set("B", "B");
+                    map.set("C", "C");
+                }
+                else if (key === "A") {
+                    map.clear();
+                    map.set("Z", "Z");
+                }
+                else if (key === "Z") {
+                    // 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");
+                }
+            };
+
+            if (useForEach) {
+                map.forEach(doForEach);
+            }
+            else {
+                // Use an iterator.
+                const iterator = map.entries();
+                while (true) {
+                    const { value: tuple, done } = iterator.next();
+                    if (done) {
+                        break;
+                    }
+
+                    doForEach(tuple[1], tuple[0]);
+                }
+            }
+
+            return resultString;
+        }
+
+        it("iterates values in insertion order and handles changes", () => {
+            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);
+            assert.equal(nativeMapForEachResult, expectedResult, "nativeMap-forEach");
+
+            nativeMap = createMap<string>();
+            const nativeMapIteratorResult = testMapIterationAddedValues(nativeMap, /* useForEach */ false);
+            assert.equal(nativeMapIteratorResult, expectedResult, "nativeMap-iterator");
+
+            // Then, test the shimMap.
+            let localShimMap = new (shimMap())<string>();
+            const shimMapForEachResult = testMapIterationAddedValues(localShimMap, /* useForEach */ true);
+            assert.equal(shimMapForEachResult, expectedResult, "shimMap-forEach");
+
+            localShimMap = new (shimMap())<string>();
+            const shimMapIteratorResult = testMapIterationAddedValues(localShimMap, /* useForEach */ false);
+            assert.equal(shimMapIteratorResult, expectedResult, "shimMap-iterator");
+
+        });
+    });
+}

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.@link tags.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 127,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTag",
             "pos": 63,
             "end": 68,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 64,
                 "end": 67,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "see"
             },
             "comment": "{@link second link text} and {@link Foo|a foo} as well."

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.Nested @param tags.json

@@ -2,60 +2,84 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 66,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 6,
             "end": 64,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 7,
                 "end": 12,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 34,
                 "end": 64,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "JSDocTypeLiteral",
                     "pos": 34,
                     "end": 64,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "jsDocPropertyTags": [
                         {
                             "kind": "JSDocParameterTag",
                             "pos": 34,
                             "end": 64,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "tagName": {
                                 "kind": "Identifier",
                                 "pos": 35,
                                 "end": 40,
+                                "modifierFlagsCache": 0,
+                                "transformFlags": 0,
                                 "escapedText": "param"
                             },
                             "typeExpression": {
                                 "kind": "JSDocTypeExpression",
                                 "pos": 41,
                                 "end": 49,
+                                "modifierFlagsCache": 0,
+                                "transformFlags": 0,
                                 "type": {
                                     "kind": "StringKeyword",
                                     "pos": 42,
-                                    "end": 48
+                                    "end": 48,
+                                    "modifierFlagsCache": 0,
+                                    "transformFlags": 0
                                 }
                             },
                             "name": {
                                 "kind": "FirstNode",
                                 "pos": 50,
                                 "end": 53,
+                                "modifierFlagsCache": 0,
+                                "transformFlags": 0,
                                 "left": {
                                     "kind": "Identifier",
                                     "pos": 50,
                                     "end": 51,
+                                    "modifierFlagsCache": 0,
+                                    "transformFlags": 0,
                                     "escapedText": "o"
                                 },
                                 "right": {
                                     "kind": "Identifier",
                                     "pos": 52,
                                     "end": 53,
+                                    "modifierFlagsCache": 0,
+                                    "transformFlags": 0,
                                     "escapedText": "f"
                                 }
                             },
@@ -70,6 +94,8 @@
                 "kind": "Identifier",
                 "pos": 22,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "o"
             },
             "isNameFirst": true,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.argSynonymForParamTag.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 44,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 42,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 12,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "arg"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 13,
                 "end": 21,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 14,
-                    "end": 20
+                    "end": 20,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 22,
                 "end": 27,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.argumentSynonymForParamTag.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 49,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 47,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "argument"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 18,
                 "end": 26,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 19,
-                    "end": 25
+                    "end": 25,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 27,
                 "end": 32,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.asteriskAfterPreamble.json

@@ -2,5 +2,7 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 23,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "comment": "* @type {number}"
 }

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.emptyComment.json

@@ -1,5 +1,7 @@
 {
     "kind": "JSDocComment",
     "pos": 0,
-    "end": 5
+    "end": 5,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0
 }

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.leadingAsterisk.json

@@ -2,25 +2,35 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 27,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTypeTag",
             "pos": 8,
             "end": 22,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 13,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "type"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 14,
                 "end": 22,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 15,
-                    "end": 21
+                    "end": 21,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             }
         },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.less-than and greater-than characters.json

@@ -2,21 +2,29 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 61,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 7,
             "end": 59,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 8,
                 "end": 13,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 14,
                 "end": 15,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "x"
             },
             "isNameFirst": true,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.noLeadingAsterisk.json

@@ -2,25 +2,35 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 27,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTypeTag",
             "pos": 8,
             "end": 22,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 13,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "type"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 14,
                 "end": 22,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 15,
-                    "end": 21
+                    "end": 21,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             }
         },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.noReturnType.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 20,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocReturnTag",
             "pos": 8,
             "end": 15,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 15,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "return"
             }
         },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.oneParamTag.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 34,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 32,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 15,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 16,
-                    "end": 22
+                    "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 24,
                 "end": 29,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTag1.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 59,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 57,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 15,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 16,
-                    "end": 22
+                    "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 24,
                 "end": 29,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagBracketedName1.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 61,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 59,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 15,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 16,
-                    "end": 22
+                    "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 25,
                 "end": 30,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagBracketedName2.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 66,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 64,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 15,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 16,
-                    "end": 22
+                    "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 26,
                 "end": 31,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagNameThenType1.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 34,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 29,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 21,
                 "end": 29,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 22,
-                    "end": 28
+                    "end": 28,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 15,
                 "end": 20,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": true,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagNameThenType2.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 46,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 44,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 21,
                 "end": 29,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 22,
-                    "end": 28
+                    "end": 28,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 15,
                 "end": 20,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": true,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramWithoutType.json

@@ -2,21 +2,29 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 23,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 21,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 15,
                 "end": 18,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             },
             "isNameFirst": true,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.returnTag1.json

@@ -2,25 +2,35 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 29,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocReturnTag",
             "pos": 8,
             "end": 24,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 15,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "return"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 16,
                 "end": 24,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 17,
-                    "end": 23
+                    "end": 23,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             }
         },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.returnTag2.json

@@ -2,25 +2,35 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 54,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocReturnTag",
             "pos": 8,
             "end": 24,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 15,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "return"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 16,
                 "end": 24,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 17,
-                    "end": 23
+                    "end": 23,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "comment": "Description text follows"

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.returnsTag1.json

@@ -2,25 +2,35 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 30,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocReturnTag",
             "pos": 8,
             "end": 25,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 16,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "returns"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 17,
                 "end": 25,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 18,
-                    "end": 24
+                    "end": 24,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             }
         },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 24,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTemplateTag",
             "pos": 8,
             "end": 19,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "template"
             },
             "typeParameters": {
@@ -18,10 +24,14 @@
                     "kind": "TypeParameter",
                     "pos": 18,
                     "end": 19,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 18,
                         "end": 19,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "T"
                     }
                 },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag2.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 26,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTemplateTag",
             "pos": 8,
             "end": 21,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "template"
             },
             "typeParameters": {
@@ -18,10 +24,14 @@
                     "kind": "TypeParameter",
                     "pos": 18,
                     "end": 19,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 18,
                         "end": 19,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "K"
                     }
                 },
@@ -29,10 +39,14 @@
                     "kind": "TypeParameter",
                     "pos": 20,
                     "end": 21,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 20,
                         "end": 21,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "V"
                     }
                 },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag3.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 27,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTemplateTag",
             "pos": 8,
             "end": 22,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "template"
             },
             "typeParameters": {
@@ -18,10 +24,14 @@
                     "kind": "TypeParameter",
                     "pos": 18,
                     "end": 19,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 18,
                         "end": 19,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "K"
                     }
                 },
@@ -29,10 +39,14 @@
                     "kind": "TypeParameter",
                     "pos": 21,
                     "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 21,
                         "end": 22,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "V"
                     }
                 },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag4.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 27,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTemplateTag",
             "pos": 8,
             "end": 22,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "template"
             },
             "typeParameters": {
@@ -18,10 +24,14 @@
                     "kind": "TypeParameter",
                     "pos": 18,
                     "end": 19,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 18,
                         "end": 19,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "K"
                     }
                 },
@@ -29,10 +39,14 @@
                     "kind": "TypeParameter",
                     "pos": 21,
                     "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 21,
                         "end": 22,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "V"
                     }
                 },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag5.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 28,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTemplateTag",
             "pos": 8,
             "end": 23,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "template"
             },
             "typeParameters": {
@@ -18,10 +24,14 @@
                     "kind": "TypeParameter",
                     "pos": 18,
                     "end": 19,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 18,
                         "end": 19,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "K"
                     }
                 },
@@ -29,10 +39,14 @@
                     "kind": "TypeParameter",
                     "pos": 22,
                     "end": 23,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 22,
                         "end": 23,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "V"
                     }
                 },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag6.json

@@ -2,15 +2,21 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 60,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTemplateTag",
             "pos": 8,
             "end": 24,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 17,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "template"
             },
             "typeParameters": {
@@ -18,10 +24,14 @@
                     "kind": "TypeParameter",
                     "pos": 18,
                     "end": 19,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 18,
                         "end": 19,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "K"
                     }
                 },
@@ -29,10 +39,14 @@
                     "kind": "TypeParameter",
                     "pos": 22,
                     "end": 23,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "name": {
                         "kind": "Identifier",
                         "pos": 22,
                         "end": 23,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "V"
                     }
                 },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.threeAsterisks.json

@@ -2,5 +2,7 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 7,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "comment": "*"
 }

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.twoParamTag2.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 60,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 34,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 15,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 16,
-                    "end": 22
+                    "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 24,
                 "end": 29,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,
@@ -36,26 +48,36 @@
             "kind": "JSDocParameterTag",
             "pos": 34,
             "end": 58,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 35,
                 "end": 40,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 41,
                 "end": 49,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 42,
-                    "end": 48
+                    "end": 48,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 50,
                 "end": 55,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name2"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.twoParamTagOnSameLine.json

@@ -2,31 +2,43 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 56,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocParameterTag",
             "pos": 8,
             "end": 30,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 14,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 15,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 16,
-                    "end": 22
+                    "end": 22,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 24,
                 "end": 29,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name1"
             },
             "isNameFirst": false,
@@ -36,26 +48,36 @@
             "kind": "JSDocParameterTag",
             "pos": 30,
             "end": 54,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 31,
                 "end": 36,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "param"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 37,
                 "end": 45,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 38,
-                    "end": 44
+                    "end": 44,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 46,
                 "end": 51,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "name2"
             },
             "isNameFirst": false,

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.typeTag.json

@@ -2,25 +2,35 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 27,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTypeTag",
             "pos": 8,
             "end": 22,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 13,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "type"
             },
             "typeExpression": {
                 "kind": "JSDocTypeExpression",
                 "pos": 14,
                 "end": 22,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "type": {
                     "kind": "NumberKeyword",
                     "pos": 15,
-                    "end": 21
+                    "end": 21,
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0
                 }
             }
         },

tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.typedefTagWithChildrenTags.json

@@ -2,58 +2,80 @@
     "kind": "JSDocComment",
     "pos": 0,
     "end": 102,
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "tags": {
         "0": {
             "kind": "JSDocTypedefTag",
             "pos": 8,
             "end": 100,
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "tagName": {
                 "kind": "Identifier",
                 "pos": 9,
                 "end": 16,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "typedef"
             },
             "fullName": {
                 "kind": "Identifier",
                 "pos": 17,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "People"
             },
             "name": {
                 "kind": "Identifier",
                 "pos": 17,
                 "end": 23,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "People"
             },
             "typeExpression": {
                 "kind": "JSDocTypeLiteral",
                 "pos": 8,
                 "end": 100,
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "jsDocPropertyTags": [
                     {
                         "kind": "JSDocPropertyTag",
                         "pos": 47,
                         "end": 74,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "tagName": {
                             "kind": "Identifier",
                             "pos": 48,
                             "end": 56,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "escapedText": "property"
                         },
                         "typeExpression": {
                             "kind": "JSDocTypeExpression",
                             "pos": 57,
                             "end": 65,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "type": {
                                 "kind": "NumberKeyword",
                                 "pos": 58,
-                                "end": 64
+                                "end": 64,
+                                "modifierFlagsCache": 0,
+                                "transformFlags": 0
                             }
                         },
                         "name": {
                             "kind": "Identifier",
                             "pos": 66,
                             "end": 69,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "escapedText": "age"
                         },
                         "isNameFirst": false,
@@ -63,26 +85,36 @@
                         "kind": "JSDocPropertyTag",
                         "pos": 74,
                         "end": 100,
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "tagName": {
                             "kind": "Identifier",
                             "pos": 75,
                             "end": 83,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "escapedText": "property"
                         },
                         "typeExpression": {
                             "kind": "JSDocTypeExpression",
                             "pos": 84,
                             "end": 92,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "type": {
                                 "kind": "StringKeyword",
                                 "pos": 85,
-                                "end": 91
+                                "end": 91,
+                                "modifierFlagsCache": 0,
+                                "transformFlags": 0
                             }
                         },
                         "name": {
                             "kind": "Identifier",
                             "pos": 93,
                             "end": 97,
+                            "modifierFlagsCache": 0,
+                            "transformFlags": 0,
                             "escapedText": "name"
                         },
                         "isNameFirst": false,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.allType.json

@@ -2,5 +2,7 @@
     "kind": "JSDocAllType",
     "pos": 1,
     "end": 2,
-    "flags": "JSDoc"
+    "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.arrayType1.json

@@ -3,16 +3,22 @@
     "pos": 1,
     "end": 4,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementType": {
         "kind": "TypeReference",
         "pos": 1,
         "end": 2,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "typeName": {
             "kind": "Identifier",
             "pos": 1,
             "end": 2,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "escapedText": "a"
         }
     }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.arrayType2.json

@@ -3,21 +3,29 @@
     "pos": 1,
     "end": 6,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementType": {
         "kind": "ArrayType",
         "pos": 1,
         "end": 4,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "elementType": {
             "kind": "TypeReference",
             "pos": 1,
             "end": 2,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "typeName": {
                 "kind": "Identifier",
                 "pos": 1,
                 "end": 2,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "a"
             }
         }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.arrayType3.json

@@ -3,31 +3,43 @@
     "pos": 1,
     "end": 9,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "ParenthesizedType",
         "pos": 1,
         "end": 8,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "type": {
             "kind": "ArrayType",
             "pos": 2,
             "end": 7,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "elementType": {
                 "kind": "ArrayType",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "elementType": {
                     "kind": "TypeReference",
                     "pos": 2,
                     "end": 3,
                     "flags": "JSDoc",
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "typeName": {
                         "kind": "Identifier",
                         "pos": 2,
                         "end": 3,
                         "flags": "JSDoc",
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "a"
                     }
                 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.callSignatureInRecordType.json

@@ -3,12 +3,16 @@
     "pos": 1,
     "end": 13,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "CallSignature",
             "pos": 2,
             "end": 12,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "parameters": {
                 "length": 0,
                 "pos": 3,
@@ -18,7 +22,9 @@
                 "kind": "NumberKeyword",
                 "pos": 5,
                 "end": 12,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 1,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionReturnType1.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 26,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "0": {
             "kind": "Parameter",
             "pos": 10,
             "end": 16,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "type": {
                 "kind": "StringKeyword",
                 "pos": 10,
                 "end": 16,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "1": {
@@ -21,11 +27,15 @@
             "pos": 17,
             "end": 25,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "type": {
                 "kind": "BooleanKeyword",
                 "pos": 17,
                 "end": 25,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionType1.json

@@ -3,6 +3,8 @@
     "pos": 1,
     "end": 11,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "length": 0,
         "pos": 10,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionType2.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 26,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "0": {
             "kind": "Parameter",
             "pos": 10,
             "end": 16,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "type": {
                 "kind": "StringKeyword",
                 "pos": 10,
                 "end": 16,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "1": {
@@ -21,11 +27,15 @@
             "pos": 17,
             "end": 25,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "type": {
                 "kind": "BooleanKeyword",
                 "pos": 17,
                 "end": 25,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionTypeWithTrailingComma.json

@@ -3,22 +3,30 @@
     "pos": 1,
     "end": 13,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "0": {
             "kind": "Parameter",
             "pos": 10,
             "end": 11,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "type": {
                 "kind": "TypeReference",
                 "pos": 10,
                 "end": 11,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "typeName": {
                     "kind": "Identifier",
                     "pos": 10,
                     "end": 11,
                     "flags": "JSDoc",
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "escapedText": "a"
                 }
             }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword1.json

@@ -3,11 +3,15 @@
     "pos": 1,
     "end": 4,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "typeName": {
         "kind": "Identifier",
         "pos": 1,
         "end": 4,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "originalKeywordKind": "VarKeyword",
         "escapedText": "var"
     }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword2.json

@@ -2,5 +2,7 @@
     "kind": "NullKeyword",
     "pos": 1,
     "end": 5,
-    "flags": "JSDoc"
+    "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword3.json

@@ -2,5 +2,7 @@
     "kind": "UndefinedKeyword",
     "pos": 1,
     "end": 10,
-    "flags": "JSDoc"
+    "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.methodInRecordType.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 16,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "MethodSignature",
             "pos": 2,
             "end": 15,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             },
             "parameters": {
@@ -25,7 +31,9 @@
                 "kind": "NumberKeyword",
                 "pos": 8,
                 "end": 15,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 1,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.newType1.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 18,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "0": {
             "kind": "Parameter",
             "pos": 10,
             "end": 17,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 10,
                 "end": 13,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "originalKeywordKind": "NewKeyword",
                 "escapedText": "new"
             },
@@ -22,16 +28,22 @@
                 "pos": 14,
                 "end": 17,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "typeName": {
                     "kind": "FirstNode",
                     "pos": 14,
                     "end": 17,
                     "flags": "JSDoc",
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "left": {
                         "kind": "Identifier",
                         "pos": 14,
                         "end": 15,
                         "flags": "JSDoc",
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "a"
                     },
                     "right": {
@@ -39,6 +51,8 @@
                         "pos": 16,
                         "end": 17,
                         "flags": "JSDoc",
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "b"
                     }
                 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nonNullableType.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 8,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "NumberKeyword",
         "pos": 2,
         "end": 8,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nonNullableType2.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 8,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "NumberKeyword",
         "pos": 1,
         "end": 7,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nullableType.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 8,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "NumberKeyword",
         "pos": 2,
         "end": 8,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nullableType2.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 8,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "NumberKeyword",
         "pos": 1,
         "end": 7,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.optionalNullable.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 3,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "JSDocUnknownType",
         "pos": 1,
         "end": 2,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.optionalType.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 8,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "NumberKeyword",
         "pos": 1,
         "end": 7,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType1.json

@@ -3,6 +3,8 @@
     "pos": 1,
     "end": 3,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "length": 0,
         "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType2.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 6,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 5,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             }
         },

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType3.json

@@ -3,24 +3,32 @@
     "pos": 1,
     "end": 14,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 13,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             },
             "type": {
                 "kind": "NumberKeyword",
                 "pos": 6,
                 "end": 13,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 1,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType4.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 11,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 6,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             }
         },
@@ -22,11 +28,15 @@
             "pos": 6,
             "end": 10,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 6,
                 "end": 10,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "bar"
             }
         },

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType5.json

@@ -3,24 +3,32 @@
     "pos": 1,
     "end": 19,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 14,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             },
             "type": {
                 "kind": "NumberKeyword",
                 "pos": 6,
                 "end": 13,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "1": {
@@ -28,11 +36,15 @@
             "pos": 14,
             "end": 18,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 14,
                 "end": 18,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "bar"
             }
         },

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType6.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 19,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 6,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             }
         },
@@ -22,18 +28,24 @@
             "pos": 6,
             "end": 18,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 6,
                 "end": 10,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "bar"
             },
             "type": {
                 "kind": "NumberKeyword",
                 "pos": 11,
                 "end": 18,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType7.json

@@ -3,24 +3,32 @@
     "pos": 1,
     "end": 27,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 14,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 5,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "foo"
             },
             "type": {
                 "kind": "NumberKeyword",
                 "pos": 6,
                 "end": 13,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "1": {
@@ -28,18 +36,24 @@
             "pos": 14,
             "end": 26,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 14,
                 "end": 18,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "bar"
             },
             "type": {
                 "kind": "NumberKeyword",
                 "pos": 19,
                 "end": 26,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             }
         },
         "length": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType8.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 11,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 10,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 10,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "originalKeywordKind": "FunctionKeyword",
                 "escapedText": "function"
             }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.thisType1.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 19,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "0": {
             "kind": "Parameter",
             "pos": 10,
             "end": 18,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 10,
                 "end": 14,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "originalKeywordKind": "ThisKeyword",
                 "escapedText": "this"
             },
@@ -22,16 +28,22 @@
                 "pos": 15,
                 "end": 18,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "typeName": {
                     "kind": "FirstNode",
                     "pos": 15,
                     "end": 18,
                     "flags": "JSDoc",
+                    "modifierFlagsCache": 0,
+                    "transformFlags": 0,
                     "left": {
                         "kind": "Identifier",
                         "pos": 15,
                         "end": 16,
                         "flags": "JSDoc",
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "a"
                     },
                     "right": {
@@ -39,6 +51,8 @@
                         "pos": 17,
                         "end": 18,
                         "flags": "JSDoc",
+                        "modifierFlagsCache": 0,
+                        "transformFlags": 0,
                         "escapedText": "b"
                     }
                 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.topLevelNoParenUnionType.json

@@ -3,18 +3,24 @@
     "pos": 1,
     "end": 14,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "types": {
         "0": {
             "kind": "NumberKeyword",
             "pos": 1,
             "end": 7,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "1": {
             "kind": "StringKeyword",
             "pos": 8,
             "end": 14,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 2,
         "pos": 1,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.trailingCommaInRecordType.json

@@ -3,17 +3,23 @@
     "pos": 1,
     "end": 5,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "members": {
         "0": {
             "kind": "PropertySignature",
             "pos": 2,
             "end": 4,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "name": {
                 "kind": "Identifier",
                 "pos": 2,
                 "end": 3,
                 "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0,
                 "escapedText": "a"
             }
         },

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tsConstructorType.json

@@ -3,6 +3,8 @@
     "pos": 1,
     "end": 17,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "length": 0,
         "pos": 6,
@@ -12,6 +14,8 @@
         "kind": "StringKeyword",
         "pos": 10,
         "end": 17,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tsFunctionType.json

@@ -3,6 +3,8 @@
     "pos": 1,
     "end": 13,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "parameters": {
         "length": 0,
         "pos": 2,
@@ -12,6 +14,8 @@
         "kind": "StringKeyword",
         "pos": 6,
         "end": 13,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType0.json

@@ -3,6 +3,8 @@
     "pos": 1,
     "end": 3,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementTypes": {
         "length": 0,
         "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType1.json

@@ -3,12 +3,16 @@
     "pos": 1,
     "end": 9,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementTypes": {
         "0": {
             "kind": "NumberKeyword",
             "pos": 2,
             "end": 8,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 1,
         "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType2.json

@@ -3,18 +3,24 @@
     "pos": 1,
     "end": 16,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementTypes": {
         "0": {
             "kind": "NumberKeyword",
             "pos": 2,
             "end": 8,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "1": {
             "kind": "StringKeyword",
             "pos": 9,
             "end": 15,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 2,
         "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType3.json

@@ -3,24 +3,32 @@
     "pos": 1,
     "end": 24,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementTypes": {
         "0": {
             "kind": "NumberKeyword",
             "pos": 2,
             "end": 8,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "1": {
             "kind": "StringKeyword",
             "pos": 9,
             "end": 15,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "2": {
             "kind": "BooleanKeyword",
             "pos": 16,
             "end": 23,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 3,
         "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleTypeWithTrailingComma.json

@@ -3,12 +3,16 @@
     "pos": 1,
     "end": 10,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "elementTypes": {
         "0": {
             "kind": "NumberKeyword",
             "pos": 2,
             "end": 8,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 1,
         "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeArgumentsNotFollowingDot.json

@@ -3,11 +3,15 @@
     "pos": 1,
     "end": 4,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "typeName": {
         "kind": "Identifier",
         "pos": 1,
         "end": 2,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "escapedText": "a"
     },
     "typeArguments": {

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeOfType.json

@@ -3,11 +3,15 @@
     "pos": 1,
     "end": 9,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "exprName": {
         "kind": "Identifier",
         "pos": 7,
         "end": 9,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "escapedText": "M"
     }
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeReference1.json

@@ -3,11 +3,15 @@
     "pos": 1,
     "end": 11,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "typeName": {
         "kind": "Identifier",
         "pos": 1,
         "end": 2,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "escapedText": "a",
         "jsdocDotPos": 2
     },
@@ -16,7 +20,9 @@
             "kind": "NumberKeyword",
             "pos": 4,
             "end": 10,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 1,
         "pos": 4,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeReference2.json

@@ -3,11 +3,15 @@
     "pos": 1,
     "end": 18,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "typeName": {
         "kind": "Identifier",
         "pos": 1,
         "end": 2,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "escapedText": "a",
         "jsdocDotPos": 2
     },
@@ -16,13 +20,17 @@
             "kind": "NumberKeyword",
             "pos": 4,
             "end": 10,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "1": {
             "kind": "StringKeyword",
             "pos": 11,
             "end": 17,
-            "flags": "JSDoc"
+            "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0
         },
         "length": 2,
         "pos": 4,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeReference3.json

@@ -3,16 +3,22 @@
     "pos": 1,
     "end": 11,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "typeName": {
         "kind": "FirstNode",
         "pos": 1,
         "end": 11,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "left": {
             "kind": "Identifier",
             "pos": 1,
             "end": 2,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "escapedText": "a"
         },
         "right": {
@@ -20,6 +26,8 @@
             "pos": 3,
             "end": 11,
             "flags": "JSDoc",
+            "modifierFlagsCache": 0,
+            "transformFlags": 0,
             "originalKeywordKind": "FunctionKeyword",
             "escapedText": "function"
         }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.unionType.json

@@ -3,23 +3,31 @@
     "pos": 1,
     "end": 16,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "UnionType",
         "pos": 2,
         "end": 15,
         "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0,
         "types": {
             "0": {
                 "kind": "NumberKeyword",
                 "pos": 2,
                 "end": 8,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             },
             "1": {
                 "kind": "StringKeyword",
                 "pos": 9,
                 "end": 15,
-                "flags": "JSDoc"
+                "flags": "JSDoc",
+                "modifierFlagsCache": 0,
+                "transformFlags": 0
             },
             "length": 2,
             "pos": 2,

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.unknownType.json

@@ -2,5 +2,7 @@
     "kind": "JSDocUnknownType",
     "pos": 1,
     "end": 2,
-    "flags": "JSDoc"
+    "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0
 }

tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.variadicType.json

@@ -3,10 +3,14 @@
     "pos": 1,
     "end": 10,
     "flags": "JSDoc",
+    "modifierFlagsCache": 0,
+    "transformFlags": 0,
     "type": {
         "kind": "NumberKeyword",
         "pos": 4,
         "end": 10,
-        "flags": "JSDoc"
+        "flags": "JSDoc",
+        "modifierFlagsCache": 0,
+        "transformFlags": 0
     }
 }

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -8347,7 +8347,7 @@ declare namespace ts.server {
         excludedFiles: ReadonlyArray<NormalizedPath>;
         private typeAcquisition;
         updateGraph(): boolean;
-        getExcludedFiles(): readonly NormalizedPath[];
+        getExcludedFiles(): ReadonlyArray<NormalizedPath>;
         getTypeAcquisition(): TypeAcquisition;
         setTypeAcquisition(newTypeAcquisition: TypeAcquisition): void;
     }

tests/baselines/reference/forAwaitForUnion.symbols

@@ -5,7 +5,7 @@ async function f<T>(source: Iterable<T> | AsyncIterable<T>) {
 >source : Symbol(source, Decl(forAwaitForUnion.ts, 0, 20))
 >Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --))
 >T : Symbol(T, Decl(forAwaitForUnion.ts, 0, 17))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 >T : Symbol(T, Decl(forAwaitForUnion.ts, 0, 17))
 
     for await (const x of source) {

tests/baselines/reference/types.asyncGenerators.es2018.1.symbols

@@ -49,13 +49,13 @@ async function * inferReturnType8() {
 }
 const assignability1: () => AsyncIterableIterator<number> = async function * () {
 >assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.1.ts, 24, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield 1;
 };
 const assignability2: () => AsyncIterableIterator<number> = async function * () {
 >assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.es2018.1.ts, 27, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -65,13 +65,13 @@ const assignability2: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability3: () => AsyncIterableIterator<number> = async function * () {
 >assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.es2018.1.ts, 30, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [1, 2];
 };
 const assignability4: () => AsyncIterableIterator<number> = async function * () {
 >assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.es2018.1.ts, 33, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -81,19 +81,19 @@ const assignability4: () => AsyncIterableIterator<number> = async function * ()
 };
 const assignability5: () => AsyncIterableIterator<number> = async function * () {
 >assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.es2018.1.ts, 36, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield 1; })();
 };
 const assignability6: () => AsyncIterable<number> = async function * () {
 >assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.es2018.1.ts, 39, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield 1;
 };
 const assignability7: () => AsyncIterable<number> = async function * () {
 >assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.es2018.1.ts, 42, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -103,13 +103,13 @@ const assignability7: () => AsyncIterable<number> = async function * () {
 };
 const assignability8: () => AsyncIterable<number> = async function * () {
 >assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.es2018.1.ts, 45, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [1, 2];
 };
 const assignability9: () => AsyncIterable<number> = async function * () {
 >assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.es2018.1.ts, 48, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -119,19 +119,19 @@ const assignability9: () => AsyncIterable<number> = async function * () {
 };
 const assignability10: () => AsyncIterable<number> = async function * () {
 >assignability10 : Symbol(assignability10, Decl(types.asyncGenerators.es2018.1.ts, 51, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield 1; })();
 };
 const assignability11: () => AsyncIterator<number> = async function * () {
 >assignability11 : Symbol(assignability11, Decl(types.asyncGenerators.es2018.1.ts, 54, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield 1;
 };
 const assignability12: () => AsyncIterator<number> = async function * () {
 >assignability12 : Symbol(assignability12, Decl(types.asyncGenerators.es2018.1.ts, 57, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -141,13 +141,13 @@ const assignability12: () => AsyncIterator<number> = async function * () {
 };
 const assignability13: () => AsyncIterator<number> = async function * () {
 >assignability13 : Symbol(assignability13, Decl(types.asyncGenerators.es2018.1.ts, 60, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [1, 2];
 };
 const assignability14: () => AsyncIterator<number> = async function * () {
 >assignability14 : Symbol(assignability14, Decl(types.asyncGenerators.es2018.1.ts, 63, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -157,19 +157,19 @@ const assignability14: () => AsyncIterator<number> = async function * () {
 };
 const assignability15: () => AsyncIterator<number> = async function * () {
 >assignability15 : Symbol(assignability15, Decl(types.asyncGenerators.es2018.1.ts, 66, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield 1; })();
 };
 async function * explicitReturnType1(): AsyncIterableIterator<number> {
 >explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.es2018.1.ts, 68, 2))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield 1;
 }
 async function * explicitReturnType2(): AsyncIterableIterator<number> {
 >explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.es2018.1.ts, 71, 1))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -178,13 +178,13 @@ async function * explicitReturnType2(): AsyncIterableIterator<number> {
 }
 async function * explicitReturnType3(): AsyncIterableIterator<number> {
 >explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.1.ts, 74, 1))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [1, 2];
 }
 async function * explicitReturnType4(): AsyncIterableIterator<number> {
 >explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.es2018.1.ts, 77, 1))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -193,19 +193,19 @@ async function * explicitReturnType4(): AsyncIterableIterator<number> {
 }
 async function * explicitReturnType5(): AsyncIterableIterator<number> {
 >explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.1.ts, 80, 1))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield 1; })();
 }
 async function * explicitReturnType6(): AsyncIterable<number> {
 >explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.es2018.1.ts, 83, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield 1;
 }
 async function * explicitReturnType7(): AsyncIterable<number> {
 >explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.es2018.1.ts, 86, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -214,13 +214,13 @@ async function * explicitReturnType7(): AsyncIterable<number> {
 }
 async function * explicitReturnType8(): AsyncIterable<number> {
 >explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.1.ts, 89, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [1, 2];
 }
 async function * explicitReturnType9(): AsyncIterable<number> {
 >explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.es2018.1.ts, 92, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -229,19 +229,19 @@ async function * explicitReturnType9(): AsyncIterable<number> {
 }
 async function * explicitReturnType10(): AsyncIterable<number> {
 >explicitReturnType10 : Symbol(explicitReturnType10, Decl(types.asyncGenerators.es2018.1.ts, 95, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield 1; })();
 }
 async function * explicitReturnType11(): AsyncIterator<number> {
 >explicitReturnType11 : Symbol(explicitReturnType11, Decl(types.asyncGenerators.es2018.1.ts, 98, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield 1;
 }
 async function * explicitReturnType12(): AsyncIterator<number> {
 >explicitReturnType12 : Symbol(explicitReturnType12, Decl(types.asyncGenerators.es2018.1.ts, 101, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield Promise.resolve(1);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -250,13 +250,13 @@ async function * explicitReturnType12(): AsyncIterator<number> {
 }
 async function * explicitReturnType13(): AsyncIterator<number> {
 >explicitReturnType13 : Symbol(explicitReturnType13, Decl(types.asyncGenerators.es2018.1.ts, 104, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [1, 2];
 }
 async function * explicitReturnType14(): AsyncIterator<number> {
 >explicitReturnType14 : Symbol(explicitReturnType14, Decl(types.asyncGenerators.es2018.1.ts, 107, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* [Promise.resolve(1)];
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
@@ -265,7 +265,7 @@ async function * explicitReturnType14(): AsyncIterator<number> {
 }
 async function * explicitReturnType15(): AsyncIterator<number> {
 >explicitReturnType15 : Symbol(explicitReturnType15, Decl(types.asyncGenerators.es2018.1.ts, 110, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield 1; })();
 }

tests/baselines/reference/types.asyncGenerators.es2018.2.symbols

@@ -20,109 +20,109 @@ async function * inferReturnType3() {
 }
 const assignability1: () => AsyncIterableIterator<number> = async function * () {
 >assignability1 : Symbol(assignability1, Decl(types.asyncGenerators.es2018.2.ts, 9, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield "a";
 };
 const assignability2: () => AsyncIterableIterator<number> = async function * () {
 >assignability2 : Symbol(assignability2, Decl(types.asyncGenerators.es2018.2.ts, 12, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* ["a", "b"];
 };
 const assignability3: () => AsyncIterableIterator<number> = async function * () {
 >assignability3 : Symbol(assignability3, Decl(types.asyncGenerators.es2018.2.ts, 15, 5))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield "a"; })();
 };
 const assignability4: () => AsyncIterable<number> = async function * () {
 >assignability4 : Symbol(assignability4, Decl(types.asyncGenerators.es2018.2.ts, 18, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield "a";
 };
 const assignability5: () => AsyncIterable<number> = async function * () {
 >assignability5 : Symbol(assignability5, Decl(types.asyncGenerators.es2018.2.ts, 21, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* ["a", "b"];
 };
 const assignability6: () => AsyncIterable<number> = async function * () {
 >assignability6 : Symbol(assignability6, Decl(types.asyncGenerators.es2018.2.ts, 24, 5))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield "a"; })();
 };
 const assignability7: () => AsyncIterator<number> = async function * () {
 >assignability7 : Symbol(assignability7, Decl(types.asyncGenerators.es2018.2.ts, 27, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield "a";
 };
 const assignability8: () => AsyncIterator<number> = async function * () {
 >assignability8 : Symbol(assignability8, Decl(types.asyncGenerators.es2018.2.ts, 30, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* ["a", "b"];
 };
 const assignability9: () => AsyncIterator<number> = async function * () {
 >assignability9 : Symbol(assignability9, Decl(types.asyncGenerators.es2018.2.ts, 33, 5))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield "a"; })();
 };
 async function * explicitReturnType1(): AsyncIterableIterator<number> {
 >explicitReturnType1 : Symbol(explicitReturnType1, Decl(types.asyncGenerators.es2018.2.ts, 35, 2))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield "a";
 }
 async function * explicitReturnType2(): AsyncIterableIterator<number> {
 >explicitReturnType2 : Symbol(explicitReturnType2, Decl(types.asyncGenerators.es2018.2.ts, 38, 1))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* ["a", "b"];
 }
 async function * explicitReturnType3(): AsyncIterableIterator<number> {
 >explicitReturnType3 : Symbol(explicitReturnType3, Decl(types.asyncGenerators.es2018.2.ts, 41, 1))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield "a"; })();
 }
 async function * explicitReturnType4(): AsyncIterable<number> {
 >explicitReturnType4 : Symbol(explicitReturnType4, Decl(types.asyncGenerators.es2018.2.ts, 44, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield "a";
 }
 async function * explicitReturnType5(): AsyncIterable<number> {
 >explicitReturnType5 : Symbol(explicitReturnType5, Decl(types.asyncGenerators.es2018.2.ts, 47, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* ["a", "b"];
 }
 async function * explicitReturnType6(): AsyncIterable<number> {
 >explicitReturnType6 : Symbol(explicitReturnType6, Decl(types.asyncGenerators.es2018.2.ts, 50, 1))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield "a"; })();
 }
 async function * explicitReturnType7(): AsyncIterator<number> {
 >explicitReturnType7 : Symbol(explicitReturnType7, Decl(types.asyncGenerators.es2018.2.ts, 53, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield "a";
 }
 async function * explicitReturnType8(): AsyncIterator<number> {
 >explicitReturnType8 : Symbol(explicitReturnType8, Decl(types.asyncGenerators.es2018.2.ts, 56, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* ["a", "b"];
 }
 async function * explicitReturnType9(): AsyncIterator<number> {
 >explicitReturnType9 : Symbol(explicitReturnType9, Decl(types.asyncGenerators.es2018.2.ts, 59, 1))
->AsyncIterator : Symbol(AsyncIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterator : Symbol(AsyncIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
     yield* (async function * () { yield "a"; })();
 }

tests/baselines/reference/types.forAwait.es2018.1.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/forAwait/types.forAwait.es2018.1.ts ===
 declare const asyncIterable: AsyncIterable<number>;
 >asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.1.ts, 0, 13))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
 declare const iterable: Iterable<number>;
 >iterable : Symbol(iterable, Decl(types.forAwait.es2018.1.ts, 1, 13))

tests/baselines/reference/types.forAwait.es2018.2.symbols

@@ -1,7 +1,7 @@
 === tests/cases/conformance/types/forAwait/types.forAwait.es2018.2.ts ===
 declare const asyncIterable: AsyncIterable<number>;
 >asyncIterable : Symbol(asyncIterable, Decl(types.forAwait.es2018.2.ts, 0, 13))
->AsyncIterable : Symbol(AsyncIterable, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterable : Symbol(AsyncIterable, Decl(lib.es2018.asynciterable.d.ts, --, --))
 
 declare const iterable: Iterable<number>;
 >iterable : Symbol(iterable, Decl(types.forAwait.es2018.2.ts, 1, 13))

tests/baselines/reference/uniqueSymbols.symbols

@@ -743,7 +743,7 @@ interface Context {
 
     method3(): AsyncIterableIterator<typeof s>;
 >method3 : Symbol(Context.method3, Decl(uniqueSymbols.ts, 219, 33))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 >s : Symbol(s, Decl(uniqueSymbols.ts, 119, 13))
 
     method4(): IterableIterator<typeof s>;

tests/baselines/reference/uniqueSymbolsDeclarations.symbols

@@ -738,7 +738,7 @@ interface Context {
 
     method3(): AsyncIterableIterator<typeof s>;
 >method3 : Symbol(Context.method3, Decl(uniqueSymbolsDeclarations.ts, 215, 33))
->AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.esnext.asynciterable.d.ts, --, --))
+>AsyncIterableIterator : Symbol(AsyncIterableIterator, Decl(lib.es2018.asynciterable.d.ts, --, --))
 >s : Symbol(s, Decl(uniqueSymbolsDeclarations.ts, 115, 13))
 
     method4(): IterableIterator<typeof s>;