From 4dd701a22c5a4256a225f52ad393066e28a348a2 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 15:02:13 -0700
Subject: [PATCH 1/9] Added overload for 'String#match' to take objects with
 '[Symbol.match]' method.

---
 src/lib/es6.d.ts | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index 10358a5e74d..f4c87636dec 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -425,6 +425,14 @@ interface String {
       */
     startsWith(searchString: string, position?: number): boolean;
 
+    // Overloads for objects with methods of well-known symbols.
+
+    /**
+      * Matches a string an object that supports being matched against, and returns an array containing the results of that search.
+      * @param regexpLike An object that supports being matched against.
+      */
+    match(regexpLike: { [Symbol.match](string: string): RegExpMatchArray; }): RegExpMatchArray;
+
     /**
       * Returns an <a> HTML anchor element and sets the name attribute to the text value
       * @param name

From 25d55b5101153ed14af334f72466f9ea2bf46107 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 15:02:46 -0700
Subject: [PATCH 2/9] Added overload for 'String#replace' to take objects with
 '[Symbol.replace]' method.

---
 src/lib/es6.d.ts | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index f4c87636dec..fddf9db79ac 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -433,6 +433,20 @@ interface String {
       */
     match(regexpLike: { [Symbol.match](string: string): RegExpMatchArray; }): RegExpMatchArray;
 
+    /**
+      * Replaces text in a string, using an object that supports replacement within a string.
+      * @param searchValue A object can search for and replace matches within a string.
+      * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
+      */
+    replace(searchValue: { [Symbol.replace](string: string, replaceValue: string): string; }, replaceValue: string): string;
+
+    /**
+      * Replaces text in a string, using an object that supports replacement within a string.
+      * @param searchValue A object can search for and replace matches within a string.
+      * @param replacer A function that returns the replacement text.
+      */
+    replace(searchValue: { [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string; }, replacer: (substring: string, ...args: any[]) => string): string;
+
     /**
       * Returns an <a> HTML anchor element and sets the name attribute to the text value
       * @param name

From 312df84934204e6683456c131d7ed8b420425082 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 15:06:10 -0700
Subject: [PATCH 3/9] Added overload for 'String#search' to take objects with
 '[Symbol.search]' method.

---
 src/lib/es6.d.ts | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index fddf9db79ac..e9a23cc2eea 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -429,9 +429,9 @@ interface String {
 
     /**
       * Matches a string an object that supports being matched against, and returns an array containing the results of that search.
-      * @param regexpLike An object that supports being matched against.
+      * @param matcher An object that supports being matched against.
       */
-    match(regexpLike: { [Symbol.match](string: string): RegExpMatchArray; }): RegExpMatchArray;
+    match(matcher: { [Symbol.match](string: string): RegExpMatchArray; }): RegExpMatchArray;
 
     /**
       * Replaces text in a string, using an object that supports replacement within a string.
@@ -447,6 +447,12 @@ interface String {
       */
     replace(searchValue: { [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string; }, replacer: (substring: string, ...args: any[]) => string): string;
 
+    /**
+      * Finds the first substring match in a regular expression search.
+      * @param searcher An object which supports searching within a string.
+      */
+    search(searcher: { [Symbol.search](string: string): number; }): number;
+
     /**
       * Returns an <a> HTML anchor element and sets the name attribute to the text value
       * @param name

From 08f37cc2fa8fe07bea95584e312b9ad846793406 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 15:09:25 -0700
Subject: [PATCH 4/9] Added overload for 'String#split' to take objects with
 '[Symbol.split]' method.

---
 src/lib/es6.d.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index e9a23cc2eea..83000e7d4b5 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -453,6 +453,13 @@ interface String {
       */
     search(searcher: { [Symbol.search](string: string): number; }): number;
 
+    /**
+      * Split a string into substrings using the specified separator and return them as an array.
+      * @param splitter An object that can split a string.
+      * @param limit A value used to limit the number of elements returned in the array.
+      */
+    split(splitter: { [Symbol.split](string: string, limit?: number): string[]; }, limit?: number): string[];
+
     /**
       * Returns an <a> HTML anchor element and sets the name attribute to the text value
       * @param name

From f36f510411ab3248b74ed29899bdc7b83645a426 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 15:46:51 -0700
Subject: [PATCH 5/9] Fix documentation for methods of the 'String' interface.

---
 src/lib/core.d.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/lib/core.d.ts b/src/lib/core.d.ts
index bffdac3a3e2..5e858e12faa 100644
--- a/src/lib/core.d.ts
+++ b/src/lib/core.d.ts
@@ -316,22 +316,22 @@ interface String {
 
     /**
       * Replaces text in a string, using a regular expression or search string.
-      * @param searchValue A String object or string literal that represents the regular expression
-      * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.
+      * @param searchValue A string that represents the regular expression.
+      * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
       */
     replace(searchValue: string, replaceValue: string): string;
 
     /**
       * Replaces text in a string, using a regular expression or search string.
-      * @param searchValue A String object or string literal that represents the regular expression
+      * @param searchValue A string that represents the regular expression.
       * @param replacer A function that returns the replacement text.
       */
     replace(searchValue: string, replacer: (substring: string, ...args: any[]) => string): string;
 
     /**
       * Replaces text in a string, using a regular expression or search string.
-      * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags
-      * @param replaceValue A String object or string literal containing the text to replace for every successful match of rgExp in stringObj.
+      * @param searchValue A Regular Expression object containing the regular expression pattern and applicable flags.
+      * @param replaceValue A string containing the text to replace for every successful match of searchValue in this string.
       */
     replace(searchValue: RegExp, replaceValue: string): string;
 

From b27ab24343a9fd9cb27da66d6d2aeba93d54ce8a Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 15:53:31 -0700
Subject: [PATCH 6/9] Updated 'Reflect.construct' to add third 'newTarget'
 argument.

---
 src/lib/es6.d.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index 83000e7d4b5..dbf642ef71f 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -3652,7 +3652,7 @@ declare var Proxy: ProxyConstructor;
 
 declare module Reflect {
     function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
-    function construct(target: Function, argumentsList: ArrayLike<any>): any;
+    function construct(target: Function, argumentsList: ArrayLike<any>, newTarget?: any): any;
     function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;
     function deleteProperty(target: any, propertyKey: PropertyKey): boolean;
     function enumerate(target: any): IterableIterator<any>;

From af05e46b2877edfbc239ade1a46d05b387568bd8 Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 17:11:10 -0700
Subject: [PATCH 7/9] Added overloads for typed array constructors to take an
 'Iterable<number>'.

---
 src/lib/core.d.ts | 2 +-
 src/lib/es6.d.ts  | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/lib/core.d.ts b/src/lib/core.d.ts
index a9ccd197260..7259ff5081c 100644
--- a/src/lib/core.d.ts
+++ b/src/lib/core.d.ts
@@ -3822,4 +3822,4 @@ interface Float64ArrayConstructor {
       */
     from(arrayLike: ArrayLike<number>, mapfn?: (v: number, k: number) => number, thisArg?: any): Float64Array;
 }
-declare var Float64Array: Float64ArrayConstructor;
+declare var Float64Array: Float64ArrayConstructor;
diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index b356be7edef..2286a20daad 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -885,6 +885,7 @@ interface Int8Array {
 }
 
 interface Int8ArrayConstructor {
+    new (elements: Iterable<number>): Int8Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -915,6 +916,7 @@ interface Uint8Array {
 }
 
 interface Uint8ArrayConstructor {
+    new (elements: Iterable<number>): Uint8Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -948,6 +950,7 @@ interface Uint8ClampedArray {
 }
 
 interface Uint8ClampedArrayConstructor {
+    new (elements: Iterable<number>): Uint8ClampedArray;

 
     /**
       * Creates an array from an array-like or iterable object.
@@ -983,6 +986,7 @@ interface Int16Array {
 }
 
 interface Int16ArrayConstructor {
+    new (elements: Iterable<number>): Int16Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1013,6 +1017,7 @@ interface Uint16Array {
 }
 
 interface Uint16ArrayConstructor {
+    new (elements: Iterable<number>): Uint16Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1043,6 +1048,7 @@ interface Int32Array {
 }
 
 interface Int32ArrayConstructor {
+    new (elements: Iterable<number>): Int32Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1073,6 +1079,7 @@ interface Uint32Array {
 }
 
 interface Uint32ArrayConstructor {
+    new (elements: Iterable<number>): Uint32Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1103,6 +1110,7 @@ interface Float32Array {
 }
 
 interface Float32ArrayConstructor {
+    new (elements: Iterable<number>): Float32Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1133,6 +1141,7 @@ interface Float64Array {
 }
 
 interface Float64ArrayConstructor {
+    new (elements: Iterable<number>): Float64Array;

     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.

From fc39c4aa6001cbc1ec61de554270b3bcab3d383d Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 17:23:14 -0700
Subject: [PATCH 8/9] Accepted baselines.

---
 .../argumentsObjectIterator02_ES6.symbols     |   6 +-
 .../reference/arrayLiterals2ES6.symbols       |   6 +-
 .../reference/asyncArrowFunction1_es6.symbols |   2 +-
 .../reference/asyncAwait_es6.symbols          |  20 +-
 .../asyncFunctionDeclaration11_es6.symbols    |   2 +-
 .../asyncFunctionDeclaration14_es6.symbols    |   2 +-
 .../asyncFunctionDeclaration1_es6.symbols     |   2 +-
 .../awaitBinaryExpression1_es6.symbols        |   4 +-
 .../awaitBinaryExpression2_es6.symbols        |   4 +-
 .../awaitBinaryExpression3_es6.symbols        |   4 +-
 .../awaitBinaryExpression4_es6.symbols        |   4 +-
 .../awaitBinaryExpression5_es6.symbols        |   4 +-
 .../awaitCallExpression1_es6.symbols          |   8 +-
 .../awaitCallExpression2_es6.symbols          |   8 +-
 .../awaitCallExpression3_es6.symbols          |   8 +-
 .../awaitCallExpression4_es6.symbols          |   8 +-
 .../awaitCallExpression5_es6.symbols          |   8 +-
 .../awaitCallExpression6_es6.symbols          |   8 +-
 .../awaitCallExpression7_es6.symbols          |   8 +-
 .../awaitCallExpression8_es6.symbols          |   8 +-
 .../reference/callWithSpreadES6.symbols       |   2 +-
 ...tructuringParameterDeclaration3ES5.symbols |  16 +-
 ...tructuringParameterDeclaration3ES6.symbols |  16 +-
 ...owFunctionWhenUsingArguments14_ES6.symbols |   2 +-
 ...owFunctionWhenUsingArguments15_ES6.symbols |   2 +-
 ...owFunctionWhenUsingArguments16_ES6.symbols |   2 +-
 ...owFunctionWhenUsingArguments17_ES6.symbols |   2 +-
 ...owFunctionWhenUsingArguments18_ES6.symbols |   2 +-
 tests/baselines/reference/for-of13.symbols    |   4 +-
 tests/baselines/reference/for-of18.symbols    |   6 +-
 tests/baselines/reference/for-of19.symbols    |   6 +-
 tests/baselines/reference/for-of20.symbols    |   6 +-
 tests/baselines/reference/for-of21.symbols    |   6 +-
 tests/baselines/reference/for-of22.symbols    |   6 +-
 tests/baselines/reference/for-of23.symbols    |   6 +-
 tests/baselines/reference/for-of25.symbols    |   6 +-
 tests/baselines/reference/for-of26.symbols    |   6 +-
 tests/baselines/reference/for-of27.symbols    |   6 +-
 tests/baselines/reference/for-of28.symbols    |   6 +-
 tests/baselines/reference/for-of37.symbols    |   2 +-
 tests/baselines/reference/for-of38.symbols    |   2 +-
 tests/baselines/reference/for-of40.symbols    |   2 +-
 tests/baselines/reference/for-of44.symbols    |   2 +-
 tests/baselines/reference/for-of45.symbols    |   2 +-
 tests/baselines/reference/for-of50.symbols    |   2 +-
 tests/baselines/reference/for-of57.symbols    |   2 +-
 .../reference/generatorES6_6.symbols          |   6 +-
 .../reference/generatorOverloads4.symbols     |   6 +-
 .../reference/generatorOverloads5.symbols     |   6 +-
 .../reference/generatorTypeCheck1.symbols     |   2 +-
 .../reference/generatorTypeCheck10.symbols    |   2 +-
 .../reference/generatorTypeCheck11.symbols    |   2 +-
 .../reference/generatorTypeCheck12.symbols    |   2 +-
 .../reference/generatorTypeCheck13.symbols    |   2 +-
 .../reference/generatorTypeCheck17.symbols    |   2 +-
 .../reference/generatorTypeCheck19.symbols    |   2 +-
 .../reference/generatorTypeCheck2.symbols     |   2 +-
 .../reference/generatorTypeCheck26.symbols    |   2 +-
 .../reference/generatorTypeCheck27.symbols    |   2 +-
 .../reference/generatorTypeCheck28.symbols    |   8 +-
 .../reference/generatorTypeCheck29.symbols    |   4 +-
 .../reference/generatorTypeCheck3.symbols     |   2 +-
 .../reference/generatorTypeCheck30.symbols    |   4 +-
 .../reference/generatorTypeCheck45.symbols    |   2 +-
 .../reference/generatorTypeCheck46.symbols    |   8 +-
 .../reference/iterableArrayPattern1.symbols   |   8 +-
 .../reference/iterableArrayPattern11.symbols  |   6 +-
 .../reference/iterableArrayPattern12.symbols  |   6 +-
 .../reference/iterableArrayPattern13.symbols  |   6 +-
 .../reference/iterableArrayPattern2.symbols   |   8 +-
 .../reference/iterableArrayPattern3.symbols   |   6 +-
 .../reference/iterableArrayPattern30.symbols  |   2 +-
 .../reference/iterableArrayPattern4.symbols   |   6 +-
 .../reference/iterableArrayPattern9.symbols   |   6 +-
 .../iterableContextualTyping1.symbols         |   2 +-
 .../reference/iteratorSpreadInArray.symbols   |   8 +-
 .../reference/iteratorSpreadInArray11.symbols |   2 +-
 .../reference/iteratorSpreadInArray2.symbols  |  14 +-
 .../reference/iteratorSpreadInArray3.symbols  |   8 +-
 .../reference/iteratorSpreadInArray4.symbols  |   8 +-
 .../reference/iteratorSpreadInArray7.symbols  |   8 +-
 .../reference/iteratorSpreadInCall11.symbols  |   8 +-
 .../reference/iteratorSpreadInCall12.symbols  |  14 +-
 .../reference/iteratorSpreadInCall3.symbols   |   8 +-
 .../reference/iteratorSpreadInCall5.symbols   |  14 +-
 .../reference/parserSymbolProperty1.symbols   |   6 +-
 .../reference/parserSymbolProperty2.symbols   |   6 +-
 .../reference/parserSymbolProperty3.symbols   |   6 +-
 .../reference/parserSymbolProperty4.symbols   |   6 +-
 .../reference/parserSymbolProperty5.symbols   |   6 +-
 .../reference/parserSymbolProperty6.symbols   |   6 +-
 .../reference/parserSymbolProperty7.symbols   |   6 +-
 .../reference/parserSymbolProperty8.symbols   |   6 +-
 .../reference/parserSymbolProperty9.symbols   |   6 +-
 .../promiseVoidErrorCallback.symbols          |  16 +-
 .../reference/stringIncludes.symbols          |   8 +-
 .../superSymbolIndexedAccess1.symbols         |   6 +-
 .../superSymbolIndexedAccess2.symbols         |  18 +-
 .../reference/symbolDeclarationEmit1.symbols  |   6 +-
 .../reference/symbolDeclarationEmit10.symbols |  12 +-
 .../reference/symbolDeclarationEmit11.symbols |  24 +-
 .../reference/symbolDeclarationEmit13.symbols |  12 +-
 .../reference/symbolDeclarationEmit14.symbols |  12 +-
 .../reference/symbolDeclarationEmit2.symbols  |   6 +-
 .../reference/symbolDeclarationEmit3.symbols  |  18 +-
 .../reference/symbolDeclarationEmit4.symbols  |  12 +-
 .../reference/symbolDeclarationEmit5.symbols  |   6 +-
 .../reference/symbolDeclarationEmit6.symbols  |   6 +-
 .../reference/symbolDeclarationEmit7.symbols  |   6 +-
 .../reference/symbolDeclarationEmit8.symbols  |   6 +-
 .../reference/symbolDeclarationEmit9.symbols  |   6 +-
 .../reference/symbolProperty11.symbols        |   6 +-
 .../reference/symbolProperty13.symbols        |  12 +-
 .../reference/symbolProperty14.symbols        |  12 +-
 .../reference/symbolProperty15.symbols        |   6 +-
 .../reference/symbolProperty16.symbols        |  12 +-
 .../reference/symbolProperty18.symbols        |  36 +--
 .../reference/symbolProperty19.symbols        |  24 +-
 .../reference/symbolProperty2.symbols         |   2 +-
 .../reference/symbolProperty20.symbols        |  24 +-
 .../reference/symbolProperty22.symbols        |  12 +-
 .../reference/symbolProperty23.symbols        |  12 +-
 .../reference/symbolProperty26.symbols        |  12 +-
 .../reference/symbolProperty27.symbols        |  12 +-
 .../reference/symbolProperty28.symbols        |  12 +-
 .../reference/symbolProperty4.symbols         |   6 +-
 .../reference/symbolProperty40.symbols        |  30 +-
 .../reference/symbolProperty41.symbols        |  30 +-
 .../reference/symbolProperty45.symbols        |  12 +-
 .../reference/symbolProperty5.symbols         |  18 +-
 .../reference/symbolProperty50.symbols        |   6 +-
 .../reference/symbolProperty51.symbols        |   6 +-
 .../reference/symbolProperty55.symbols        |  12 +-
 .../reference/symbolProperty56.symbols        |   6 +-
 .../reference/symbolProperty57.symbols        |   8 +-
 .../reference/symbolProperty6.symbols         |  24 +-
 .../reference/symbolProperty8.symbols         |  12 +-
 .../baselines/reference/symbolType11.symbols  |   6 +-
 .../baselines/reference/symbolType16.symbols  |   2 +-
 ...teStringWithEmbeddedNewOperatorES6.symbols |   2 +-
 ...typeArgumentInferenceApparentType1.symbols |   2 +-
 ...typeArgumentInferenceApparentType2.symbols |   4 +-
 tests/baselines/reference/typedArrays.symbols | 288 +++++++++---------
 143 files changed, 681 insertions(+), 681 deletions(-)

diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
index afbc1c28621..2c5e611de68 100644
--- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
+++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols
@@ -9,9 +9,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe
     let blah = arguments[Symbol.iterator];
 >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7))
 >arguments : Symbol(arguments)
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
     let result = [];
 >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7))
diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols
index 8d94cc6aa67..fd31800e840 100644
--- a/tests/baselines/reference/arrayLiterals2ES6.symbols
+++ b/tests/baselines/reference/arrayLiterals2ES6.symbols
@@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]];
 
 interface myArray extends Array<Number> { }
 >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 interface myArray2 extends Array<Number|String> { }
 >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 var d0 = [1, true, ...temp, ];  // has type (string|number|boolean)[]
 >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3))
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
index 3561f217ba8..0da7c4433b3 100644
--- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
@@ -2,6 +2,6 @@
 
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 };
diff --git a/tests/baselines/reference/asyncAwait_es6.symbols b/tests/baselines/reference/asyncAwait_es6.symbols
index a7cb875bbdb..6f492b07d1b 100644
--- a/tests/baselines/reference/asyncAwait_es6.symbols
+++ b/tests/baselines/reference/asyncAwait_es6.symbols
@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
index b913ff5523e..f7574402c80 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
index 9e316ad2ee4..97dc419ba47 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
   return;
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
index 98fdef67031..35e4394c82d 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 }
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
index 7fe72e187dc..b91d8bf9492 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = await p || a;
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
index 3ec32232d7d..60127a06b90 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = await p && a;
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
index 5788b69d875..83f006bc285 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
@@ -4,11 +4,11 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = await p + a;
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
index 1a8c1fc20df..38e9ccfe608 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = await p, a;
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
index 69abaaf1b51..161d697b75b 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var o: { a: boolean; };
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols
index ac4852c6eac..8c6494d34af 100644
--- a/tests/baselines/reference/awaitCallExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = fn(a, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols
index 5fa26def527..db8cff67f01 100644
--- a/tests/baselines/reference/awaitCallExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = fn(await p, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols
index 53d11f34a80..e2b0e8a9137 100644
--- a/tests/baselines/reference/awaitCallExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = fn(a, await p, a);
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols
index 479e8de989f..75067422152 100644
--- a/tests/baselines/reference/awaitCallExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = (await pfn)(a, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols
index 717714a6bb7..d9c9cb9ed9a 100644
--- a/tests/baselines/reference/awaitCallExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = o.fn(a, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols
index 880673fd659..ee9779e68e8 100644
--- a/tests/baselines/reference/awaitCallExpression6_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = o.fn(await p, a, a);
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols
index 2cd5878bf24..51ce2db20a2 100644
--- a/tests/baselines/reference/awaitCallExpression7_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = o.fn(a, await p, a);
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols
index 6a0a08e566e..be3a841cce1 100644
--- a/tests/baselines/reference/awaitCallExpression8_es6.symbols
+++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32))
@@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; };
 
 declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43))
@@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 
     "before";
     var b = (await po).fn(a, a, a);
diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols
index d8569eeb1ff..8e84f48948f 100644
--- a/tests/baselines/reference/callWithSpreadES6.symbols
+++ b/tests/baselines/reference/callWithSpreadES6.symbols
@@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc");
 >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3))
 
 (<Function>xa[1].foo)(...[1, 2, "abc"]);
->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 4008, 1))
+>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 4009, 1))
 >xa[1].foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13))
 >xa : Symbol(xa, Decl(callWithSpreadES6.ts, 11, 3))
 >foo : Symbol(X.foo, Decl(callWithSpreadES6.ts, 1, 13))
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
index d4d41c14b72..24774958941 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols
@@ -8,18 +8,18 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES5.ts, 8, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -33,8 +33,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES5.ts, 13, 36))
diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
index b812e50f3c5..e8cfc29f3a0 100644
--- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
+++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols
@@ -8,18 +8,18 @@
 
 type arrayString = Array<String>
 >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 type someArray = Array<String> | number[];
 >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 type stringOrNumArray = Array<String|Number>;
 >stringOrNumArray : Symbol(stringOrNumArray, Decl(destructuringParameterDeclaration3ES6.ts, 8, 42))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 >Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
 
 function a1(...x: (number|string)[]) { }
@@ -33,8 +33,8 @@ function a2(...a) { }
 function a3(...a: Array<String>) { }
 >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21))
 >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12))
->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4090, 1))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4091, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
 function a4(...a: arrayString) { }
 >a4 : Symbol(a4, Decl(destructuringParameterDeclaration3ES6.ts, 13, 36))
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
index 1472af3b192..e5275396346 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols
@@ -5,7 +5,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4356, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         let arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
index 95832b34fd5..230e7158d32 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4356, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         const arguments = 100;
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
index 72775873027..e304c33e48e 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols
@@ -8,7 +8,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4356, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
index e7ae9bb14fa..4a309471e64 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols
@@ -9,7 +9,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4356, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments[0];
diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
index 311d9a099f1..e9760caa319 100644
--- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
+++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols
@@ -10,7 +10,7 @@ function f() {
 
     if (Math.random()) {
 >Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4356, 60))
+>Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4392, 60))
 >random : Symbol(Math.random, Decl(lib.d.ts, 608, 38))
 
         return () => arguments;
diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols
index acabc911b80..e465f36a50f 100644
--- a/tests/baselines/reference/for-of13.symbols
+++ b/tests/baselines/reference/for-of13.symbols
@@ -4,6 +4,6 @@ var v: string;
 
 for (v of [""].values()) { }
 >v : Symbol(v, Decl(for-of13.ts, 0, 3))
->[""].values : Symbol(Array.values, Decl(lib.d.ts, 4118, 37))
->values : Symbol(Array.values, Decl(lib.d.ts, 4118, 37))
+>[""].values : Symbol(Array.values, Decl(lib.d.ts, 4119, 37))
+>values : Symbol(Array.values, Decl(lib.d.ts, 4119, 37))
 
diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols
index 061168ea4e9..76621026a00 100644
--- a/tests/baselines/reference/for-of18.symbols
+++ b/tests/baselines/reference/for-of18.symbols
@@ -22,9 +22,9 @@ class StringIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of18.ts, 1, 33))
diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols
index faddbf0d680..35892922df3 100644
--- a/tests/baselines/reference/for-of19.symbols
+++ b/tests/baselines/reference/for-of19.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of19.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols
index d3c223b19ee..f01969e23bb 100644
--- a/tests/baselines/reference/for-of20.symbols
+++ b/tests/baselines/reference/for-of20.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of20.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols
index 4e58554a9b8..c740cf62446 100644
--- a/tests/baselines/reference/for-of21.symbols
+++ b/tests/baselines/reference/for-of21.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of21.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols
index 8fa1cb0cc4e..bf4304a8216 100644
--- a/tests/baselines/reference/for-of22.symbols
+++ b/tests/baselines/reference/for-of22.symbols
@@ -28,9 +28,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of22.ts, 5, 13))
diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols
index 98d30994a7d..a45775127b0 100644
--- a/tests/baselines/reference/for-of23.symbols
+++ b/tests/baselines/reference/for-of23.symbols
@@ -27,9 +27,9 @@ class FooIterator {
         };
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(for-of23.ts, 4, 13))
diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols
index 1d8508f7cf4..ef08deb568d 100644
--- a/tests/baselines/reference/for-of25.symbols
+++ b/tests/baselines/reference/for-of25.symbols
@@ -10,9 +10,9 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 1, 37))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return x;
 >x : Symbol(x, Decl(for-of25.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols
index b6d554412b6..abaa0a92dcc 100644
--- a/tests/baselines/reference/for-of26.symbols
+++ b/tests/baselines/reference/for-of26.symbols
@@ -16,9 +16,9 @@ class StringIterator {
 >x : Symbol(x, Decl(for-of26.ts, 0, 3))
     }
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of26.ts, 1, 37))
diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols
index 09ef84bbd10..727574805b9 100644
--- a/tests/baselines/reference/for-of27.symbols
+++ b/tests/baselines/reference/for-of27.symbols
@@ -7,7 +7,7 @@ class StringIterator {
 >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 37))
 
     [Symbol.iterator]: any;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 }
diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols
index d73cbf3d2de..4e1bf8ad3dc 100644
--- a/tests/baselines/reference/for-of28.symbols
+++ b/tests/baselines/reference/for-of28.symbols
@@ -10,9 +10,9 @@ class StringIterator {
 >next : Symbol(next, Decl(for-of28.ts, 2, 22))
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 37))
diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols
index 61ff5036782..e6a10d77cad 100644
--- a/tests/baselines/reference/for-of37.symbols
+++ b/tests/baselines/reference/for-of37.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of37.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of37.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4572, 1), Decl(lib.d.ts, 4595, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
 
 for (var v of map) {
 >v : Symbol(v, Decl(for-of37.ts, 1, 8))
diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols
index f42c8358d9a..43df250ab95 100644
--- a/tests/baselines/reference/for-of38.symbols
+++ b/tests/baselines/reference/for-of38.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of38.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of38.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4572, 1), Decl(lib.d.ts, 4595, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
 
 for (var [k, v] of map) {
 >k : Symbol(k, Decl(for-of38.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols
index 070333f6db2..e1e413424ad 100644
--- a/tests/baselines/reference/for-of40.symbols
+++ b/tests/baselines/reference/for-of40.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of40.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of40.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4572, 1), Decl(lib.d.ts, 4595, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
 
 for (var [k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of40.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols
index d70b0ba5d76..839de020702 100644
--- a/tests/baselines/reference/for-of44.symbols
+++ b/tests/baselines/reference/for-of44.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of44.ts ===
 var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]]
 >array : Symbol(array, Decl(for-of44.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
 for (var [num, strBoolSym] of array) {
 >num : Symbol(num, Decl(for-of44.ts, 1, 10))
diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols
index 715005fbce5..87c227f5dc9 100644
--- a/tests/baselines/reference/for-of45.symbols
+++ b/tests/baselines/reference/for-of45.symbols
@@ -5,7 +5,7 @@ var k: string, v: boolean;
 
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of45.ts, 1, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4572, 1), Decl(lib.d.ts, 4595, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
 
 for ([k = "", v = false] of map) {
 >k : Symbol(k, Decl(for-of45.ts, 0, 3))
diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols
index 098223ba723..c01a37bf409 100644
--- a/tests/baselines/reference/for-of50.symbols
+++ b/tests/baselines/reference/for-of50.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of50.ts ===
 var map = new Map([["", true]]);
 >map : Symbol(map, Decl(for-of50.ts, 0, 3))
->Map : Symbol(Map, Decl(lib.d.ts, 4572, 1), Decl(lib.d.ts, 4595, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
 
 for (const [k, v] of map) {
 >k : Symbol(k, Decl(for-of50.ts, 1, 12))
diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols
index de3ec3ecce2..ff061ffcca1 100644
--- a/tests/baselines/reference/for-of57.symbols
+++ b/tests/baselines/reference/for-of57.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/for-ofStatements/for-of57.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(for-of57.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
 for (let num of iter) { }
 >num : Symbol(num, Decl(for-of57.ts, 1, 8))
diff --git a/tests/baselines/reference/generatorES6_6.symbols b/tests/baselines/reference/generatorES6_6.symbols
index 02c1b8f7807..f424048eeec 100644
--- a/tests/baselines/reference/generatorES6_6.symbols
+++ b/tests/baselines/reference/generatorES6_6.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(generatorES6_6.ts, 0, 0))
 
   *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
     let a = yield 1;
 >a : Symbol(a, Decl(generatorES6_6.ts, 2, 7))
diff --git a/tests/baselines/reference/generatorOverloads4.symbols b/tests/baselines/reference/generatorOverloads4.symbols
index ca78c220e2a..647576d081e 100644
--- a/tests/baselines/reference/generatorOverloads4.symbols
+++ b/tests/baselines/reference/generatorOverloads4.symbols
@@ -5,15 +5,15 @@ class C {
     f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
     f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
     *f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32))
 >s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 }
diff --git a/tests/baselines/reference/generatorOverloads5.symbols b/tests/baselines/reference/generatorOverloads5.symbols
index ddda5abc65b..e876a2619d2 100644
--- a/tests/baselines/reference/generatorOverloads5.symbols
+++ b/tests/baselines/reference/generatorOverloads5.symbols
@@ -5,15 +5,15 @@ module M {
     function f(s: string): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
     function f(s: number): Iterable<any>;
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
     function* f(s: any): Iterable<any> { }
 >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41))
 >s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 }
diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols
index ad355bd1582..728084f01d0 100644
--- a/tests/baselines/reference/generatorTypeCheck1.symbols
+++ b/tests/baselines/reference/generatorTypeCheck1.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts ===
 function* g1(): Iterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4327, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
 
diff --git a/tests/baselines/reference/generatorTypeCheck10.symbols b/tests/baselines/reference/generatorTypeCheck10.symbols
index b8124fb2520..f00d72007f5 100644
--- a/tests/baselines/reference/generatorTypeCheck10.symbols
+++ b/tests/baselines/reference/generatorTypeCheck10.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts ===
 function* g(): IterableIterator<any> {
 >g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 
     return;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols
index 0f4bbad9dac..48a1abfbaca 100644
--- a/tests/baselines/reference/generatorTypeCheck11.symbols
+++ b/tests/baselines/reference/generatorTypeCheck11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 
     return 0;
 }
diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols
index 1f5798d0394..745e4831b12 100644
--- a/tests/baselines/reference/generatorTypeCheck12.symbols
+++ b/tests/baselines/reference/generatorTypeCheck12.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 
     return "";
 }
diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols
index cb672506e87..c6189a6ef64 100644
--- a/tests/baselines/reference/generatorTypeCheck13.symbols
+++ b/tests/baselines/reference/generatorTypeCheck13.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts ===
 function* g(): IterableIterator<number> {
 >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 
     yield 0;
     return "";
diff --git a/tests/baselines/reference/generatorTypeCheck17.symbols b/tests/baselines/reference/generatorTypeCheck17.symbols
index 5495d56e6d2..51d6c40ae37 100644
--- a/tests/baselines/reference/generatorTypeCheck17.symbols
+++ b/tests/baselines/reference/generatorTypeCheck17.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck19.symbols b/tests/baselines/reference/generatorTypeCheck19.symbols
index 4ffc3486735..12bf5e5e34e 100644
--- a/tests/baselines/reference/generatorTypeCheck19.symbols
+++ b/tests/baselines/reference/generatorTypeCheck19.symbols
@@ -10,7 +10,7 @@ class Bar extends Foo { y: string }
 
 function* g(): IterableIterator<Foo> {
 >g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 >Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0))
 
     yield;
diff --git a/tests/baselines/reference/generatorTypeCheck2.symbols b/tests/baselines/reference/generatorTypeCheck2.symbols
index 247c39e8b9e..c03276b6c9b 100644
--- a/tests/baselines/reference/generatorTypeCheck2.symbols
+++ b/tests/baselines/reference/generatorTypeCheck2.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts ===
 function* g1(): Iterable<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols
index ff1977dd823..399e4ccc497 100644
--- a/tests/baselines/reference/generatorTypeCheck26.symbols
+++ b/tests/baselines/reference/generatorTypeCheck26.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33))
 
     yield x => x.length;
diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols
index 8c031907aad..3d0a66382c6 100644
--- a/tests/baselines/reference/generatorTypeCheck27.symbols
+++ b/tests/baselines/reference/generatorTypeCheck27.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33))
 
     yield * function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols
index 394478d0836..96ce1e27c63 100644
--- a/tests/baselines/reference/generatorTypeCheck28.symbols
+++ b/tests/baselines/reference/generatorTypeCheck28.symbols
@@ -1,14 +1,14 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts ===
 function* g(): IterableIterator<(x: string) => number> {
 >g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33))
 
     yield * {
         *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
             yield x => x.length;
 >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17))
diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols
index 4e66617e2b2..b01b97eb763 100644
--- a/tests/baselines/reference/generatorTypeCheck29.symbols
+++ b/tests/baselines/reference/generatorTypeCheck29.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4327, 1))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck3.symbols b/tests/baselines/reference/generatorTypeCheck3.symbols
index 803c2087716..79a3164e2d2 100644
--- a/tests/baselines/reference/generatorTypeCheck3.symbols
+++ b/tests/baselines/reference/generatorTypeCheck3.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts ===
 function* g1(): IterableIterator<string> { }
 >g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0))
->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4337, 1))
+>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4373, 1))
 
diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols
index 47662d84a8b..e337277aa43 100644
--- a/tests/baselines/reference/generatorTypeCheck30.symbols
+++ b/tests/baselines/reference/generatorTypeCheck30.symbols
@@ -1,8 +1,8 @@
 === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts ===
 function* g2(): Iterator<Iterable<(x: string) => number>> {
 >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4327, 1))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35))
 
     yield function* () {
diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols
index 009df89c29e..9cf40641ad6 100644
--- a/tests/baselines/reference/generatorTypeCheck45.symbols
+++ b/tests/baselines/reference/generatorTypeCheck45.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32))
->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4327, 1))
+>Iterator : Symbol(Iterator, Decl(lib.d.ts, 4363, 1))
 >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23))
diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols
index e65d42c3bd1..8b3bf966681 100644
--- a/tests/baselines/reference/generatorTypeCheck46.symbols
+++ b/tests/baselines/reference/generatorTypeCheck46.symbols
@@ -6,7 +6,7 @@ declare function foo<T, U>(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U)
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54))
 >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21))
 >U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23))
@@ -21,9 +21,9 @@ foo("", function* () {
 
     yield* {
         *[Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
             yield x => x.length
 >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17))
diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols
index 8fdeee893d4..fae627e9c95 100644
--- a/tests/baselines/reference/iterableArrayPattern1.symbols
+++ b/tests/baselines/reference/iterableArrayPattern1.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iterableArrayPattern1.ts, 4, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 32))
diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols
index f1a8127d84a..fefeaced83f 100644
--- a/tests/baselines/reference/iterableArrayPattern11.symbols
+++ b/tests/baselines/reference/iterableArrayPattern11.symbols
@@ -36,9 +36,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols
index 13c797733da..fd00059449a 100644
--- a/tests/baselines/reference/iterableArrayPattern12.symbols
+++ b/tests/baselines/reference/iterableArrayPattern12.symbols
@@ -36,9 +36,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols
index be0b4132f25..8271e564f9e 100644
--- a/tests/baselines/reference/iterableArrayPattern13.symbols
+++ b/tests/baselines/reference/iterableArrayPattern13.symbols
@@ -35,9 +35,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols
index 311356187a4..d4f2949e24f 100644
--- a/tests/baselines/reference/iterableArrayPattern2.symbols
+++ b/tests/baselines/reference/iterableArrayPattern2.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iterableArrayPattern2.ts, 4, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 35))
diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols
index 7527c30f4a1..9e38c52ad70 100644
--- a/tests/baselines/reference/iterableArrayPattern3.symbols
+++ b/tests/baselines/reference/iterableArrayPattern3.symbols
@@ -37,9 +37,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols
index 85618126640..523d81cde2d 100644
--- a/tests/baselines/reference/iterableArrayPattern30.symbols
+++ b/tests/baselines/reference/iterableArrayPattern30.symbols
@@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]])
 >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11))
 >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18))
 >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21))
->Map : Symbol(Map, Decl(lib.d.ts, 4572, 1), Decl(lib.d.ts, 4595, 11))
+>Map : Symbol(Map, Decl(lib.d.ts, 4608, 1), Decl(lib.d.ts, 4631, 11))
 
diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols
index 03a0b416b14..d3a7f4fb1d7 100644
--- a/tests/baselines/reference/iterableArrayPattern4.symbols
+++ b/tests/baselines/reference/iterableArrayPattern4.symbols
@@ -37,9 +37,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 3, 27))
diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols
index 4876ad4fc10..efb88d2e608 100644
--- a/tests/baselines/reference/iterableArrayPattern9.symbols
+++ b/tests/baselines/reference/iterableArrayPattern9.symbols
@@ -32,9 +32,9 @@ class FooIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27))
diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols
index fcedc624d5a..52f5f2d0b17 100644
--- a/tests/baselines/reference/iterableContextualTyping1.symbols
+++ b/tests/baselines/reference/iterableContextualTyping1.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts ===
 var iter: Iterable<(x: string) => number> = [s => s.length];
 >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20))
 >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols
index 5e273944ea3..03099b124c9 100644
--- a/tests/baselines/reference/iteratorSpreadInArray.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 5, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 36))
diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols
index e82487f041e..c18c9095f50 100644
--- a/tests/baselines/reference/iteratorSpreadInArray11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts ===
 var iter: Iterable<number>;
 >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 
 var array = [...iter];
 >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3))
diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols
index 477fadfdbc7..906e8288af0 100644
--- a/tests/baselines/reference/iteratorSpreadInArray2.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols
@@ -13,7 +13,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 5, 28))
@@ -22,9 +22,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 59))
@@ -48,9 +48,9 @@ class NumberIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 13, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols
index b15f1ec4506..e25374c80a8 100644
--- a/tests/baselines/reference/iteratorSpreadInArray3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 5, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 47))
diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols
index 9e124add927..1856d1bb682 100644
--- a/tests/baselines/reference/iteratorSpreadInArray4.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols
@@ -12,7 +12,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 5, 28))
@@ -21,9 +21,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 42))
diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols
index afbd8b33ea9..c68550b7fa7 100644
--- a/tests/baselines/reference/iteratorSpreadInArray7.symbols
+++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 6, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38))
diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols
index c72f389b20c..874a034631d 100644
--- a/tests/baselines/reference/iteratorSpreadInCall11.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols
@@ -19,7 +19,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 7, 28))
@@ -28,9 +28,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 2, 42))
diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols
index c997b9ebfea..0f84a0e1cbb 100644
--- a/tests/baselines/reference/iteratorSpreadInCall12.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols
@@ -22,7 +22,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 9, 28))
@@ -31,9 +31,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 4, 1))
@@ -57,9 +57,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 17, 1))
diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols
index bb619eeed84..6f329329431 100644
--- a/tests/baselines/reference/iteratorSpreadInCall3.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols
@@ -16,7 +16,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 6, 28))
@@ -25,9 +25,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 2, 32))
diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols
index 3aaeca7509f..01a0112b026 100644
--- a/tests/baselines/reference/iteratorSpreadInCall5.symbols
+++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols
@@ -17,7 +17,7 @@ class SymbolIterator {
         return {
             value: Symbol(),
 >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
             done: false
 >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 6, 28))
@@ -26,9 +26,9 @@ class SymbolIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 2, 43))
@@ -52,9 +52,9 @@ class StringIterator {
     }
 
     [Symbol.iterator]() {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
         return this;
 >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1))
diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols
index 4e4b9177f4e..f21959df892 100644
--- a/tests/baselines/reference/parserSymbolProperty1.symbols
+++ b/tests/baselines/reference/parserSymbolProperty1.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0))
 
     [Symbol.iterator]: string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols
index 3630bd93b02..9f43ba7b006 100644
--- a/tests/baselines/reference/parserSymbolProperty2.symbols
+++ b/tests/baselines/reference/parserSymbolProperty2.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0))
 
     [Symbol.unscopables](): string;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols
index 254d8ee4b3c..e3a3b1d5609 100644
--- a/tests/baselines/reference/parserSymbolProperty3.symbols
+++ b/tests/baselines/reference/parserSymbolProperty3.symbols
@@ -3,7 +3,7 @@ declare class C {
 >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0))
 
     [Symbol.unscopables](): string;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols
index 9724eb4f8e4..ba0134e82a9 100644
--- a/tests/baselines/reference/parserSymbolProperty4.symbols
+++ b/tests/baselines/reference/parserSymbolProperty4.symbols
@@ -3,7 +3,7 @@ declare class C {
 >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0))
 
     [Symbol.toPrimitive]: string;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols
index 52c1f755c45..970f8a0b753 100644
--- a/tests/baselines/reference/parserSymbolProperty5.symbols
+++ b/tests/baselines/reference/parserSymbolProperty5.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0))
 
     [Symbol.toPrimitive]: string;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols
index c95afd7af92..29831fad7ef 100644
--- a/tests/baselines/reference/parserSymbolProperty6.symbols
+++ b/tests/baselines/reference/parserSymbolProperty6.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0))
 
     [Symbol.toStringTag]: string = "";
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols
index a931edd4baa..8322d312839 100644
--- a/tests/baselines/reference/parserSymbolProperty7.symbols
+++ b/tests/baselines/reference/parserSymbolProperty7.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0))
 
     [Symbol.toStringTag](): void { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols
index b8863451c5d..7c5dfbff7c6 100644
--- a/tests/baselines/reference/parserSymbolProperty8.symbols
+++ b/tests/baselines/reference/parserSymbolProperty8.symbols
@@ -3,7 +3,7 @@ var x: {
 >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3))
 
     [Symbol.toPrimitive](): string
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols
index 038f503bbba..7ee5e7e6998 100644
--- a/tests/baselines/reference/parserSymbolProperty9.symbols
+++ b/tests/baselines/reference/parserSymbolProperty9.symbols
@@ -3,7 +3,7 @@ var x: {
 >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3))
 
     [Symbol.toPrimitive]: string
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index a358cd17f71..b12d564d880 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -22,13 +22,13 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5055, 39), Decl(lib.d.ts, 5062, 54))
->Promise : Symbol(Promise, Decl(lib.d.ts, 4987, 1), Decl(lib.d.ts, 5073, 11))
->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5055, 39), Decl(lib.d.ts, 5062, 54))
+>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5109, 39), Decl(lib.d.ts, 5116, 54))
+>Promise : Symbol(Promise, Decl(lib.d.ts, 5041, 1), Decl(lib.d.ts, 5127, 11))
+>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5109, 39), Decl(lib.d.ts, 5116, 54))
 >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28))
 }
 
@@ -47,12 +47,12 @@ function f2(x: T1): T2 {
 
 var x3 = f1()
 >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3))
->f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 4992, 22), Decl(lib.d.ts, 4999, 158))
->f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 4992, 22), Decl(lib.d.ts, 4999, 158))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
+>f1()    .then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 4992, 22), Decl(lib.d.ts, 4999, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
@@ -62,7 +62,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.d.ts, 4992, 22), Decl(lib.d.ts, 4999, 158))
+>then : Symbol(Promise.then, Decl(lib.d.ts, 5046, 22), Decl(lib.d.ts, 5053, 158))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
diff --git a/tests/baselines/reference/stringIncludes.symbols b/tests/baselines/reference/stringIncludes.symbols
index 3e1763d57cf..0ca53dbb837 100644
--- a/tests/baselines/reference/stringIncludes.symbols
+++ b/tests/baselines/reference/stringIncludes.symbols
@@ -5,11 +5,11 @@ var includes: boolean;
 
 includes = "abcde".includes("cd");
 >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4221, 37))
->includes : Symbol(String.includes, Decl(lib.d.ts, 4221, 37))
+>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
+>includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
 
 includes = "abcde".includes("cd", 2);
 >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3))
->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4221, 37))
->includes : Symbol(String.includes, Decl(lib.d.ts, 4221, 37))
+>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
+>includes : Symbol(String.includes, Decl(lib.d.ts, 4222, 37))
 
diff --git a/tests/baselines/reference/superSymbolIndexedAccess1.symbols b/tests/baselines/reference/superSymbolIndexedAccess1.symbols
index 1e24f7d8481..416ac465e24 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess1.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess1.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess1.ts ===
 var symbol = Symbol.for('myThing');
 >symbol : Symbol(symbol, Decl(superSymbolIndexedAccess1.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3861, 42))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3861, 42))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
 
 class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess1.ts, 0, 35))
diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.symbols b/tests/baselines/reference/superSymbolIndexedAccess2.symbols
index dd20f1cbce3..726abb3fdc5 100644
--- a/tests/baselines/reference/superSymbolIndexedAccess2.symbols
+++ b/tests/baselines/reference/superSymbolIndexedAccess2.symbols
@@ -4,9 +4,9 @@ class Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]() {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 
         return 0;
     }
@@ -17,14 +17,14 @@ class Bar extends Foo {
 >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]() {
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 
         return super[Symbol.isConcatSpreadable]();
 >super : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0))
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
     }
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols
index 185cc8b6606..9a7d93c7246 100644
--- a/tests/baselines/reference/symbolDeclarationEmit1.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0))
 
     [Symbol.toPrimitive]: number;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols
index 3169e2c4bc7..63602f4fd2c 100644
--- a/tests/baselines/reference/symbolDeclarationEmit10.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols
@@ -3,13 +3,13 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3))
 
     get [Symbol.isConcatSpreadable]() { return '' },
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 
     set [Symbol.isConcatSpreadable](x) { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols
index e83e875e88e..850bde66c49 100644
--- a/tests/baselines/reference/symbolDeclarationEmit11.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols
@@ -3,23 +3,23 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0))
 
     static [Symbol.iterator] = 0;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
     static [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 
     static get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
     static set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols
index 1682029d8b2..accb92a8c52 100644
--- a/tests/baselines/reference/symbolDeclarationEmit13.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols
@@ -3,13 +3,13 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
     set [Symbol.toStringTag](x) { }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols
index 92fc24b6860..91a5cfdd760 100644
--- a/tests/baselines/reference/symbolDeclarationEmit14.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols
@@ -3,12 +3,12 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
     get [Symbol.toStringTag]() { return ""; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols
index 8f82cc6f351..1993e369aea 100644
--- a/tests/baselines/reference/symbolDeclarationEmit2.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols
@@ -3,7 +3,7 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0))
 
     [Symbol.toPrimitive] = "";
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols
index a32220969ca..84f39f363f1 100644
--- a/tests/baselines/reference/symbolDeclarationEmit3.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols
@@ -3,20 +3,20 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0))
 
     [Symbol.toPrimitive](x: number);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25))
 
     [Symbol.toPrimitive](x: string);
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25))
 
     [Symbol.toPrimitive](x: any) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols
index 2a3a34752cd..655a91fc88b 100644
--- a/tests/baselines/reference/symbolDeclarationEmit4.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols
@@ -3,13 +3,13 @@ class C {
 >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0))
 
     get [Symbol.toPrimitive]() { return ""; }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
     set [Symbol.toPrimitive](x) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols
index 4ffee2ca2b6..1436f9b9f69 100644
--- a/tests/baselines/reference/symbolDeclarationEmit5.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0))
 
     [Symbol.isConcatSpreadable](): string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols
index 26cf3d058c1..f07ebd532fa 100644
--- a/tests/baselines/reference/symbolDeclarationEmit6.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols
@@ -3,7 +3,7 @@ interface I {
 >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols
index edb489190fc..0435dc15df2 100644
--- a/tests/baselines/reference/symbolDeclarationEmit7.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols
@@ -3,7 +3,7 @@ var obj: {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: string;
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols
index 4d611985484..7e95754b1eb 100644
--- a/tests/baselines/reference/symbolDeclarationEmit8.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]: 0
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 }
diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols
index ac56fe94b5a..d4f08115a21 100644
--- a/tests/baselines/reference/symbolDeclarationEmit9.symbols
+++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols
@@ -3,7 +3,7 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3))
 
     [Symbol.isConcatSpreadable]() { }
->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3883, 24))
+>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24))
 }
diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols
index b194e8280d5..3db0f7012cb 100644
--- a/tests/baselines/reference/symbolProperty11.symbols
+++ b/tests/baselines/reference/symbolProperty11.symbols
@@ -6,9 +6,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols
index a5e95b91f31..62ce887a731 100644
--- a/tests/baselines/reference/symbolProperty13.symbols
+++ b/tests/baselines/reference/symbolProperty13.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols
index 74bec0c7f96..c48bd271c87 100644
--- a/tests/baselines/reference/symbolProperty14.symbols
+++ b/tests/baselines/reference/symbolProperty14.symbols
@@ -3,9 +3,9 @@ class C {
 >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0))
 
     [Symbol.iterator]: { x; y };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24))
 >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27))
 }
@@ -13,9 +13,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols
index 4d4fdb4764c..56f722c523b 100644
--- a/tests/baselines/reference/symbolProperty15.symbols
+++ b/tests/baselines/reference/symbolProperty15.symbols
@@ -6,9 +6,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11))
 
     [Symbol.iterator]?: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25))
 }
 
diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols
index 6bb736a3b93..092d766034e 100644
--- a/tests/baselines/reference/symbolProperty16.symbols
+++ b/tests/baselines/reference/symbolProperty16.symbols
@@ -3,18 +3,18 @@ class C {
 >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0))
 
     private [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32))
 }
 interface I {
 >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1))
 
     [Symbol.iterator]: { x };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24))
 }
 
diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols
index f613704ed8b..b5d930b4005 100644
--- a/tests/baselines/reference/symbolProperty18.symbols
+++ b/tests/baselines/reference/symbolProperty18.symbols
@@ -3,39 +3,39 @@ var i = {
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
 
     [Symbol.iterator]: 0,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
     [Symbol.toStringTag]() { return "" },
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
     set [Symbol.toPrimitive](p: boolean) { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29))
 }
 
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3))
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 var str = i[Symbol.toStringTag]();
 >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3))
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
 i[Symbol.toPrimitive] = false;
 >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3))
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols
index 74cbddbc52d..eae891f2e22 100644
--- a/tests/baselines/reference/symbolProperty19.symbols
+++ b/tests/baselines/reference/symbolProperty19.symbols
@@ -3,15 +3,15 @@ var i = {
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
 
     [Symbol.iterator]: { p: null },
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24))
 
     [Symbol.toStringTag]() { return { p: undefined }; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37))
 >undefined : Symbol(undefined)
 }
@@ -19,14 +19,14 @@ var i = {
 var it = i[Symbol.iterator];
 >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3))
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 var str = i[Symbol.toStringTag]();
 >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3))
 >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols
index 02b0f4b4343..d03ca9a4c51 100644
--- a/tests/baselines/reference/symbolProperty2.symbols
+++ b/tests/baselines/reference/symbolProperty2.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/Symbols/symbolProperty2.ts ===
 var s = Symbol();
 >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
 var x = {
 >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3))
diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols
index 993f05fe6d4..110067abda5 100644
--- a/tests/baselines/reference/symbolProperty20.symbols
+++ b/tests/baselines/reference/symbolProperty20.symbols
@@ -3,15 +3,15 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
 
     [Symbol.iterator]: (s: string) => string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24))
 
     [Symbol.toStringTag](s: number): number;
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25))
 }
 
@@ -20,16 +20,16 @@ var i: I = {
 >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0))
 
     [Symbol.iterator]: s => s,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22))
 
     [Symbol.toStringTag](n) { return n; }
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25))
 }
diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols
index 11876a1c449..2288537456c 100644
--- a/tests/baselines/reference/symbolProperty22.symbols
+++ b/tests/baselines/reference/symbolProperty22.symbols
@@ -5,9 +5,9 @@ interface I<T, U> {
 >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14))
 
     [Symbol.unscopables](x: T): U;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
 >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25))
 >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12))
 >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14))
@@ -27,9 +27,9 @@ declare function foo<T, U>(p1: T, p2: I<T, U>): U;
 
 foo("", { [Symbol.unscopables]: s => s.length });
 >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1))
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
 >s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19))
 >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31))
diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols
index 773c3e49ef3..152048a95a8 100644
--- a/tests/baselines/reference/symbolProperty23.symbols
+++ b/tests/baselines/reference/symbolProperty23.symbols
@@ -3,9 +3,9 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0))
 
     [Symbol.toPrimitive]: () => boolean;
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
 
 class C implements I {
@@ -13,9 +13,9 @@ class C implements I {
 >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0))
 
     [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
         return true;
     }
diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols
index e729bf12350..7a2e443368f 100644
--- a/tests/baselines/reference/symbolProperty26.symbols
+++ b/tests/baselines/reference/symbolProperty26.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return "";
     }
@@ -16,9 +16,9 @@ class C2 extends C1 {
 >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols
index 7b7207c4562..306802cdff2 100644
--- a/tests/baselines/reference/symbolProperty27.symbols
+++ b/tests/baselines/reference/symbolProperty27.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return {};
     }
@@ -16,9 +16,9 @@ class C2 extends C1 {
 >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols
index 7fde499ae97..77b476c6ea3 100644
--- a/tests/baselines/reference/symbolProperty28.symbols
+++ b/tests/baselines/reference/symbolProperty28.symbols
@@ -3,9 +3,9 @@ class C1 {
 >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0))
 
     [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return { x: "" };
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
@@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x;
 >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3))
 >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3))
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16))
 
diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols
index cd2409b6f00..c159cc756d8 100644
--- a/tests/baselines/reference/symbolProperty4.symbols
+++ b/tests/baselines/reference/symbolProperty4.symbols
@@ -3,13 +3,13 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3))
 
     [Symbol()]: 0,
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
     [Symbol()]() { },
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
     get [Symbol()]() {
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols
index 1a10dda2e8d..29b66c96f1f 100644
--- a/tests/baselines/reference/symbolProperty40.symbols
+++ b/tests/baselines/reference/symbolProperty40.symbols
@@ -3,21 +3,21 @@ class C {
 >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0))
 
     [Symbol.iterator](x: string): string;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22))
 
     [Symbol.iterator](x: number): number;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22))
 
         return undefined;
@@ -31,13 +31,13 @@ var c = new C;
 
 c[Symbol.iterator]("");
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 c[Symbol.iterator](0);
 >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols
index 59deb949f91..129c856b804 100644
--- a/tests/baselines/reference/symbolProperty41.symbols
+++ b/tests/baselines/reference/symbolProperty41.symbols
@@ -3,24 +3,24 @@ class C {
 >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0))
 
     [Symbol.iterator](x: string): { x: string };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22))
 >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35))
 
     [Symbol.iterator](x: "hello"): { x: string; hello: string };
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22))
 >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36))
 >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47))
 
     [Symbol.iterator](x: any) {
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22))
 
         return undefined;
@@ -34,13 +34,13 @@ var c = new C;
 
 c[Symbol.iterator]("");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 c[Symbol.iterator]("hello");
 >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols
index 6ced79ca415..34bb5ad967f 100644
--- a/tests/baselines/reference/symbolProperty45.symbols
+++ b/tests/baselines/reference/symbolProperty45.symbols
@@ -3,16 +3,16 @@ class C {
 >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0))
 
     get [Symbol.hasInstance]() {
->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3875, 32))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3875, 32))
+>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3876, 32))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3876, 32))
 
         return "";
     }
     get [Symbol.toPrimitive]() {
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
         return "";
     }
diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols
index 32ae2f713cc..063ae8d3d34 100644
--- a/tests/baselines/reference/symbolProperty5.symbols
+++ b/tests/baselines/reference/symbolProperty5.symbols
@@ -3,19 +3,19 @@ var x = {
 >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3))
 
     [Symbol.iterator]: 0,
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
     [Symbol.toPrimitive]() { },
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols
index be50264c427..64472f3c71a 100644
--- a/tests/baselines/reference/symbolProperty50.symbols
+++ b/tests/baselines/reference/symbolProperty50.symbols
@@ -9,8 +9,8 @@ module M {
 >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24))
 
         [Symbol.iterator]() { }
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols
index 265956f8e19..45a56260828 100644
--- a/tests/baselines/reference/symbolProperty51.symbols
+++ b/tests/baselines/reference/symbolProperty51.symbols
@@ -9,8 +9,8 @@ module M {
 >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21))
 
         [Symbol.iterator]() { }
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
     }
 }
diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols
index a138e75d85b..98f4a7769b2 100644
--- a/tests/baselines/reference/symbolProperty55.symbols
+++ b/tests/baselines/reference/symbolProperty55.symbols
@@ -3,9 +3,9 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 };
 
@@ -14,13 +14,13 @@ module M {
 
     var Symbol: SymbolConstructor;
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 3849, 1))
+>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 3850, 1))
 
     // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator,
     // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol.
     obj[Symbol.iterator];
 >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3))
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 }
diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols
index 7b399d2c642..fe73fb9f330 100644
--- a/tests/baselines/reference/symbolProperty56.symbols
+++ b/tests/baselines/reference/symbolProperty56.symbols
@@ -3,9 +3,9 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 };
 
diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols
index 37319e89af5..eaf5be2a07c 100644
--- a/tests/baselines/reference/symbolProperty57.symbols
+++ b/tests/baselines/reference/symbolProperty57.symbols
@@ -3,14 +3,14 @@ var obj = {
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
 
     [Symbol.iterator]: 0
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
 };
 
 // Should give type 'any'.
 obj[Symbol["nonsense"]];
 >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
 
diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols
index 16828db98b4..04b89f43652 100644
--- a/tests/baselines/reference/symbolProperty6.symbols
+++ b/tests/baselines/reference/symbolProperty6.symbols
@@ -3,24 +3,24 @@ class C {
 >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0))
 
     [Symbol.iterator] = 0;
->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3889, 31))
+>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
 
     [Symbol.toPrimitive]() { }
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 
     get [Symbol.toStringTag]() {
->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3931, 24))
+>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24))
 
         return 0;
     }
diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols
index 187423b2b94..541833d686a 100644
--- a/tests/baselines/reference/symbolProperty8.symbols
+++ b/tests/baselines/reference/symbolProperty8.symbols
@@ -3,12 +3,12 @@ interface I {
 >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0))
 
     [Symbol.unscopables]: number;
->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3937, 24))
+>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24))
 
     [Symbol.toPrimitive]();
->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3925, 18))
+>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18))
 }
diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols
index 368298ff71c..bbccd2a0f8b 100644
--- a/tests/baselines/reference/symbolType11.symbols
+++ b/tests/baselines/reference/symbolType11.symbols
@@ -1,9 +1,9 @@
 === tests/cases/conformance/es6/Symbols/symbolType11.ts ===
 var s = Symbol.for("logical");
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3861, 42))
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11))
->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3861, 42))
+>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11))
+>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42))
 
 s && s;
 >s : Symbol(s, Decl(symbolType11.ts, 0, 3))
diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols
index 38dae0b2b87..9a25d9ad152 100644
--- a/tests/baselines/reference/symbolType16.symbols
+++ b/tests/baselines/reference/symbolType16.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/es6/Symbols/symbolType16.ts ===
 interface Symbol {
->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3839, 102), Decl(lib.d.ts, 3945, 11), Decl(symbolType16.ts, 0, 0))
+>Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11), Decl(symbolType16.ts, 0, 0))
 
     newSymbolProp: number;
 >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18))
diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
index e0739715d4a..42a865e4e28 100644
--- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
+++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts ===
 var x = `abc${ new String("Hi") }def`;
 >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3))
->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4208, 1))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4209, 1))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
index d2782266077..28cb344da6e 100644
--- a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols
@@ -3,7 +3,7 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType1.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType1.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16))
 
diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
index 0be3776a4dc..2287b1db082 100644
--- a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
+++ b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols
@@ -3,14 +3,14 @@ function method<T>(iterable: Iterable<T>): T {
 >method : Symbol(method, Decl(typeArgumentInferenceApparentType2.ts, 0, 0))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType2.ts, 0, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
     function inner<U extends Iterable<T>>() {
 >inner : Symbol(inner, Decl(typeArgumentInferenceApparentType2.ts, 0, 46))
 >U : Symbol(U, Decl(typeArgumentInferenceApparentType2.ts, 1, 19))
->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4333, 1))
+>Iterable : Symbol(Iterable, Decl(lib.d.ts, 4369, 1))
 >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16))
 
         var u: U;
diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols
index 017db194363..dcba2e51f48 100644
--- a/tests/baselines/reference/typedArrays.symbols
+++ b/tests/baselines/reference/typedArrays.symbols
@@ -8,39 +8,39 @@ function CreateTypedArrayTypes() {
 
     typedArrays[0] = Int8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
 
     typedArrays[1] = Uint8Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
 
     typedArrays[2] = Int16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
 
     typedArrays[3] = Uint16Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
 
     typedArrays[4] = Int32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
 
     typedArrays[5] = Uint32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
 
     typedArrays[6] = Float32Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
 
     typedArrays[7] = Float64Array;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
 
     typedArrays[8] = Uint8ClampedArray;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
 
     return typedArrays;
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7))
@@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45))
 
     return typedArrays;
@@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) {
 
     typedArrays[0] = new Int8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[1] = new Uint8Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[2] = new Int16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[3] = new Uint16Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[4] = new Int32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[5] = new Uint32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[6] = new Float32Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[7] = new Float64Array(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     typedArrays[8] = new Uint8ClampedArray(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
 >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44))
 
     return typedArrays;
@@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44))
 
     return typedArrays;
@@ -242,65 +242,65 @@ function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike<number>) {
 
     typedArrays[0] = Int8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[1] = Uint8Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[2] = Int16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[3] = Uint16Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[4] = Int32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[5] = Uint32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[6] = Float32Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[7] = Float64Array.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     typedArrays[8] = Uint8ClampedArray.from(obj);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47))
 
     return typedArrays;
@@ -333,55 +333,55 @@ function CreateTypedArraysOf2() {
     typedArrays[0] = Int8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
 >of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30))
 
     typedArrays[1] = Uint8Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
 >of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30))
 
     typedArrays[2] = Int16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
 >of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30))
 
     typedArrays[3] = Uint16Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
 >of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30))
 
     typedArrays[4] = Int32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
 >of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30))
 
     typedArrays[5] = Uint32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
 >of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30))
 
     typedArrays[6] = Float32Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
 >of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30))
 
     typedArrays[7] = Float64Array.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
 >of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30))
 
     typedArrays[8] = Uint8ClampedArray.of(1,2,3,4);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7))
 >Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
 >of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30))
 
     return typedArrays;
@@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike<number>, mapFn: (n:number, v:n
 
     typedArrays[0] = Int8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[2] = Int16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[4] = Int32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[6] = Float32Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[7] = Float64Array.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58))
 
@@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike<number>, mapFn: (n:number, v
 
     typedArrays[0] = Int8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4668, 1))
->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4690, 32))
+>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
+>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4704, 1))
+>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4727, 48))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4698, 1))
->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4720, 33))
+>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
+>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4736, 1))
+>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4759, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[2] = Int16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4762, 1))
->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4788, 33))
+>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
+>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4804, 1))
+>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4831, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4796, 1))
->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4818, 34))
+>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
+>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4840, 1))
+>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4863, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[4] = Int32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4826, 1))
->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4848, 33))
+>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
+>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4872, 1))
+>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4895, 49))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4856, 1))
->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4878, 34))
+>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
+>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4904, 1))
+>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4927, 50))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[6] = Float32Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4886, 1))
->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4908, 35))
+>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
+>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4936, 1))
+>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4959, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[7] = Float64Array.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4916, 1))
->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4938, 35))
+>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
+>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4968, 1))
+>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 4991, 51))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))
 
     typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg);
 >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7))
->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4728, 1))
->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4753, 40))
+>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
+>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4768, 1))
+>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4794, 56))
 >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38))
 >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60))
 >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98))

From a55d531677480586f1f3433472155f1c99fed75d Mon Sep 17 00:00:00 2001
From: Daniel Rosenwasser <drosen@microsoft.com>
Date: Wed, 19 Aug 2015 18:22:40 -0700
Subject: [PATCH 9/9] Fixed newlines, switched 'module' keyword to 'namespace'.

---
 src/lib/es6.d.ts | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/src/lib/es6.d.ts b/src/lib/es6.d.ts
index 2286a20daad..c07d047b58e 100644
--- a/src/lib/es6.d.ts
+++ b/src/lib/es6.d.ts
@@ -885,7 +885,8 @@ interface Int8Array {
 }
 
 interface Int8ArrayConstructor {
-    new (elements: Iterable<number>): Int8Array;

+    new (elements: Iterable<number>): Int8Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -916,7 +917,8 @@ interface Uint8Array {
 }
 
 interface Uint8ArrayConstructor {
-    new (elements: Iterable<number>): Uint8Array;

+    new (elements: Iterable<number>): Uint8Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -950,7 +952,8 @@ interface Uint8ClampedArray {
 }
 
 interface Uint8ClampedArrayConstructor {
-    new (elements: Iterable<number>): Uint8ClampedArray;

+    new (elements: Iterable<number>): Uint8ClampedArray;
+
 
     /**
       * Creates an array from an array-like or iterable object.
@@ -986,7 +989,8 @@ interface Int16Array {
 }
 
 interface Int16ArrayConstructor {
-    new (elements: Iterable<number>): Int16Array;

+    new (elements: Iterable<number>): Int16Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1017,7 +1021,8 @@ interface Uint16Array {
 }
 
 interface Uint16ArrayConstructor {
-    new (elements: Iterable<number>): Uint16Array;

+    new (elements: Iterable<number>): Uint16Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1048,7 +1053,8 @@ interface Int32Array {
 }
 
 interface Int32ArrayConstructor {
-    new (elements: Iterable<number>): Int32Array;

+    new (elements: Iterable<number>): Int32Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1079,7 +1085,8 @@ interface Uint32Array {
 }
 
 interface Uint32ArrayConstructor {
-    new (elements: Iterable<number>): Uint32Array;

+    new (elements: Iterable<number>): Uint32Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1110,7 +1117,8 @@ interface Float32Array {
 }
 
 interface Float32ArrayConstructor {
-    new (elements: Iterable<number>): Float32Array;

+    new (elements: Iterable<number>): Float32Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1141,7 +1149,8 @@ interface Float64Array {
 }
 
 interface Float64ArrayConstructor {
-    new (elements: Iterable<number>): Float64Array;

+    new (elements: Iterable<number>): Float64Array;
+
     /**
       * Creates an array from an array-like or iterable object.
       * @param arrayLike An array-like or iterable object to convert to an array.
@@ -1174,7 +1183,7 @@ interface ProxyConstructor {
 }
 declare var Proxy: ProxyConstructor;
 
-declare module Reflect {
+declare namespace Reflect {
     function apply(target: Function, thisArgument: any, argumentsList: ArrayLike<any>): any;
     function construct(target: Function, argumentsList: ArrayLike<any>, newTarget?: any): any;
     function defineProperty(target: any, propertyKey: PropertyKey, attributes: PropertyDescriptor): boolean;