diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 2b059e29d09b5..f2c9dcd608dc6 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14358,6 +14358,9 @@ namespace ts {
                 error(func, Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option);
                 return unknownType;
             }
+            else if (!getGlobalPromiseConstructorSymbol()) {
+                error(func, Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
+            }
 
             return promiseType;
         }
@@ -16954,7 +16957,12 @@ namespace ts {
                 const promiseConstructorSymbol = resolveEntityName(promiseConstructorName, SymbolFlags.Value, /*ignoreErrors*/ true);
                 const promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : unknownType;
                 if (promiseConstructorType === unknownType) {
-                    error(node.type, Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, entityNameToString(promiseConstructorName));
+                    if (promiseConstructorName.kind === SyntaxKind.Identifier && promiseConstructorName.text === "Promise" && getTargetType(returnType) === tryGetGlobalPromiseType()) {
+                        error(node.type, Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option);
+                    }
+                    else {
+                        error(node.type, Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, entityNameToString(promiseConstructorName));
+                    }
                     return unknownType;
                 }
 
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 9f67b95c4d000..ec6067751a28f 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2055,6 +2055,10 @@
         "category": "Error",
         "code": 2704
     },
+    "An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.": {
+        "category": "Error",
+        "code": 2705
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
diff --git a/src/lib/es2015.promise.d.ts b/src/lib/es2015.promise.d.ts
index e27da2ce11b6c..b1e736100c57c 100644
--- a/src/lib/es2015.promise.d.ts
+++ b/src/lib/es2015.promise.d.ts
@@ -1,53 +1,3 @@
-/**
- * Represents the completion of an asynchronous operation
- */
-interface Promise<T> {
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of which ever callback is executed.
-     */
-    then(onfulfilled?: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): Promise<T>;
-
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of which ever callback is executed.
-     */
-    then<TResult>(onfulfilled: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
-
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of which ever callback is executed.
-     */
-    then<TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
-
-    /**
-     * Attaches callbacks for the resolution and/or rejection of the Promise.
-     * @param onfulfilled The callback to execute when the Promise is resolved.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of which ever callback is executed.
-     */
-    then<TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
-
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of the callback.
-     */
-    catch(onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): Promise<T>;
-
-    /**
-     * Attaches a callback for only the rejection of the Promise.
-     * @param onrejected The callback to execute when the Promise is rejected.
-     * @returns A Promise for the completion of the callback.
-     */
-    catch<TResult>(onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
-}
 
 interface PromiseConstructor {
     /**
diff --git a/src/lib/es5.d.ts b/src/lib/es5.d.ts
index 038d0344fda72..951549e2dcc51 100644
--- a/src/lib/es5.d.ts
+++ b/src/lib/es5.d.ts
@@ -1351,6 +1351,57 @@ interface PromiseLike<T> {
         onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
 }
 
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then(onfulfilled?: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): Promise<T>;
+
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult>(onfulfilled: ((value: T) => T | PromiseLike<T>) | undefined | null, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
+
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<TResult>;
+
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch(onrejected?: ((reason: any) => T | PromiseLike<T>) | undefined | null): Promise<T>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult>(onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
+}
+
 interface ArrayLike<T> {
     readonly length: number;
     readonly [n: number]: T;
diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.symbols b/tests/baselines/reference/asyncAliasReturnType_es6.symbols
index 61de47e409252..fccb2e5c73796 100644
--- a/tests/baselines/reference/asyncAliasReturnType_es6.symbols
+++ b/tests/baselines/reference/asyncAliasReturnType_es6.symbols
@@ -2,7 +2,7 @@
 type PromiseAlias<T> = Promise<T>;
 >PromiseAlias : Symbol(PromiseAlias, Decl(asyncAliasReturnType_es6.ts, 0, 0))
 >T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
 
 async function f(): PromiseAlias<void> {
diff --git a/tests/baselines/reference/asyncArrowFunction1_es2017.symbols b/tests/baselines/reference/asyncArrowFunction1_es2017.symbols
index 35fd033d6b4af..239a057aa8832 100644
--- a/tests/baselines/reference/asyncArrowFunction1_es2017.symbols
+++ b/tests/baselines/reference/asyncArrowFunction1_es2017.symbols
@@ -2,6 +2,6 @@
 
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es2017.ts, 1, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/asyncArrowFunction1_es5.symbols b/tests/baselines/reference/asyncArrowFunction1_es5.symbols
index c37985dc34765..9f09c3ac9adcf 100644
--- a/tests/baselines/reference/asyncArrowFunction1_es5.symbols
+++ b/tests/baselines/reference/asyncArrowFunction1_es5.symbols
@@ -2,6 +2,6 @@
 
 var foo = async (): Promise<void> => {
 >foo : Symbol(foo, Decl(asyncArrowFunction1_es5.ts, 1, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols
index a2f62f829909f..bc3557865ee04 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 };
diff --git a/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.symbols b/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.symbols
index 12a60509f4f83..acd490f5266e2 100644
--- a/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.symbols
+++ b/tests/baselines/reference/asyncAwaitWithCapturedBlockScopeVar.symbols
@@ -65,7 +65,7 @@ async function fn3() {
 
 async function fn4(): Promise<number> {
 >fn4 : Symbol(fn4, Decl(asyncAwaitWithCapturedBlockScopeVar.ts, 24, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     let ar = [];
 >ar : Symbol(ar, Decl(asyncAwaitWithCapturedBlockScopeVar.ts, 27, 7))
diff --git a/tests/baselines/reference/asyncAwait_es2017.symbols b/tests/baselines/reference/asyncAwait_es2017.symbols
index 34dc9802a25de..a456a2242953c 100644
--- a/tests/baselines/reference/asyncAwait_es2017.symbols
+++ b/tests/baselines/reference/asyncAwait_es2017.symbols
@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es2017.ts, 0, 0), Decl(asyncAwait_es2017.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es2017.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAwait_es2017.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es2017.ts, 0, 0), Decl(asyncAwait_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es2017.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es2017.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es2017.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es2017.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es2017.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es2017.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es2017.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { }; 
 >f9 : Symbol(f9, Decl(asyncAwait_es2017.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es2017.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwait_es2017.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es2017.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es2017.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(C.m2, Decl(asyncAwait_es2017.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.m3, Decl(asyncAwait_es2017.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es2017.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es2017.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncAwait_es5.symbols b/tests/baselines/reference/asyncAwait_es5.symbols
index 2f80a025ade2a..cdc52137ff472 100644
--- a/tests/baselines/reference/asyncAwait_es5.symbols
+++ b/tests/baselines/reference/asyncAwait_es5.symbols
@@ -2,16 +2,16 @@
 type MyPromise<T> = Promise<T>;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es5.ts, 0, 0), Decl(asyncAwait_es5.ts, 1, 11))
 >T : Symbol(T, Decl(asyncAwait_es5.ts, 0, 15))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(asyncAwait_es5.ts, 0, 15))
 
 declare var MyPromise: typeof Promise;
 >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es5.ts, 0, 0), Decl(asyncAwait_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es5.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare var mp: MyPromise<number>;
 >mp : Symbol(mp, Decl(asyncAwait_es5.ts, 3, 11))
@@ -22,7 +22,7 @@ async function f0() { }
 
 async function f1(): Promise<void> { }
 >f1 : Symbol(f1, Decl(asyncAwait_es5.ts, 5, 23))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 async function f3(): MyPromise<void> { }
 >f3 : Symbol(f3, Decl(asyncAwait_es5.ts, 6, 38))
@@ -33,7 +33,7 @@ let f4 = async function() { }
 
 let f5 = async function(): Promise<void> { }
 >f5 : Symbol(f5, Decl(asyncAwait_es5.ts, 10, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 let f6 = async function(): MyPromise<void> { }
 >f6 : Symbol(f6, Decl(asyncAwait_es5.ts, 11, 3))
@@ -44,7 +44,7 @@ let f7 = async () => { };
 
 let f8 = async (): Promise<void> => { };
 >f8 : Symbol(f8, Decl(asyncAwait_es5.ts, 14, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 let f9 = async (): MyPromise<void> => { };
 >f9 : Symbol(f9, Decl(asyncAwait_es5.ts, 15, 3))
@@ -60,7 +60,7 @@ let f11 = async () => mp;
 
 let f12 = async (): Promise<number> => mp;
 >f12 : Symbol(f12, Decl(asyncAwait_es5.ts, 18, 3))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >mp : Symbol(mp, Decl(asyncAwait_es5.ts, 3, 11))
 
 let f13 = async (): MyPromise<number> => p;
@@ -76,7 +76,7 @@ let o = {
 
 	async m2(): Promise<void> { },
 >m2 : Symbol(m2, Decl(asyncAwait_es5.ts, 22, 16))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(m3, Decl(asyncAwait_es5.ts, 23, 31))
@@ -92,7 +92,7 @@ class C {
 
 	async m2(): Promise<void> { }
 >m2 : Symbol(C.m2, Decl(asyncAwait_es5.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.m3, Decl(asyncAwait_es5.ts, 29, 30))
@@ -103,7 +103,7 @@ class C {
 
 	static async m5(): Promise<void> { }
 >m5 : Symbol(C.m5, Decl(asyncAwait_es5.ts, 31, 22))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es5.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncAwait_es6.symbols b/tests/baselines/reference/asyncAwait_es6.symbols
index 26295e72f783d..25032b1a94300 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 	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(C.m2, Decl(asyncAwait_es6.ts, 28, 15))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 	async m3(): MyPromise<void> { }
 >m3 : Symbol(C.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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 	static async m6(): MyPromise<void> { }
 >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37))
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es2017.symbols
index 02c35d81d6230..d9ae9715c2ee8 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration11_es2017.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es2017.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration11_es2017.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es5.symbols
index fc20251d5671e..f0a8bbd490369 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration11_es5.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es5.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration11_es5.ts ===
 async function await(): Promise<void> {
 >await : Symbol(await, Decl(asyncFunctionDeclaration11_es5.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols
index c9288f42763ae..4f1aea28635ff 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es2017.symbols
index 1b5bca844c062..0c410ece27de9 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration14_es2017.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es2017.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration14_es2017.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
   return;
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es5.symbols
index 1126618cfe73f..2458c22324a7d 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration14_es5.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es5.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration14_es5.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es5.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
   return;
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols
index d036632ff86c3..2aa5c7e0b2358 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
   return;
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es2017.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es2017.symbols
index a712df4589636..32b86eb69c72a 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration1_es2017.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es2017.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es2017/functionDeclarations/asyncFunctionDeclaration1_es2017.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es5.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es5.symbols
index ba7616ac293d9..610af242e03bf 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration1_es5.symbols
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es5.symbols
@@ -1,5 +1,5 @@
 === tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1_es5.ts ===
 async function foo(): Promise<void> {
 >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es5.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols
index 019d2db4f0793..fc645fa038e6b 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt b/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt
index 89a61ff648fd3..5d4a87a186ca4 100644
--- a/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt
+++ b/tests/baselines/reference/asyncFunctionNoReturnType.errors.txt
@@ -1,22 +1,16 @@
-error TS2318: Cannot find global type 'Promise'.
-tests/cases/compiler/asyncFunctionNoReturnType.ts(1,1): error TS2697: An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option.
-tests/cases/compiler/asyncFunctionNoReturnType.ts(1,1): error TS7030: Not all code paths return a value.
+error TS2468: Cannot find global value 'Promise'.
+tests/cases/compiler/asyncFunctionNoReturnType.ts(1,1): error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
 tests/cases/compiler/asyncFunctionNoReturnType.ts(2,9): error TS2304: Cannot find name 'window'.
-tests/cases/compiler/asyncFunctionNoReturnType.ts(3,9): error TS7030: Not all code paths return a value.
 
 
-!!! error TS2318: Cannot find global type 'Promise'.
-==== tests/cases/compiler/asyncFunctionNoReturnType.ts (4 errors) ====
+!!! error TS2468: Cannot find global value 'Promise'.
+==== tests/cases/compiler/asyncFunctionNoReturnType.ts (2 errors) ====
     async () => {
     ~~~~~~~~~~~~~
-!!! error TS2697: An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option.
-    ~~~~~~~~~~~~~
-!!! error TS7030: Not all code paths return a value.
+!!! error TS2705: An async function or method in ES5/ES3 requires the 'Promise' constructor.  Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option.
         if (window)
             ~~~~~~
 !!! error TS2304: Cannot find name 'window'.
             return;
-            ~~~~~~~
-!!! error TS7030: Not all code paths return a value.
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncFunctionReturnType.symbols b/tests/baselines/reference/asyncFunctionReturnType.symbols
index d5aa71c9e51a8..7939fe7e83c97 100644
--- a/tests/baselines/reference/asyncFunctionReturnType.symbols
+++ b/tests/baselines/reference/asyncFunctionReturnType.symbols
@@ -8,7 +8,7 @@ async function fAsync() {
 
 async function fAsyncExplicit(): Promise<[number, boolean]> {
 >fAsyncExplicit : Symbol(fAsyncExplicit, Decl(asyncFunctionReturnType.ts, 3, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     // This is contextually typed as a tuple.
     return [1, true];
@@ -29,7 +29,7 @@ async function fIndexedTypeForStringProp(obj: Obj): Promise<Obj["stringProp"]> {
 >fIndexedTypeForStringProp : Symbol(fIndexedTypeForStringProp, Decl(asyncFunctionReturnType.ts, 14, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 16, 41))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return obj.stringProp;
@@ -42,12 +42,12 @@ async function fIndexedTypeForPromiseOfStringProp(obj: Obj): Promise<Obj["string
 >fIndexedTypeForPromiseOfStringProp : Symbol(fIndexedTypeForPromiseOfStringProp, Decl(asyncFunctionReturnType.ts, 18, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 20, 50))
@@ -58,12 +58,12 @@ async function fIndexedTypeForExplicitPromiseOfStringProp(obj: Obj): Promise<Obj
 >fIndexedTypeForExplicitPromiseOfStringProp : Symbol(fIndexedTypeForExplicitPromiseOfStringProp, Decl(asyncFunctionReturnType.ts, 22, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 24, 58))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["stringProp"]>(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -75,7 +75,7 @@ async function fIndexedTypeForAnyProp(obj: Obj): Promise<Obj["anyProp"]> {
 >fIndexedTypeForAnyProp : Symbol(fIndexedTypeForAnyProp, Decl(asyncFunctionReturnType.ts, 26, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 28, 38))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return obj.anyProp;
@@ -88,12 +88,12 @@ async function fIndexedTypeForPromiseOfAnyProp(obj: Obj): Promise<Obj["anyProp"]
 >fIndexedTypeForPromiseOfAnyProp : Symbol(fIndexedTypeForPromiseOfAnyProp, Decl(asyncFunctionReturnType.ts, 30, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 32, 47))
@@ -104,12 +104,12 @@ async function fIndexedTypeForExplicitPromiseOfAnyProp(obj: Obj): Promise<Obj["a
 >fIndexedTypeForExplicitPromiseOfAnyProp : Symbol(fIndexedTypeForExplicitPromiseOfAnyProp, Decl(asyncFunctionReturnType.ts, 34, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 36, 55))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 
     return Promise.resolve<Obj["anyProp"]>(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -123,7 +123,7 @@ async function fGenericIndexedTypeForStringProp<TObj extends Obj>(obj: TObj): Pr
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 40, 66))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 40, 48))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 40, 48))
 
     return obj.stringProp;
@@ -138,12 +138,12 @@ async function fGenericIndexedTypeForPromiseOfStringProp<TObj extends Obj>(obj:
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 44, 57))
 
     return Promise.resolve(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 44, 75))
@@ -156,12 +156,12 @@ async function fGenericIndexedTypeForExplicitPromiseOfStringProp<TObj extends Ob
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 48, 83))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 
     return Promise.resolve<TObj["stringProp"]>(obj.stringProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 48, 65))
 >obj.stringProp : Symbol(Obj.stringProp, Decl(asyncFunctionReturnType.ts, 11, 15))
@@ -175,7 +175,7 @@ async function fGenericIndexedTypeForAnyProp<TObj extends Obj>(obj: TObj): Promi
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 52, 63))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 52, 45))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 52, 45))
 
     return obj.anyProp;
@@ -190,12 +190,12 @@ async function fGenericIndexedTypeForPromiseOfAnyProp<TObj extends Obj>(obj: TOb
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 56, 54))
 
     return Promise.resolve(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 56, 72))
@@ -208,12 +208,12 @@ async function fGenericIndexedTypeForExplicitPromiseOfAnyProp<TObj extends Obj>(
 >Obj : Symbol(Obj, Decl(asyncFunctionReturnType.ts, 8, 1))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 60, 80))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 
     return Promise.resolve<TObj["anyProp"]>(obj.anyProp);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 60, 62))
 >obj.anyProp : Symbol(Obj.anyProp, Decl(asyncFunctionReturnType.ts, 12, 23))
@@ -231,7 +231,7 @@ async function fGenericIndexedTypeForKProp<TObj extends Obj, K extends keyof TOb
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 64, 93))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 64, 43))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 64, 60))
 
@@ -250,13 +250,13 @@ async function fGenericIndexedTypeForPromiseOfKProp<TObj extends Obj, K extends
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 68, 52))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 68, 69))
 
     return Promise.resolve(obj[key]);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >obj : Symbol(obj, Decl(asyncFunctionReturnType.ts, 68, 92))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 68, 102))
@@ -272,13 +272,13 @@ async function fGenericIndexedTypeForExplicitPromiseOfKProp<TObj extends Obj, K
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >key : Symbol(key, Decl(asyncFunctionReturnType.ts, 72, 110))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
 
     return Promise.resolve<TObj[K]>(obj[key]);
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >TObj : Symbol(TObj, Decl(asyncFunctionReturnType.ts, 72, 60))
 >K : Symbol(K, Decl(asyncFunctionReturnType.ts, 72, 77))
diff --git a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols
index 2d10183133d0d..116406f765213 100644
--- a/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols
+++ b/tests/baselines/reference/asyncFunctionsAndStrictNullChecks.symbols
@@ -106,7 +106,7 @@ declare function resolve1<T>(value: T): Promise<T>;
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26))
 >value : Symbol(value, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 29))
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >T : Symbol(T, Decl(asyncFunctionsAndStrictNullChecks.ts, 18, 26))
 
 declare function resolve2<T>(value: T): Windows.Foundation.IPromise<T>;
diff --git a/tests/baselines/reference/asyncImportedPromise_es5.symbols b/tests/baselines/reference/asyncImportedPromise_es5.symbols
index b889299bd7ebd..c4ff901f5b9d7 100644
--- a/tests/baselines/reference/asyncImportedPromise_es5.symbols
+++ b/tests/baselines/reference/asyncImportedPromise_es5.symbols
@@ -2,7 +2,7 @@
 export class Task<T> extends Promise<T> { }
 >Task : Symbol(Task, Decl(task.ts, 0, 0))
 >T : Symbol(T, Decl(task.ts, 0, 18))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(task.ts, 0, 18))
 
 === tests/cases/conformance/async/es5/test.ts ===
diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es5.symbols b/tests/baselines/reference/asyncQualifiedReturnType_es5.symbols
index 1fcc5d4e60904..8964074ed6109 100644
--- a/tests/baselines/reference/asyncQualifiedReturnType_es5.symbols
+++ b/tests/baselines/reference/asyncQualifiedReturnType_es5.symbols
@@ -5,7 +5,7 @@ namespace X {
     export class MyPromise<T> extends Promise<T> {
 >MyPromise : Symbol(MyPromise, Decl(asyncQualifiedReturnType_es5.ts, 0, 13))
 >T : Symbol(T, Decl(asyncQualifiedReturnType_es5.ts, 1, 27))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(asyncQualifiedReturnType_es5.ts, 1, 27))
     }
 }
diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols
index b5f83de6021ae..d1de246fa93b0 100644
--- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols
+++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es2017.symbols
@@ -3,7 +3,7 @@
 declare function someOtherFunction(i: any): Promise<void>;
 >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 0, 0))
 >i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 1, 35))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 const x = async i => await someOtherFunction(i)
 >x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es2017.ts, 2, 5))
diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols
index 0f43ba7773e01..82b73a199ea8e 100644
--- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols
+++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es5.symbols
@@ -3,7 +3,7 @@
 declare function someOtherFunction(i: any): Promise<void>;
 >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 0, 0))
 >i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 1, 35))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const x = async i => await someOtherFunction(i)
 >x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es5.ts, 2, 5))
diff --git a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols
index 018c239925890..fee86b56cee12 100644
--- a/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols
+++ b/tests/baselines/reference/asyncUnParenthesizedArrowFunction_es6.symbols
@@ -3,7 +3,7 @@
 declare function someOtherFunction(i: any): Promise<void>;
 >someOtherFunction : Symbol(someOtherFunction, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 0, 0))
 >i : Symbol(i, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 1, 35))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 const x = async i => await someOtherFunction(i)
 >x : Symbol(x, Decl(asyncUnParenthesizedArrowFunction_es6.ts, 2, 5))
diff --git a/tests/baselines/reference/asyncUseStrict_es2017.symbols b/tests/baselines/reference/asyncUseStrict_es2017.symbols
index 23fd654ca29d1..ecd5c992cd804 100644
--- a/tests/baselines/reference/asyncUseStrict_es2017.symbols
+++ b/tests/baselines/reference/asyncUseStrict_es2017.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(asyncUseStrict_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(asyncUseStrict_es2017.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     "use strict";
     var b = await p || a;
diff --git a/tests/baselines/reference/asyncUseStrict_es5.symbols b/tests/baselines/reference/asyncUseStrict_es5.symbols
index a70f3ca546ab5..925f348249bbd 100644
--- a/tests/baselines/reference/asyncUseStrict_es5.symbols
+++ b/tests/baselines/reference/asyncUseStrict_es5.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(asyncUseStrict_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(asyncUseStrict_es5.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     "use strict";
     var b = await p || a;
diff --git a/tests/baselines/reference/asyncUseStrict_es6.symbols b/tests/baselines/reference/asyncUseStrict_es6.symbols
index f94c16664e7f0..8aa3606c3b4e1 100644
--- a/tests/baselines/reference/asyncUseStrict_es6.symbols
+++ b/tests/baselines/reference/asyncUseStrict_es6.symbols
@@ -4,11 +4,11 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(asyncUseStrict_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(asyncUseStrict_es6.ts, 1, 32))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     "use strict";
     var b = await p || a;
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es2017.symbols b/tests/baselines/reference/awaitBinaryExpression1_es2017.symbols
index 827769b3db5c9..b763a454458ed 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es2017.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression1_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression1_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression1_es2017.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es5.symbols b/tests/baselines/reference/awaitBinaryExpression1_es5.symbols
index 84d3b17b126cb..b1b3b04d6aaee 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es5.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression1_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression1_es5.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es5.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression1_es5.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
index 0f05f6521cb2f..f6782d3663661 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression1_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es2017.symbols b/tests/baselines/reference/awaitBinaryExpression2_es2017.symbols
index 549eb49cf9297..7f97d409b51bd 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es2017.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression2_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression2_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression2_es2017.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es5.symbols b/tests/baselines/reference/awaitBinaryExpression2_es5.symbols
index e44238d4172a7..1f8bafa8a3707 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es5.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression2_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression2_es5.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es5.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression2_es5.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
index 518e6eec528a0..e2b724e2c2d17 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression2_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es2017.symbols b/tests/baselines/reference/awaitBinaryExpression3_es2017.symbols
index 29c8fb7f398ef..1d7e1ff74a011 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es2017.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression3_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression3_es2017.ts, 1, 31))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression3_es2017.ts, 1, 31))
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es5.symbols b/tests/baselines/reference/awaitBinaryExpression3_es5.symbols
index d9480fdf5248a..7e8cd107b424e 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es5.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression3_es5.symbols
@@ -4,7 +4,7 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression3_es5.ts, 1, 31))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es5.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression3_es5.ts, 1, 31))
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
index 0d653c1ff7b42..afd2ae97641e8 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols
@@ -4,7 +4,7 @@ declare var a: number;
 
 declare var p: Promise<number>;
 >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression3_es6.ts, 1, 31))
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es2017.symbols b/tests/baselines/reference/awaitBinaryExpression4_es2017.symbols
index 0db5a20e0c11e..cf01d5ec85804 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es2017.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression4_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression4_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression4_es2017.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es5.symbols b/tests/baselines/reference/awaitBinaryExpression4_es5.symbols
index ab2cbeadfc5cf..19ffe817b1557 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es5.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression4_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression4_es5.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es5.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression4_es5.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
index 18a593225584c..61e12001c6a93 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression4_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es2017.symbols b/tests/baselines/reference/awaitBinaryExpression5_es2017.symbols
index e2d30c658f711..4b684c44f77ca 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es2017.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression5_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression5_es2017.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es2017.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression5_es2017.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es5.symbols b/tests/baselines/reference/awaitBinaryExpression5_es5.symbols
index ad258355d3872..b7255d25a5797 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es5.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression5_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression5_es5.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es5.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression5_es5.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
index 57a7958a13cff..fb50640ce7cfa 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function before(): void;
 >before : Symbol(before, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
@@ -14,7 +14,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 3, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitBinaryExpression5_es6.ts, 1, 32))
diff --git a/tests/baselines/reference/awaitCallExpression1_es2017.symbols b/tests/baselines/reference/awaitCallExpression1_es2017.symbols
index 68c28d153507e..373654dd11a21 100644
--- a/tests/baselines/reference/awaitCallExpression1_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression1_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression1_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression1_es5.symbols b/tests/baselines/reference/awaitCallExpression1_es5.symbols
index b172db760e37d..61851ae77f72e 100644
--- a/tests/baselines/reference/awaitCallExpression1_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression1_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression1_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression1_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression1_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression1_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression1_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols
index 1b1deb0f5795f..a81586bc4fe91 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression1_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression2_es2017.symbols b/tests/baselines/reference/awaitCallExpression2_es2017.symbols
index 4528ae4c0743d..6bf77f40d1927 100644
--- a/tests/baselines/reference/awaitCallExpression2_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression2_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression2_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression2_es5.symbols b/tests/baselines/reference/awaitCallExpression2_es5.symbols
index 95e1f65003099..71ecc53a3c93f 100644
--- a/tests/baselines/reference/awaitCallExpression2_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression2_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression2_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression2_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression2_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression2_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression2_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols
index d7f3cc0d4bd0a..91de39742dcf5 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression2_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression3_es2017.symbols b/tests/baselines/reference/awaitCallExpression3_es2017.symbols
index a1120103fb070..f42254489ce1d 100644
--- a/tests/baselines/reference/awaitCallExpression3_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression3_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression3_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression3_es5.symbols b/tests/baselines/reference/awaitCallExpression3_es5.symbols
index 2c18507340adc..66ef232948dd0 100644
--- a/tests/baselines/reference/awaitCallExpression3_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression3_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression3_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression3_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression3_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression3_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression3_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols
index 14b6f35bc30de..6b559d847d97e 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression3_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression4_es2017.symbols b/tests/baselines/reference/awaitCallExpression4_es2017.symbols
index fb607d9841f4f..60fc9f643f9ce 100644
--- a/tests/baselines/reference/awaitCallExpression4_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression4_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression4_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression4_es5.symbols b/tests/baselines/reference/awaitCallExpression4_es5.symbols
index 46a5b942956a8..f52e6d2b59e69 100644
--- a/tests/baselines/reference/awaitCallExpression4_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression4_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression4_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression4_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression4_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression4_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression4_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols
index d7e90fc4a53e5..33117d2d80bbd 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression4_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression5_es2017.symbols b/tests/baselines/reference/awaitCallExpression5_es2017.symbols
index 3854353314aef..ffad2bda5a66b 100644
--- a/tests/baselines/reference/awaitCallExpression5_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression5_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression5_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression5_es5.symbols b/tests/baselines/reference/awaitCallExpression5_es5.symbols
index 9f34c3e9fe81d..2d7b9bd875e04 100644
--- a/tests/baselines/reference/awaitCallExpression5_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression5_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression5_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression5_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression5_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression5_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression5_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols
index ba8f987818827..cf6afde09ed28 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression5_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression6_es2017.symbols b/tests/baselines/reference/awaitCallExpression6_es2017.symbols
index 6a651510328a4..f540e418f4a68 100644
--- a/tests/baselines/reference/awaitCallExpression6_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression6_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression6_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression6_es5.symbols b/tests/baselines/reference/awaitCallExpression6_es5.symbols
index fc3ae4cbdbb5c..a361b7ea7369d 100644
--- a/tests/baselines/reference/awaitCallExpression6_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression6_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression6_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression6_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression6_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression6_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression6_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols
index 938c49d1d4111..35feb7c8ea037 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression6_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression7_es2017.symbols b/tests/baselines/reference/awaitCallExpression7_es2017.symbols
index e95078c68500a..525af85372964 100644
--- a/tests/baselines/reference/awaitCallExpression7_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression7_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression7_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression7_es5.symbols b/tests/baselines/reference/awaitCallExpression7_es5.symbols
index 96a7252ef04d0..3b56d8520b014 100644
--- a/tests/baselines/reference/awaitCallExpression7_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression7_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression7_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression7_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression7_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression7_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression7_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols
index f366417b23f9d..fe6c1fb0eeb49 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression7_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression8_es2017.symbols b/tests/baselines/reference/awaitCallExpression8_es2017.symbols
index e3fd465c120f0..53ba162671da3 100644
--- a/tests/baselines/reference/awaitCallExpression8_es2017.symbols
+++ b/tests/baselines/reference/awaitCallExpression8_es2017.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression8_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression8_es2017.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_es2017.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es2017.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es2017.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es2017.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression8_es2017.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es2017.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es2017.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es2017.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es2017.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression8_es2017.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression8_es5.symbols b/tests/baselines/reference/awaitCallExpression8_es5.symbols
index 50b564481b960..e7f1659a7e7e4 100644
--- a/tests/baselines/reference/awaitCallExpression8_es5.symbols
+++ b/tests/baselines/reference/awaitCallExpression8_es5.symbols
@@ -4,7 +4,7 @@ declare var a: boolean;
 
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(awaitCallExpression8_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void;
 >fn : Symbol(fn, Decl(awaitCallExpression8_es5.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_es5.ts, 4, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es5.ts, 4, 28))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es5.ts, 4, 42))
 >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es5.ts, 4, 57))
 
 declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>;
 >po : Symbol(po, Decl(awaitCallExpression8_es5.ts, 5, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >fn : Symbol(fn, Decl(awaitCallExpression8_es5.ts, 5, 25))
 >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es5.ts, 5, 29))
 >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es5.ts, 5, 43))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es5.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression8_es5.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols
index 89441ea3e37da..037ab79b68f8a 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >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))
@@ -42,7 +42,7 @@ declare function after(): void;
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 7, 31))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     before();
 >before : Symbol(before, Decl(awaitCallExpression8_es6.ts, 5, 84))
diff --git a/tests/baselines/reference/awaitClassExpression_es2017.symbols b/tests/baselines/reference/awaitClassExpression_es2017.symbols
index bebffa2bbada4..1c497d8095181 100644
--- a/tests/baselines/reference/awaitClassExpression_es2017.symbols
+++ b/tests/baselines/reference/awaitClassExpression_es2017.symbols
@@ -4,12 +4,12 @@ declare class C { }
 
 declare var p: Promise<typeof C>;
 >p : Symbol(p, Decl(awaitClassExpression_es2017.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >C : Symbol(C, Decl(awaitClassExpression_es2017.ts, 0, 0))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitClassExpression_es2017.ts, 1, 33))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     class D extends (await p) {
 >D : Symbol(D, Decl(awaitClassExpression_es2017.ts, 3, 38))
diff --git a/tests/baselines/reference/awaitClassExpression_es5.symbols b/tests/baselines/reference/awaitClassExpression_es5.symbols
index 1f550576c0983..18b742e4437a8 100644
--- a/tests/baselines/reference/awaitClassExpression_es5.symbols
+++ b/tests/baselines/reference/awaitClassExpression_es5.symbols
@@ -4,12 +4,12 @@ declare class C { }
 
 declare var p: Promise<typeof C>;
 >p : Symbol(p, Decl(awaitClassExpression_es5.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >C : Symbol(C, Decl(awaitClassExpression_es5.ts, 0, 0))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitClassExpression_es5.ts, 1, 33))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     class D extends (await p) {
 >D : Symbol(D, Decl(awaitClassExpression_es5.ts, 3, 38))
diff --git a/tests/baselines/reference/awaitClassExpression_es6.symbols b/tests/baselines/reference/awaitClassExpression_es6.symbols
index 6d1e9f1a10316..b7c485e88c627 100644
--- a/tests/baselines/reference/awaitClassExpression_es6.symbols
+++ b/tests/baselines/reference/awaitClassExpression_es6.symbols
@@ -4,12 +4,12 @@ declare class C { }
 
 declare var p: Promise<typeof C>;
 >p : Symbol(p, Decl(awaitClassExpression_es6.ts, 1, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >C : Symbol(C, Decl(awaitClassExpression_es6.ts, 0, 0))
 
 async function func(): Promise<void> {
 >func : Symbol(func, Decl(awaitClassExpression_es6.ts, 1, 33))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     class D extends (await p) {
 >D : Symbol(D, Decl(awaitClassExpression_es6.ts, 3, 38))
diff --git a/tests/baselines/reference/awaitInheritedPromise_es2017.symbols b/tests/baselines/reference/awaitInheritedPromise_es2017.symbols
index ef68d16b67818..f4cf33bfe83a6 100644
--- a/tests/baselines/reference/awaitInheritedPromise_es2017.symbols
+++ b/tests/baselines/reference/awaitInheritedPromise_es2017.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/async/es2017/awaitInheritedPromise_es2017.ts ===
 interface A extends Promise<string> {}
 >A : Symbol(A, Decl(awaitInheritedPromise_es2017.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 declare var a: A;
 >a : Symbol(a, Decl(awaitInheritedPromise_es2017.ts, 1, 11))
diff --git a/tests/baselines/reference/bluebirdStaticThis.errors.txt b/tests/baselines/reference/bluebirdStaticThis.errors.txt
index 1c22a12c34179..b9e28711715a0 100644
--- a/tests/baselines/reference/bluebirdStaticThis.errors.txt
+++ b/tests/baselines/reference/bluebirdStaticThis.errors.txt
@@ -1,10 +1,10 @@
-tests/cases/compiler/bluebirdStaticThis.ts(5,15): error TS2420: Class 'Promise<R>' incorrectly implements interface 'Thenable<R>'.
+tests/cases/compiler/bluebirdStaticThis.ts(5,22): error TS2420: Class 'Promise<R>' incorrectly implements interface 'Thenable<R>'.
   Property 'then' is missing in type 'Promise<R>'.
-tests/cases/compiler/bluebirdStaticThis.ts(22,51): error TS2694: Namespace 'Promise' has no exported member 'Resolver'.
-tests/cases/compiler/bluebirdStaticThis.ts(57,109): error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
-tests/cases/compiler/bluebirdStaticThis.ts(58,91): error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
-tests/cases/compiler/bluebirdStaticThis.ts(59,91): error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
-tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
+tests/cases/compiler/bluebirdStaticThis.ts(22,51): error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Resolver'.
+tests/cases/compiler/bluebirdStaticThis.ts(57,109): error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
+tests/cases/compiler/bluebirdStaticThis.ts(58,91): error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
+tests/cases/compiler/bluebirdStaticThis.ts(59,91): error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
+tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
 
 
 ==== tests/cases/compiler/bluebirdStaticThis.ts (6 errors) ====
@@ -12,8 +12,8 @@ tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace 'Prom
     // and all the comments.
     // Then it adds explicit `this` arguments to the static members.
     // Tests by: Bart van der Schoor <https://github.com/Bartvds>
-    declare class Promise<R> implements Promise.Thenable<R> {
-                  ~~~~~~~
+    export declare class Promise<R> implements Promise.Thenable<R> {
+                         ~~~~~~~
 !!! error TS2420: Class 'Promise<R>' incorrectly implements interface 'Thenable<R>'.
 !!! error TS2420:   Property 'then' is missing in type 'Promise<R>'.
     	constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable<R>) => void, reject: (error: any) => void) => void);
@@ -34,7 +34,7 @@ tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace 'Prom
     
         static defer<R>(dit: typeof Promise): Promise.Resolver<R>;
                                                       ~~~~~~~~
-!!! error TS2694: Namespace 'Promise' has no exported member 'Resolver'.
+!!! error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Resolver'.
     
         static cast<R>(dit: typeof Promise, value: Promise.Thenable<R>): Promise<R>;
         static cast<R>(dit: typeof Promise, value: R): Promise<R>;
@@ -71,16 +71,16 @@ tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace 'Prom
     
         static settle<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<Promise.Inspection<R>[]>;
                                                                                                                 ~~~~~~~~~~
-!!! error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
+!!! error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
         static settle<R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<Promise.Inspection<R>[]>;
                                                                                               ~~~~~~~~~~
-!!! error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
+!!! error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
         static settle<R>(dit: typeof Promise, values: Promise.Thenable<R>[]): Promise<Promise.Inspection<R>[]>;
                                                                                               ~~~~~~~~~~
-!!! error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
+!!! error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
         static settle<R>(dit: typeof Promise, values: R[]): Promise<Promise.Inspection<R>[]>;
                                                                             ~~~~~~~~~~
-!!! error TS2694: Namespace 'Promise' has no exported member 'Inspection'.
+!!! error TS2694: Namespace '"tests/cases/compiler/bluebirdStaticThis".Promise' has no exported member 'Inspection'.
     
         static any<R>(dit: typeof Promise, values: Promise.Thenable<Promise.Thenable<R>[]>): Promise<R>;
         static any<R>(dit: typeof Promise, values: Promise.Thenable<R[]>): Promise<R>;
@@ -131,7 +131,7 @@ tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace 'Prom
         static filter<R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
     }
     
-    declare module Promise {
+    export declare module Promise {
     	export interface Thenable<R> {
     		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
     		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>;
@@ -141,9 +141,6 @@ tests/cases/compiler/bluebirdStaticThis.ts(60,73): error TS2694: Namespace 'Prom
     
     }
     
-    declare module 'bluebird' {
-    	export = Promise;
-    }
     interface Foo {
         a: number;
         b: string;
diff --git a/tests/baselines/reference/bluebirdStaticThis.js b/tests/baselines/reference/bluebirdStaticThis.js
index 606f778323fdb..1d8d8f2ec43a2 100644
--- a/tests/baselines/reference/bluebirdStaticThis.js
+++ b/tests/baselines/reference/bluebirdStaticThis.js
@@ -3,7 +3,7 @@
 // and all the comments.
 // Then it adds explicit `this` arguments to the static members.
 // Tests by: Bart van der Schoor <https://github.com/Bartvds>
-declare class Promise<R> implements Promise.Thenable<R> {
+export declare class Promise<R> implements Promise.Thenable<R> {
 	constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable<R>) => void, reject: (error: any) => void) => void);
     static try<R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
     static try<R>(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise<R>;
@@ -109,7 +109,7 @@ declare class Promise<R> implements Promise.Thenable<R> {
     static filter<R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
 }
 
-declare module Promise {
+export declare module Promise {
 	export interface Thenable<R> {
 		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
 		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>;
@@ -119,9 +119,6 @@ declare module Promise {
 
 }
 
-declare module 'bluebird' {
-	export = Promise;
-}
 interface Foo {
     a: number;
     b: string;
@@ -142,6 +139,8 @@ fooProm = Promise.try(Promise, () => {
 }, arr, x);
 
 //// [bluebirdStaticThis.js]
+"use strict";
+exports.__esModule = true;
 var x;
 var arr;
 var foo;
diff --git a/tests/baselines/reference/controlFlowInstanceof.symbols b/tests/baselines/reference/controlFlowInstanceof.symbols
index 3189482799013..19304ada88826 100644
--- a/tests/baselines/reference/controlFlowInstanceof.symbols
+++ b/tests/baselines/reference/controlFlowInstanceof.symbols
@@ -46,7 +46,7 @@ function f2(s: Set<string> | Set<number>) {
 
     if (s instanceof Promise) {
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         s;  // Set<number> & Promise<any>
 >s : Symbol(s, Decl(controlFlowInstanceof.ts, 13, 12))
diff --git a/tests/baselines/reference/decoratorMetadataPromise.symbols b/tests/baselines/reference/decoratorMetadataPromise.symbols
index b0ebe05e8c1c4..6eec0fe46233e 100644
--- a/tests/baselines/reference/decoratorMetadataPromise.symbols
+++ b/tests/baselines/reference/decoratorMetadataPromise.symbols
@@ -18,7 +18,7 @@ class A {
 
     async bar(): Promise<number> { return 0; }
 >bar : Symbol(A.bar, Decl(decoratorMetadataPromise.ts, 5, 18))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     @decorator
 >decorator : Symbol(decorator, Decl(decoratorMetadataPromise.ts, 1, 13))
@@ -26,8 +26,8 @@ class A {
     baz(n: Promise<number>): Promise<number> { return n; }
 >baz : Symbol(A.baz, Decl(decoratorMetadataPromise.ts, 7, 46))
 >n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >n : Symbol(n, Decl(decoratorMetadataPromise.ts, 9, 8))
 }
 
diff --git a/tests/baselines/reference/defaultExportInAwaitExpression01.symbols b/tests/baselines/reference/defaultExportInAwaitExpression01.symbols
index eb833f63895ca..9b77ee1a68bfb 100644
--- a/tests/baselines/reference/defaultExportInAwaitExpression01.symbols
+++ b/tests/baselines/reference/defaultExportInAwaitExpression01.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/modules/a.ts ===
 const x = new Promise( ( resolve, reject ) => { resolve( {} ); } );
 >x : Symbol(x, Decl(a.ts, 0, 5))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
 >reject : Symbol(reject, Decl(a.ts, 0, 33))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
diff --git a/tests/baselines/reference/defaultExportInAwaitExpression02.symbols b/tests/baselines/reference/defaultExportInAwaitExpression02.symbols
index eb833f63895ca..9b77ee1a68bfb 100644
--- a/tests/baselines/reference/defaultExportInAwaitExpression02.symbols
+++ b/tests/baselines/reference/defaultExportInAwaitExpression02.symbols
@@ -1,7 +1,7 @@
 === tests/cases/conformance/es6/modules/a.ts ===
 const x = new Promise( ( resolve, reject ) => { resolve( {} ); } );
 >x : Symbol(x, Decl(a.ts, 0, 5))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
 >reject : Symbol(reject, Decl(a.ts, 0, 33))
 >resolve : Symbol(resolve, Decl(a.ts, 0, 24))
diff --git a/tests/baselines/reference/es2017basicAsync.symbols b/tests/baselines/reference/es2017basicAsync.symbols
index d79faf1502af2..fc73741ba82a6 100644
--- a/tests/baselines/reference/es2017basicAsync.symbols
+++ b/tests/baselines/reference/es2017basicAsync.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/es2017basicAsync.ts ===
 
 async (): Promise<void> => {
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     await 0;
 }
@@ -14,7 +14,7 @@ async function asyncFunc() {
 
 const asyncArrowFunc = async (): Promise<void> => {
 >asyncArrowFunc : Symbol(asyncArrowFunc, Decl(es2017basicAsync.ts, 9, 5))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
     await 0;
 }
@@ -25,20 +25,20 @@ async function asyncIIFE() {
     await 0;
 
     await (async function(): Promise<void> {
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 1;
     })();
     
     await (async function asyncNamedFunc(): Promise<void> {
 >asyncNamedFunc : Symbol(asyncNamedFunc, Decl(es2017basicAsync.ts, 20, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 1;
     })();
     
     await (async (): Promise<void> => {
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 1;
     })();
@@ -49,7 +49,7 @@ class AsyncClass {
 
     asyncPropFunc = async function(): Promise<void> {
 >asyncPropFunc : Symbol(AsyncClass.asyncPropFunc, Decl(es2017basicAsync.ts, 29, 18))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 2;
     }
@@ -57,21 +57,21 @@ class AsyncClass {
     asyncPropNamedFunc = async function namedFunc(): Promise<void> {
 >asyncPropNamedFunc : Symbol(AsyncClass.asyncPropNamedFunc, Decl(es2017basicAsync.ts, 32, 5))
 >namedFunc : Symbol(namedFunc, Decl(es2017basicAsync.ts, 34, 24))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 2;
     }
 
     asyncPropArrowFunc = async (): Promise<void> => {
 >asyncPropArrowFunc : Symbol(AsyncClass.asyncPropArrowFunc, Decl(es2017basicAsync.ts, 36, 5))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 2;
     }
 
     async asyncMethod(): Promise<void> {
 >asyncMethod : Symbol(AsyncClass.asyncMethod, Decl(es2017basicAsync.ts, 40, 5))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
         await 2;
     }
diff --git a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols
index 6c6a182071707..eada06414bf07 100644
--- a/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols
+++ b/tests/baselines/reference/es5-asyncFunctionBinaryExpressions.symbols
@@ -259,7 +259,7 @@ async function binaryComma0() {
 
 async function binaryComma1(): Promise<any> {
 >binaryComma1 : Symbol(binaryComma1, Decl(es5-asyncFunctionBinaryExpressions.ts, 117, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     return x, await y;
 >x : Symbol(x, Decl(es5-asyncFunctionBinaryExpressions.ts, 0, 11))
diff --git a/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols b/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols
index 651af244e70d4..f2e6667c27e90 100644
--- a/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols
+++ b/tests/baselines/reference/es5-asyncFunctionReturnStatements.symbols
@@ -9,14 +9,14 @@ declare var x, y, z, a, b, c;
 
 async function returnStatement0(): Promise<any> {
 >returnStatement0 : Symbol(returnStatement0, Decl(es5-asyncFunctionReturnStatements.ts, 0, 29))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     return;
 }
 
 async function returnStatement1(): Promise<any> {
 >returnStatement1 : Symbol(returnStatement1, Decl(es5-asyncFunctionReturnStatements.ts, 4, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     return x;
 >x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11))
@@ -24,7 +24,7 @@ async function returnStatement1(): Promise<any> {
 
 async function returnStatement2(): Promise<any> {
 >returnStatement2 : Symbol(returnStatement2, Decl(es5-asyncFunctionReturnStatements.ts, 8, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     return await x;
 >x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11))
@@ -32,14 +32,14 @@ async function returnStatement2(): Promise<any> {
 
 async function returnStatement3(): Promise<any> {
 >returnStatement3 : Symbol(returnStatement3, Decl(es5-asyncFunctionReturnStatements.ts, 12, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     { return; }
 }
 
 async function returnStatement4(): Promise<any> {
 >returnStatement4 : Symbol(returnStatement4, Decl(es5-asyncFunctionReturnStatements.ts, 16, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     await x;
 >x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11))
@@ -49,7 +49,7 @@ async function returnStatement4(): Promise<any> {
 
 async function returnStatement5(): Promise<any>{
 >returnStatement5 : Symbol(returnStatement5, Decl(es5-asyncFunctionReturnStatements.ts, 21, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     { return await x; }
 >x : Symbol(x, Decl(es5-asyncFunctionReturnStatements.ts, 0, 11))
diff --git a/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols b/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols
index 52a4ec8df769b..fc73f21f62248 100644
--- a/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols
+++ b/tests/baselines/reference/es5-asyncFunctionTryStatements.symbols
@@ -66,7 +66,7 @@ async function tryCatch2() {
 
 async function tryCatch3(): Promise<Function> {
 >tryCatch3 : Symbol(tryCatch3, Decl(es5-asyncFunctionTryStatements.ts, 30, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Function : Symbol(Function, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     var x: any, y: any;
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction.symbols b/tests/baselines/reference/exportDefaultAsyncFunction.symbols
index 47178519558f3..a86226fe678a7 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction.symbols
+++ b/tests/baselines/reference/exportDefaultAsyncFunction.symbols
@@ -1,7 +1,7 @@
 === tests/cases/compiler/exportDefaultAsyncFunction.ts ===
 export default async function foo(): Promise<void> {}
 >foo : Symbol(foo, Decl(exportDefaultAsyncFunction.ts, 0, 0))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 foo();
 >foo : Symbol(foo, Decl(exportDefaultAsyncFunction.ts, 0, 0))
diff --git a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
index 013d0d7f697f7..cffbf284573b0 100644
--- a/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
+++ b/tests/baselines/reference/exportDefaultAsyncFunction2.symbols
@@ -18,7 +18,7 @@ export default async(() => await(Promise.resolve(1)));
 >async : Symbol(async, Decl(a.ts, 0, 8))
 >await : Symbol(await, Decl(a.ts, 0, 15))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 === tests/cases/compiler/b.ts ===
diff --git a/tests/baselines/reference/inferenceLimit.symbols b/tests/baselines/reference/inferenceLimit.symbols
index 721e7af7560df..82aecd7e7938c 100644
--- a/tests/baselines/reference/inferenceLimit.symbols
+++ b/tests/baselines/reference/inferenceLimit.symbols
@@ -14,7 +14,7 @@ export class BrokenClass {
 >value : Symbol(value, Decl(file1.ts, 7, 36))
 
   return new Promise<Array<MyModule.MyModel>>((resolve, reject) => {
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >MyModule : Symbol(MyModule, Decl(file1.ts, 1, 6))
 >MyModel : Symbol(MyModule.MyModel, Decl(mymodule.ts, 0, 0))
@@ -32,19 +32,19 @@ export class BrokenClass {
 >order : Symbol(order, Decl(file1.ts, 12, 25))
 
       return new Promise((resolve, reject) => {
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(file1.ts, 13, 26))
 >reject : Symbol(reject, Decl(file1.ts, 13, 34))
 
         this.doStuff(order.id)
->this.doStuff(order.id)          .then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>this.doStuff(order.id)          .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >this.doStuff : Symbol(BrokenClass.doStuff, Decl(file1.ts, 27, 3))
 >this : Symbol(BrokenClass, Decl(file1.ts, 1, 39))
 >doStuff : Symbol(BrokenClass.doStuff, Decl(file1.ts, 27, 3))
 >order : Symbol(order, Decl(file1.ts, 12, 25))
 
           .then((items) => {
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >items : Symbol(items, Decl(file1.ts, 15, 17))
 
             order.items = items;
@@ -60,9 +60,9 @@ export class BrokenClass {
     };
 
     return Promise.all(result.map(populateItems))
->Promise.all(result.map(populateItems))      .then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>Promise.all(result.map(populateItems))      .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >result.map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >result : Symbol(result, Decl(file1.ts, 10, 7))
@@ -70,7 +70,7 @@ export class BrokenClass {
 >populateItems : Symbol(populateItems, Decl(file1.ts, 12, 7))
 
       .then((orders: Array<MyModule.MyModel>) => {
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >orders : Symbol(orders, Decl(file1.ts, 23, 13))
 >Array : Symbol(Array, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --))
 >MyModule : Symbol(MyModule, Decl(file1.ts, 1, 6))
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols
index d8520698e6cd3..ed7bb2697ab4f 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions1.symbols
@@ -112,7 +112,7 @@ async function out() {
 >out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37))
 
     return new Promise(function (resolve, reject) {});
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 33))
 >reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 49, 41))
 }
@@ -121,9 +121,9 @@ declare var console: any;
 >console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11))
 
 out().then(() => {
->out().then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 45, 37))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     console.log("Yea!");
 >console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions1.ts, 52, 11))
diff --git a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols
index ea1eb599c6fb0..22c2173db42ec 100644
--- a/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols
+++ b/tests/baselines/reference/modularizeLibrary_NoErrorDuplicateLibOptions2.symbols
@@ -112,7 +112,7 @@ async function out() {
 >out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37))
 
     return new Promise(function (resolve, reject) {});
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 33))
 >reject : Symbol(reject, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 49, 41))
 }
@@ -121,9 +121,9 @@ declare var console: any;
 >console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11))
 
 out().then(() => {
->out().then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >out : Symbol(out, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 45, 37))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     console.log("Yea!");
 >console : Symbol(console, Decl(modularizeLibrary_NoErrorDuplicateLibOptions2.ts, 52, 11))
diff --git a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols
index ed1fb96ded3aa..cc74a4e843a7b 100644
--- a/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols
+++ b/tests/baselines/reference/modularizeLibrary_TargetES5UsingES6Lib.symbols
@@ -112,7 +112,7 @@ async function out() {
 >out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37))
 
     return new Promise(function (resolve, reject) {});
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >resolve : Symbol(resolve, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 33))
 >reject : Symbol(reject, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 49, 41))
 }
@@ -121,9 +121,9 @@ declare var console: any;
 >console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11))
 
 out().then(() => {
->out().then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>out().then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >out : Symbol(out, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 45, 37))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     console.log("Yea!");
 >console : Symbol(console, Decl(modularizeLibrary_TargetES5UsingES6Lib.ts, 52, 11))
diff --git a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
index 7bf70fbf04e1e..58d14c2a6d04e 100644
--- a/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
+++ b/tests/baselines/reference/noImplicitReturnsInAsync1.symbols
@@ -12,6 +12,6 @@ async function test(isError: boolean = false) {
     let x = await Promise.resolve("The test is passed without an error.");
 >x : Symbol(x, Decl(noImplicitReturnsInAsync1.ts, 5, 7))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 }
diff --git a/tests/baselines/reference/promiseIdentity.js b/tests/baselines/reference/promiseIdentity.js
index 5b57709e991e8..526bae62c0812 100644
--- a/tests/baselines/reference/promiseIdentity.js
+++ b/tests/baselines/reference/promiseIdentity.js
@@ -1,5 +1,5 @@
 //// [promiseIdentity.ts]
-interface IPromise<T> {
+export interface IPromise<T> {
     then<U>(callback: (x: T) => IPromise<U>): IPromise<U>;
 }
 interface Promise<T> {
@@ -22,6 +22,8 @@ var y: IPromise2<string, number>;
 var y: Promise2<any, string>;
 
 //// [promiseIdentity.js]
+"use strict";
+exports.__esModule = true;
 var x;
 var x;
 // Ok because T in this particular Promise2 is any, as are all the U and W references.
diff --git a/tests/baselines/reference/promiseIdentity.symbols b/tests/baselines/reference/promiseIdentity.symbols
index f1404eaf7b194..f103f5b4199dd 100644
--- a/tests/baselines/reference/promiseIdentity.symbols
+++ b/tests/baselines/reference/promiseIdentity.symbols
@@ -1,14 +1,14 @@
 === tests/cases/compiler/promiseIdentity.ts ===
-interface IPromise<T> {
+export interface IPromise<T> {
 >IPromise : Symbol(IPromise, Decl(promiseIdentity.ts, 0, 0))
->T : Symbol(T, Decl(promiseIdentity.ts, 0, 19))
+>T : Symbol(T, Decl(promiseIdentity.ts, 0, 26))
 
     then<U>(callback: (x: T) => IPromise<U>): IPromise<U>;
->then : Symbol(IPromise.then, Decl(promiseIdentity.ts, 0, 23))
+>then : Symbol(IPromise.then, Decl(promiseIdentity.ts, 0, 30))
 >U : Symbol(U, Decl(promiseIdentity.ts, 1, 9))
 >callback : Symbol(callback, Decl(promiseIdentity.ts, 1, 12))
 >x : Symbol(x, Decl(promiseIdentity.ts, 1, 23))
->T : Symbol(T, Decl(promiseIdentity.ts, 0, 19))
+>T : Symbol(T, Decl(promiseIdentity.ts, 0, 26))
 >IPromise : Symbol(IPromise, Decl(promiseIdentity.ts, 0, 0))
 >U : Symbol(U, Decl(promiseIdentity.ts, 1, 9))
 >IPromise : Symbol(IPromise, Decl(promiseIdentity.ts, 0, 0))
diff --git a/tests/baselines/reference/promiseIdentity.types b/tests/baselines/reference/promiseIdentity.types
index 2be853c996467..af8bc9908bf0a 100644
--- a/tests/baselines/reference/promiseIdentity.types
+++ b/tests/baselines/reference/promiseIdentity.types
@@ -1,5 +1,5 @@
 === tests/cases/compiler/promiseIdentity.ts ===
-interface IPromise<T> {
+export interface IPromise<T> {
 >IPromise : IPromise<T>
 >T : T
 
diff --git a/tests/baselines/reference/promiseIdentity2.errors.txt b/tests/baselines/reference/promiseIdentity2.errors.txt
index 6b8223c3bdad4..edfba2f42bcd4 100644
--- a/tests/baselines/reference/promiseIdentity2.errors.txt
+++ b/tests/baselines/reference/promiseIdentity2.errors.txt
@@ -2,10 +2,10 @@ tests/cases/compiler/promiseIdentity2.ts(11,5): error TS2403: Subsequent variabl
 
 
 ==== tests/cases/compiler/promiseIdentity2.ts (1 errors) ====
-    interface IPromise<T, V> {
+    export interface IPromise<T, V> {
         then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
     }
-    interface Promise<T, V> {
+    export interface Promise<T, V> {
         then<U, W>(callback: (x: T) => Promise<T, U>): Promise<T, W>;
     }
     
diff --git a/tests/baselines/reference/promiseIdentity2.js b/tests/baselines/reference/promiseIdentity2.js
index 8bb4139a7375f..81beb44d78a74 100644
--- a/tests/baselines/reference/promiseIdentity2.js
+++ b/tests/baselines/reference/promiseIdentity2.js
@@ -1,8 +1,8 @@
 //// [promiseIdentity2.ts]
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
     then<U, W>(callback: (x: T) => Promise<T, U>): Promise<T, W>;
 }
 
@@ -12,6 +12,8 @@ var x: IPromise<string, number>;
 var x: Promise<any, string>;
 
 //// [promiseIdentity2.js]
+"use strict";
+exports.__esModule = true;
 // error because T is string in the first declaration, and T is boolean in the second
 // Return type and callback return type are ok because T is any in this particular Promise
 var x;
diff --git a/tests/baselines/reference/promiseIdentityWithAny.js b/tests/baselines/reference/promiseIdentityWithAny.js
index 1a516067c8e3d..422d00a131272 100644
--- a/tests/baselines/reference/promiseIdentityWithAny.js
+++ b/tests/baselines/reference/promiseIdentityWithAny.js
@@ -1,8 +1,8 @@
 //// [promiseIdentityWithAny.ts]
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
     then<U, W>(callback: (x: T) => Promise<any, any>): Promise<any, any>;
 }
 
@@ -11,6 +11,8 @@ var x: IPromise<string, number>;
 var x: Promise<string, boolean>;
 
 //// [promiseIdentityWithAny.js]
+"use strict";
+exports.__esModule = true;
 // Should be ok because signature type parameters get erased to any
 var x;
 var x;
diff --git a/tests/baselines/reference/promiseIdentityWithAny.symbols b/tests/baselines/reference/promiseIdentityWithAny.symbols
index 8bcf096a0a37c..65881f53a321e 100644
--- a/tests/baselines/reference/promiseIdentityWithAny.symbols
+++ b/tests/baselines/reference/promiseIdentityWithAny.symbols
@@ -1,16 +1,16 @@
 === tests/cases/compiler/promiseIdentityWithAny.ts ===
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
 >IPromise : Symbol(IPromise, Decl(promiseIdentityWithAny.ts, 0, 0))
->T : Symbol(T, Decl(promiseIdentityWithAny.ts, 0, 19))
->V : Symbol(V, Decl(promiseIdentityWithAny.ts, 0, 21))
+>T : Symbol(T, Decl(promiseIdentityWithAny.ts, 0, 26))
+>V : Symbol(V, Decl(promiseIdentityWithAny.ts, 0, 28))
 
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
->then : Symbol(IPromise.then, Decl(promiseIdentityWithAny.ts, 0, 26))
+>then : Symbol(IPromise.then, Decl(promiseIdentityWithAny.ts, 0, 33))
 >U : Symbol(U, Decl(promiseIdentityWithAny.ts, 1, 9))
 >W : Symbol(W, Decl(promiseIdentityWithAny.ts, 1, 11))
 >callback : Symbol(callback, Decl(promiseIdentityWithAny.ts, 1, 15))
 >x : Symbol(x, Decl(promiseIdentityWithAny.ts, 1, 26))
->T : Symbol(T, Decl(promiseIdentityWithAny.ts, 0, 19))
+>T : Symbol(T, Decl(promiseIdentityWithAny.ts, 0, 26))
 >IPromise : Symbol(IPromise, Decl(promiseIdentityWithAny.ts, 0, 0))
 >U : Symbol(U, Decl(promiseIdentityWithAny.ts, 1, 9))
 >W : Symbol(W, Decl(promiseIdentityWithAny.ts, 1, 11))
@@ -18,18 +18,18 @@ interface IPromise<T, V> {
 >U : Symbol(U, Decl(promiseIdentityWithAny.ts, 1, 9))
 >W : Symbol(W, Decl(promiseIdentityWithAny.ts, 1, 11))
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
 >Promise : Symbol(Promise, Decl(promiseIdentityWithAny.ts, 2, 1))
->T : Symbol(T, Decl(promiseIdentityWithAny.ts, 3, 18))
->V : Symbol(V, Decl(promiseIdentityWithAny.ts, 3, 20))
+>T : Symbol(T, Decl(promiseIdentityWithAny.ts, 3, 25))
+>V : Symbol(V, Decl(promiseIdentityWithAny.ts, 3, 27))
 
     then<U, W>(callback: (x: T) => Promise<any, any>): Promise<any, any>;
->then : Symbol(Promise.then, Decl(promiseIdentityWithAny.ts, 3, 25))
+>then : Symbol(Promise.then, Decl(promiseIdentityWithAny.ts, 3, 32))
 >U : Symbol(U, Decl(promiseIdentityWithAny.ts, 4, 9))
 >W : Symbol(W, Decl(promiseIdentityWithAny.ts, 4, 11))
 >callback : Symbol(callback, Decl(promiseIdentityWithAny.ts, 4, 15))
 >x : Symbol(x, Decl(promiseIdentityWithAny.ts, 4, 26))
->T : Symbol(T, Decl(promiseIdentityWithAny.ts, 3, 18))
+>T : Symbol(T, Decl(promiseIdentityWithAny.ts, 3, 25))
 >Promise : Symbol(Promise, Decl(promiseIdentityWithAny.ts, 2, 1))
 >Promise : Symbol(Promise, Decl(promiseIdentityWithAny.ts, 2, 1))
 }
diff --git a/tests/baselines/reference/promiseIdentityWithAny.types b/tests/baselines/reference/promiseIdentityWithAny.types
index f96e6d903639c..d5efb5a6f8b97 100644
--- a/tests/baselines/reference/promiseIdentityWithAny.types
+++ b/tests/baselines/reference/promiseIdentityWithAny.types
@@ -1,5 +1,5 @@
 === tests/cases/compiler/promiseIdentityWithAny.ts ===
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
 >IPromise : IPromise<T, V>
 >T : T
 >V : V
@@ -18,7 +18,7 @@ interface IPromise<T, V> {
 >U : U
 >W : W
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
 >Promise : Promise<T, V>
 >T : T
 >V : V
diff --git a/tests/baselines/reference/promiseIdentityWithAny2.errors.txt b/tests/baselines/reference/promiseIdentityWithAny2.errors.txt
index 36492d3f37acd..9d01438b88c49 100644
--- a/tests/baselines/reference/promiseIdentityWithAny2.errors.txt
+++ b/tests/baselines/reference/promiseIdentityWithAny2.errors.txt
@@ -3,7 +3,7 @@ tests/cases/compiler/promiseIdentityWithAny2.ts(22,5): error TS2403: Subsequent
 
 
 ==== tests/cases/compiler/promiseIdentityWithAny2.ts (2 errors) ====
-    interface IPromise<T, V> {
+    export interface IPromise<T, V> {
         then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
     }
     interface Promise<T, V> {
diff --git a/tests/baselines/reference/promiseIdentityWithAny2.js b/tests/baselines/reference/promiseIdentityWithAny2.js
index ec98b5ed4d971..a26cfd0508448 100644
--- a/tests/baselines/reference/promiseIdentityWithAny2.js
+++ b/tests/baselines/reference/promiseIdentityWithAny2.js
@@ -1,5 +1,5 @@
 //// [promiseIdentityWithAny2.ts]
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
 interface Promise<T, V> {
@@ -23,6 +23,8 @@ var y: IPromise2<string, number>;
 var y: Promise2<string, boolean>;
 
 //// [promiseIdentityWithAny2.js]
+"use strict";
+exports.__esModule = true;
 // Error because type parameter arity doesn't match
 var x;
 var x;
diff --git a/tests/baselines/reference/promiseIdentityWithConstraints.js b/tests/baselines/reference/promiseIdentityWithConstraints.js
index 0130d22df8f61..5c0549dc99d78 100644
--- a/tests/baselines/reference/promiseIdentityWithConstraints.js
+++ b/tests/baselines/reference/promiseIdentityWithConstraints.js
@@ -1,8 +1,8 @@
 //// [promiseIdentityWithConstraints.ts]
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U extends T, W extends V>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
     then<U extends T, W extends V>(callback: (x: T) => Promise<U, W>): Promise<U, W>;
 }
 
@@ -11,6 +11,8 @@ var x: IPromise<string, number>;
 var x: Promise<string, boolean>;
 
 //// [promiseIdentityWithConstraints.js]
+"use strict";
+exports.__esModule = true;
 // Error because constraint V doesn't match
 var x;
 var x;
diff --git a/tests/baselines/reference/promiseIdentityWithConstraints.symbols b/tests/baselines/reference/promiseIdentityWithConstraints.symbols
index 00308362b18f4..bcdc3c441bdeb 100644
--- a/tests/baselines/reference/promiseIdentityWithConstraints.symbols
+++ b/tests/baselines/reference/promiseIdentityWithConstraints.symbols
@@ -1,18 +1,18 @@
 === tests/cases/compiler/promiseIdentityWithConstraints.ts ===
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
 >IPromise : Symbol(IPromise, Decl(promiseIdentityWithConstraints.ts, 0, 0))
->T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 0, 19))
->V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 0, 21))
+>T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 0, 26))
+>V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 0, 28))
 
     then<U extends T, W extends V>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
->then : Symbol(IPromise.then, Decl(promiseIdentityWithConstraints.ts, 0, 26))
+>then : Symbol(IPromise.then, Decl(promiseIdentityWithConstraints.ts, 0, 33))
 >U : Symbol(U, Decl(promiseIdentityWithConstraints.ts, 1, 9))
->T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 0, 19))
+>T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 0, 26))
 >W : Symbol(W, Decl(promiseIdentityWithConstraints.ts, 1, 21))
->V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 0, 21))
+>V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 0, 28))
 >callback : Symbol(callback, Decl(promiseIdentityWithConstraints.ts, 1, 35))
 >x : Symbol(x, Decl(promiseIdentityWithConstraints.ts, 1, 46))
->T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 0, 19))
+>T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 0, 26))
 >IPromise : Symbol(IPromise, Decl(promiseIdentityWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(promiseIdentityWithConstraints.ts, 1, 9))
 >W : Symbol(W, Decl(promiseIdentityWithConstraints.ts, 1, 21))
@@ -20,20 +20,20 @@ interface IPromise<T, V> {
 >U : Symbol(U, Decl(promiseIdentityWithConstraints.ts, 1, 9))
 >W : Symbol(W, Decl(promiseIdentityWithConstraints.ts, 1, 21))
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
 >Promise : Symbol(Promise, Decl(promiseIdentityWithConstraints.ts, 2, 1))
->T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 3, 18))
->V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 3, 20))
+>T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 3, 25))
+>V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 3, 27))
 
     then<U extends T, W extends V>(callback: (x: T) => Promise<U, W>): Promise<U, W>;
->then : Symbol(Promise.then, Decl(promiseIdentityWithConstraints.ts, 3, 25))
+>then : Symbol(Promise.then, Decl(promiseIdentityWithConstraints.ts, 3, 32))
 >U : Symbol(U, Decl(promiseIdentityWithConstraints.ts, 4, 9))
->T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 3, 18))
+>T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 3, 25))
 >W : Symbol(W, Decl(promiseIdentityWithConstraints.ts, 4, 21))
->V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 3, 20))
+>V : Symbol(V, Decl(promiseIdentityWithConstraints.ts, 3, 27))
 >callback : Symbol(callback, Decl(promiseIdentityWithConstraints.ts, 4, 35))
 >x : Symbol(x, Decl(promiseIdentityWithConstraints.ts, 4, 46))
->T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 3, 18))
+>T : Symbol(T, Decl(promiseIdentityWithConstraints.ts, 3, 25))
 >Promise : Symbol(Promise, Decl(promiseIdentityWithConstraints.ts, 2, 1))
 >U : Symbol(U, Decl(promiseIdentityWithConstraints.ts, 4, 9))
 >W : Symbol(W, Decl(promiseIdentityWithConstraints.ts, 4, 21))
diff --git a/tests/baselines/reference/promiseIdentityWithConstraints.types b/tests/baselines/reference/promiseIdentityWithConstraints.types
index 5bc321cbb16cc..9c52a9581b8cb 100644
--- a/tests/baselines/reference/promiseIdentityWithConstraints.types
+++ b/tests/baselines/reference/promiseIdentityWithConstraints.types
@@ -1,5 +1,5 @@
 === tests/cases/compiler/promiseIdentityWithConstraints.ts ===
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
 >IPromise : IPromise<T, V>
 >T : T
 >V : V
@@ -20,7 +20,7 @@ interface IPromise<T, V> {
 >U : U
 >W : W
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
 >Promise : Promise<T, V>
 >T : T
 >V : V
diff --git a/tests/baselines/reference/promisePermutations.errors.txt b/tests/baselines/reference/promisePermutations.errors.txt
index 13fc071859691..661d66a4a446b 100644
--- a/tests/baselines/reference/promisePermutations.errors.txt
+++ b/tests/baselines/reference/promisePermutations.errors.txt
@@ -51,9 +51,9 @@ tests/cases/compiler/promisePermutations.ts(144,12): error TS2453: The type argu
 tests/cases/compiler/promisePermutations.ts(152,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'Promise<number>' is not a valid type argument because it is not a supertype of candidate 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
-        Types of parameters 'success' and 'success' are incompatible.
-          Type '(value: number) => Promise<any>' is not assignable to type '(value: string) => IPromise<any>'.
+      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+        Types of parameters 'success' and 'onfulfilled' are incompatible.
+          Type '(value: number) => number | PromiseLike<number>' is not assignable to type '(value: string) => IPromise<any>'.
             Types of parameters 'value' and 'value' are incompatible.
               Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/promisePermutations.ts(156,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
@@ -68,9 +68,9 @@ tests/cases/compiler/promisePermutations.ts(159,21): error TS2345: Argument of t
 tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
-        Types of parameters 'success' and 'success' are incompatible.
-          Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => Promise<any>'.
+      Type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+        Types of parameters 'onfulfilled' and 'success' are incompatible.
+          Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => number | PromiseLike<number>'.
             Types of parameters 'value' and 'value' are incompatible.
               Type 'number' is not assignable to type 'string'.
 
@@ -310,9 +310,9 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t
 !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate 'Promise<number>' is not a valid type argument because it is not a supertype of candidate 'IPromise<string>'.
 !!! error TS2453:     Types of property 'then' are incompatible.
-!!! error TS2453:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
-!!! error TS2453:         Types of parameters 'success' and 'success' are incompatible.
-!!! error TS2453:           Type '(value: number) => Promise<any>' is not assignable to type '(value: string) => IPromise<any>'.
+!!! error TS2453:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2453:         Types of parameters 'success' and 'onfulfilled' are incompatible.
+!!! error TS2453:           Type '(value: number) => number | PromiseLike<number>' is not assignable to type '(value: string) => IPromise<any>'.
 !!! error TS2453:             Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2453:               Type 'string' is not assignable to type 'number'.
     var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
@@ -339,9 +339,9 @@ tests/cases/compiler/promisePermutations.ts(160,21): error TS2345: Argument of t
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
-!!! error TS2345:         Types of parameters 'success' and 'success' are incompatible.
-!!! error TS2345:           Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => Promise<any>'.
+!!! error TS2345:       Type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+!!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
+!!! error TS2345:           Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => number | PromiseLike<number>'.
 !!! error TS2345:             Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:               Type 'number' is not assignable to type 'string'.
     
diff --git a/tests/baselines/reference/promisePermutations2.errors.txt b/tests/baselines/reference/promisePermutations2.errors.txt
index b21a3a3920886..b133801f7763b 100644
--- a/tests/baselines/reference/promisePermutations2.errors.txt
+++ b/tests/baselines/reference/promisePermutations2.errors.txt
@@ -51,9 +51,9 @@ tests/cases/compiler/promisePermutations2.ts(143,12): error TS2453: The type arg
 tests/cases/compiler/promisePermutations2.ts(151,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'Promise<number>' is not a valid type argument because it is not a supertype of candidate 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => Promise<U>'.
-        Types of parameters 'success' and 'success' are incompatible.
-          Type '(value: number) => any' is not assignable to type '(value: string) => IPromise<any>'.
+      Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+        Types of parameters 'success' and 'onfulfilled' are incompatible.
+          Type '(value: number) => number | PromiseLike<number>' is not assignable to type '(value: string) => IPromise<any>'.
             Types of parameters 'value' and 'value' are incompatible.
               Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/promisePermutations2.ts(155,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
@@ -68,9 +68,9 @@ tests/cases/compiler/promisePermutations2.ts(158,21): error TS2345: Argument of
 tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => Promise<U>' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
-        Types of parameters 'success' and 'success' are incompatible.
-          Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => any'.
+      Type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+        Types of parameters 'onfulfilled' and 'success' are incompatible.
+          Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => number | PromiseLike<number>'.
             Types of parameters 'value' and 'value' are incompatible.
               Type 'number' is not assignable to type 'string'.
 
@@ -309,9 +309,9 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate 'Promise<number>' is not a valid type argument because it is not a supertype of candidate 'IPromise<string>'.
 !!! error TS2453:     Types of property 'then' are incompatible.
-!!! error TS2453:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => Promise<U>'.
-!!! error TS2453:         Types of parameters 'success' and 'success' are incompatible.
-!!! error TS2453:           Type '(value: number) => any' is not assignable to type '(value: string) => IPromise<any>'.
+!!! error TS2453:       Type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }' is not assignable to type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2453:         Types of parameters 'success' and 'onfulfilled' are incompatible.
+!!! error TS2453:           Type '(value: number) => number | PromiseLike<number>' is not assignable to type '(value: string) => IPromise<any>'.
 !!! error TS2453:             Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2453:               Type 'string' is not assignable to type 'number'.
     var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
@@ -338,9 +338,9 @@ tests/cases/compiler/promisePermutations2.ts(159,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '<U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void) => Promise<U>' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
-!!! error TS2345:         Types of parameters 'success' and 'success' are incompatible.
-!!! error TS2345:           Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => any'.
+!!! error TS2345:       Type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '{ <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => IPromise<U>, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => IPromise<U>, progress?: (progress: any) => void): IPromise<U>; <U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void): IPromise<U>; }'.
+!!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
+!!! error TS2345:           Type '(value: string) => IPromise<any>' is not assignable to type '(value: number) => number | PromiseLike<number>'.
 !!! error TS2345:             Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:               Type 'number' is not assignable to type 'string'.
     
diff --git a/tests/baselines/reference/promisePermutations3.errors.txt b/tests/baselines/reference/promisePermutations3.errors.txt
index 1a33d1083aac3..b6c2a1cdfc726 100644
--- a/tests/baselines/reference/promisePermutations3.errors.txt
+++ b/tests/baselines/reference/promisePermutations3.errors.txt
@@ -54,9 +54,9 @@ tests/cases/compiler/promisePermutations3.ts(143,12): error TS2453: The type arg
 tests/cases/compiler/promisePermutations3.ts(151,12): error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
   Type argument candidate 'Promise<number>' is not a valid type argument because it is not a supertype of candidate 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
-        Types of parameters 'success' and 'success' are incompatible.
-          Type '(value: number) => Promise<any>' is not assignable to type '(value: string) => any'.
+      Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+        Types of parameters 'success' and 'onfulfilled' are incompatible.
+          Type '(value: number) => number | PromiseLike<number>' is not assignable to type '(value: string) => any'.
             Types of parameters 'value' and 'value' are incompatible.
               Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/promisePermutations3.ts(155,21): error TS2345: Argument of type '{ (x: number): IPromise<number>; (x: string): IPromise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
@@ -71,15 +71,15 @@ tests/cases/compiler/promisePermutations3.ts(158,21): error TS2345: Argument of
 tests/cases/compiler/promisePermutations3.ts(159,21): error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
     Types of property 'then' are incompatible.
-      Type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
-        Types of parameters 'success' and 'success' are incompatible.
-          Type '(value: string) => any' is not assignable to type '(value: number) => Promise<any>'.
+      Type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
+        Types of parameters 'onfulfilled' and 'success' are incompatible.
+          Type '(value: string) => any' is not assignable to type '(value: number) => number | PromiseLike<number>'.
             Types of parameters 'value' and 'value' are incompatible.
               Type 'number' is not assignable to type 'string'.
 tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     Types of property 'then' are incompatible.
-      Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+      Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ (onfulfilled?: (value: any) => any, onrejected?: (reason: any) => any): Promise<any>; <TResult>(onfulfilled: (value: any) => any, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<any>; <TResult>(onfulfilled: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
         Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 
 
@@ -321,9 +321,9 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2453: The type argument for type parameter 'U' cannot be inferred from the usage. Consider specifying the type arguments explicitly.
 !!! error TS2453:   Type argument candidate 'Promise<number>' is not a valid type argument because it is not a supertype of candidate 'IPromise<string>'.
 !!! error TS2453:     Types of property 'then' are incompatible.
-!!! error TS2453:       Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
-!!! error TS2453:         Types of parameters 'success' and 'success' are incompatible.
-!!! error TS2453:           Type '(value: number) => Promise<any>' is not assignable to type '(value: string) => any'.
+!!! error TS2453:       Type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2453:         Types of parameters 'success' and 'onfulfilled' are incompatible.
+!!! error TS2453:           Type '(value: number) => number | PromiseLike<number>' is not assignable to type '(value: string) => any'.
 !!! error TS2453:             Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2453:               Type 'string' is not assignable to type 'number'.
     var s10g = s10.then(testFunctionP, nIPromise, sIPromise).then(sPromise, sIPromise, sIPromise); // ok
@@ -350,9 +350,9 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ (x: number): Promise<number>; (x: string): Promise<string>; }' is not assignable to parameter of type '(value: number) => IPromise<string>'.
 !!! error TS2345:   Type 'Promise<number>' is not assignable to type 'IPromise<string>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '{ <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
-!!! error TS2345:         Types of parameters 'success' and 'success' are incompatible.
-!!! error TS2345:           Type '(value: string) => any' is not assignable to type '(value: number) => Promise<any>'.
+!!! error TS2345:       Type '{ (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: number) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }' is not assignable to type '<U>(success?: (value: string) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>'.
+!!! error TS2345:         Types of parameters 'onfulfilled' and 'success' are incompatible.
+!!! error TS2345:           Type '(value: string) => any' is not assignable to type '(value: number) => number | PromiseLike<number>'.
 !!! error TS2345:             Types of parameters 'value' and 'value' are incompatible.
 !!! error TS2345:               Type 'number' is not assignable to type 'string'.
     
@@ -365,6 +365,6 @@ tests/cases/compiler/promisePermutations3.ts(165,21): error TS2345: Argument of
 !!! error TS2345: Argument of type '{ <T>(x: T): IPromise<T>; <T>(x: T, y: T): Promise<T>; }' is not assignable to parameter of type '(value: (x: any) => any) => Promise<any>'.
 !!! error TS2345:   Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
 !!! error TS2345:     Types of property 'then' are incompatible.
-!!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
+!!! error TS2345:       Type '<U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void) => IPromise<U>' is not assignable to type '{ (onfulfilled?: (value: any) => any, onrejected?: (reason: any) => any): Promise<any>; <TResult>(onfulfilled: (value: any) => any, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<any>; <TResult>(onfulfilled: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: any) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => Promise<U>, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => Promise<U>, progress?: (progress: any) => void): Promise<U>; <U>(success?: (value: any) => U, error?: (error: any) => U, progress?: (progress: any) => void): Promise<U>; }'.
 !!! error TS2345:         Type 'IPromise<any>' is not assignable to type 'Promise<any>'.
     var s12c = s12.then(testFunction12P, testFunction12, testFunction12); // ok
\ No newline at end of file
diff --git a/tests/baselines/reference/promiseTest.symbols b/tests/baselines/reference/promiseTest.symbols
index 6cf4ff98d8fc5..547e2de52feb6 100644
--- a/tests/baselines/reference/promiseTest.symbols
+++ b/tests/baselines/reference/promiseTest.symbols
@@ -1,44 +1,44 @@
 === tests/cases/compiler/promiseTest.ts ===
 
 interface Promise<T> {
->Promise : Symbol(Promise, Decl(promiseTest.ts, 0, 0))
->T : Symbol(T, Decl(promiseTest.ts, 1, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18))
 
     then<A>(success?: (value: T) => Promise<A>): Promise<A>;
->then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
 >A : Symbol(A, Decl(promiseTest.ts, 2, 9))
 >success : Symbol(success, Decl(promiseTest.ts, 2, 12))
 >value : Symbol(value, Decl(promiseTest.ts, 2, 23))
->T : Symbol(T, Decl(promiseTest.ts, 1, 18))
->Promise : Symbol(Promise, Decl(promiseTest.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0))
 >A : Symbol(A, Decl(promiseTest.ts, 2, 9))
->Promise : Symbol(Promise, Decl(promiseTest.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0))
 >A : Symbol(A, Decl(promiseTest.ts, 2, 9))
 
     then<B>(success?: (value: T) => B): Promise<B>;
->then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
 >B : Symbol(B, Decl(promiseTest.ts, 3, 9))
 >success : Symbol(success, Decl(promiseTest.ts, 3, 12))
 >value : Symbol(value, Decl(promiseTest.ts, 3, 23))
->T : Symbol(T, Decl(promiseTest.ts, 1, 18))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18))
 >B : Symbol(B, Decl(promiseTest.ts, 3, 9))
->Promise : Symbol(Promise, Decl(promiseTest.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0))
 >B : Symbol(B, Decl(promiseTest.ts, 3, 9))
 
     data: T;
 >data : Symbol(Promise.data, Decl(promiseTest.ts, 3, 51))
->T : Symbol(T, Decl(promiseTest.ts, 1, 18))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 18))
 }
 
 var p: Promise<number> = null;
 >p : Symbol(p, Decl(promiseTest.ts, 7, 3))
->Promise : Symbol(Promise, Decl(promiseTest.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 0, 0))
 
 var p2 = p.then(function (x) {
 >p2 : Symbol(p2, Decl(promiseTest.ts, 8, 3))
->p.then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
+>p.then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
 >p : Symbol(p, Decl(promiseTest.ts, 7, 3))
->then : Symbol(Promise.then, Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTest.ts, 1, 22), Decl(promiseTest.ts, 2, 60))
 >x : Symbol(x, Decl(promiseTest.ts, 8, 26))
 
     return p;
diff --git a/tests/baselines/reference/promiseTest.types b/tests/baselines/reference/promiseTest.types
index 5ec43b9f42b39..fdcc05203f837 100644
--- a/tests/baselines/reference/promiseTest.types
+++ b/tests/baselines/reference/promiseTest.types
@@ -5,7 +5,7 @@ interface Promise<T> {
 >T : T
 
     then<A>(success?: (value: T) => Promise<A>): Promise<A>;
->then : { <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
 >A : A
 >success : (value: T) => Promise<A>
 >value : T
@@ -16,7 +16,7 @@ interface Promise<T> {
 >A : A
 
     then<B>(success?: (value: T) => B): Promise<B>;
->then : { <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: T) => Promise<A>): Promise<A>; <B>(success?: (value: T) => B): Promise<B>; }
 >B : B
 >success : (value: T) => B
 >value : T
@@ -38,9 +38,9 @@ var p: Promise<number> = null;
 var p2 = p.then(function (x) {
 >p2 : Promise<number>
 >p.then(function (x) {    return p;} ) : Promise<number>
->p.then : { <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
+>p.then : { (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
 >p : Promise<number>
->then : { <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
+>then : { (onfulfilled?: (value: number) => number | PromiseLike<number>, onrejected?: (reason: any) => number | PromiseLike<number>): Promise<number>; <TResult>(onfulfilled: (value: number) => number | PromiseLike<number>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<number | TResult>; <TResult>(onfulfilled: (value: number) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: number) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <A>(success?: (value: number) => Promise<A>): Promise<A>; <B>(success?: (value: number) => B): Promise<B>; }
 >function (x) {    return p;} : (x: number) => Promise<number>
 >x : number
 
diff --git a/tests/baselines/reference/promiseType.symbols b/tests/baselines/reference/promiseType.symbols
index 845aed26d5e32..23a9450137186 100644
--- a/tests/baselines/reference/promiseType.symbols
+++ b/tests/baselines/reference/promiseType.symbols
@@ -1,88 +1,88 @@
 === tests/cases/compiler/promiseType.ts ===
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 const a = p.then();
 >a : Symbol(a, Decl(promiseType.ts, 2, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const b = p.then(b => 1);
 >b : Symbol(b, Decl(promiseType.ts, 3, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseType.ts, 3, 17))
 
 const c = p.then(b => 1, e => 'error');
 >c : Symbol(c, Decl(promiseType.ts, 4, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseType.ts, 4, 17))
 >e : Symbol(e, Decl(promiseType.ts, 4, 24))
 
 const d = p.then(b => 1, e => { });
 >d : Symbol(d, Decl(promiseType.ts, 5, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseType.ts, 5, 17))
 >e : Symbol(e, Decl(promiseType.ts, 5, 24))
 
 const e = p.then(b => 1, e => { throw Error(); });
 >e : Symbol(e, Decl(promiseType.ts, 6, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseType.ts, 6, 17))
 >e : Symbol(e, Decl(promiseType.ts, 6, 24))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const f = p.then(b => 1, e => Promise.reject(Error()));
 >f : Symbol(f, Decl(promiseType.ts, 7, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseType.ts, 7, 17))
 >e : Symbol(e, Decl(promiseType.ts, 7, 24))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const g = p.catch(e => 'error');
 >g : Symbol(g, Decl(promiseType.ts, 8, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseType.ts, 8, 18))
 
 const h = p.catch(e => { });
 >h : Symbol(h, Decl(promiseType.ts, 9, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseType.ts, 9, 18))
 
 const i = p.catch(e => { throw Error(); });
 >i : Symbol(i, Decl(promiseType.ts, 10, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseType.ts, 10, 18))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const j = p.catch(e => Promise.reject(Error()));
 >j : Symbol(j, Decl(promiseType.ts, 11, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseType.ts, 11, 18))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
@@ -167,7 +167,7 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
     }
@@ -226,7 +226,7 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
     }
@@ -236,405 +236,405 @@ async function I() {
 
 const p00 = p.catch();
 >p00 : Symbol(p00, Decl(promiseType.ts, 96, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p01 = p.catch(undefined);
 >p01 : Symbol(p01, Decl(promiseType.ts, 97, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p07 = p.catch(null);
 >p07 : Symbol(p07, Decl(promiseType.ts, 98, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p02 = p.catch(() => 1);
 >p02 : Symbol(p02, Decl(promiseType.ts, 99, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p03 = p.catch(() => {});
 >p03 : Symbol(p03, Decl(promiseType.ts, 100, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p04 = p.catch(() => {throw 1});
 >p04 : Symbol(p04, Decl(promiseType.ts, 101, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p05 = p.catch(() => Promise.reject(1));
 >p05 : Symbol(p05, Decl(promiseType.ts, 102, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p06 = p.catch(() => Promise.resolve(1));
 >p06 : Symbol(p06, Decl(promiseType.ts, 103, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p10 = p.then();
 >p10 : Symbol(p10, Decl(promiseType.ts, 105, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p20 = p.then(undefined);
 >p20 : Symbol(p20, Decl(promiseType.ts, 107, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p21 = p.then(() => 1);
 >p21 : Symbol(p21, Decl(promiseType.ts, 108, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p22 = p.then(() => {});
 >p22 : Symbol(p22, Decl(promiseType.ts, 109, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p23 = p.then(() => {throw 1});
 >p23 : Symbol(p23, Decl(promiseType.ts, 110, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p24 = p.then(() => Promise.resolve(1));
 >p24 : Symbol(p24, Decl(promiseType.ts, 111, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p25 = p.then(() => Promise.reject(1));
 >p25 : Symbol(p25, Decl(promiseType.ts, 112, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p30 = p.then(undefined, undefined);
 >p30 : Symbol(p30, Decl(promiseType.ts, 114, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p31 = p.then(undefined, () => 1);
 >p31 : Symbol(p31, Decl(promiseType.ts, 115, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p32 = p.then(undefined, () => {});
 >p32 : Symbol(p32, Decl(promiseType.ts, 116, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p33 = p.then(undefined, () => {throw 1});
 >p33 : Symbol(p33, Decl(promiseType.ts, 117, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p34 = p.then(undefined, () => Promise.resolve(1));
 >p34 : Symbol(p34, Decl(promiseType.ts, 118, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p35 = p.then(undefined, () => Promise.reject(1));
 >p35 : Symbol(p35, Decl(promiseType.ts, 119, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p40 = p.then(() => "1", undefined);
 >p40 : Symbol(p40, Decl(promiseType.ts, 121, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p41 = p.then(() => "1", () => 1);
 >p41 : Symbol(p41, Decl(promiseType.ts, 122, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p42 = p.then(() => "1", () => {});
 >p42 : Symbol(p42, Decl(promiseType.ts, 123, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p43 = p.then(() => "1", () => {throw 1});
 >p43 : Symbol(p43, Decl(promiseType.ts, 124, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p44 = p.then(() => "1", () => Promise.resolve(1));
 >p44 : Symbol(p44, Decl(promiseType.ts, 125, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p45 = p.then(() => "1", () => Promise.reject(1));
 >p45 : Symbol(p45, Decl(promiseType.ts, 126, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p50 = p.then(() => {}, undefined);
 >p50 : Symbol(p50, Decl(promiseType.ts, 128, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p51 = p.then(() => {}, () => 1);
 >p51 : Symbol(p51, Decl(promiseType.ts, 129, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p52 = p.then(() => {}, () => {});
 >p52 : Symbol(p52, Decl(promiseType.ts, 130, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p53 = p.then(() => {}, () => {throw 1});
 >p53 : Symbol(p53, Decl(promiseType.ts, 131, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p54 = p.then(() => {}, () => Promise.resolve(1));
 >p54 : Symbol(p54, Decl(promiseType.ts, 132, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p55 = p.then(() => {}, () => Promise.reject(1));
 >p55 : Symbol(p55, Decl(promiseType.ts, 133, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p60 = p.then(() => {throw 1}, undefined);
 >p60 : Symbol(p60, Decl(promiseType.ts, 135, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p61 = p.then(() => {throw 1}, () => 1);
 >p61 : Symbol(p61, Decl(promiseType.ts, 136, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p62 = p.then(() => {throw 1}, () => {});
 >p62 : Symbol(p62, Decl(promiseType.ts, 137, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p63 = p.then(() => {throw 1}, () => {throw 1});
 >p63 : Symbol(p63, Decl(promiseType.ts, 138, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p64 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >p64 : Symbol(p64, Decl(promiseType.ts, 139, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p65 = p.then(() => {throw 1}, () => Promise.reject(1));
 >p65 : Symbol(p65, Decl(promiseType.ts, 140, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p70 = p.then(() => Promise.resolve("1"), undefined);
 >p70 : Symbol(p70, Decl(promiseType.ts, 142, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p71 = p.then(() => Promise.resolve("1"), () => 1);
 >p71 : Symbol(p71, Decl(promiseType.ts, 143, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p72 = p.then(() => Promise.resolve("1"), () => {});
 >p72 : Symbol(p72, Decl(promiseType.ts, 144, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p73 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >p73 : Symbol(p73, Decl(promiseType.ts, 145, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p74 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >p74 : Symbol(p74, Decl(promiseType.ts, 146, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p75 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >p75 : Symbol(p75, Decl(promiseType.ts, 147, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p80 = p.then(() => Promise.reject(1), undefined);
 >p80 : Symbol(p80, Decl(promiseType.ts, 149, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p81 = p.then(() => Promise.reject(1), () => 1);
 >p81 : Symbol(p81, Decl(promiseType.ts, 150, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p82 = p.then(() => Promise.reject(1), () => {});
 >p82 : Symbol(p82, Decl(promiseType.ts, 151, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p83 = p.then(() => Promise.reject(1), () => {throw 1});
 >p83 : Symbol(p83, Decl(promiseType.ts, 152, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p84 = p.then(() => Promise.reject(1), () => Promise.resolve(1));
 >p84 : Symbol(p84, Decl(promiseType.ts, 153, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p85 = p.then(() => Promise.reject(1), () => Promise.reject(1));
 >p85 : Symbol(p85, Decl(promiseType.ts, 154, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseType.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
diff --git a/tests/baselines/reference/promiseTypeInference.symbols b/tests/baselines/reference/promiseTypeInference.symbols
index 1dcf037b8b388..427158c88eb60 100644
--- a/tests/baselines/reference/promiseTypeInference.symbols
+++ b/tests/baselines/reference/promiseTypeInference.symbols
@@ -1,17 +1,17 @@
 === tests/cases/compiler/promiseTypeInference.ts ===
 declare class Promise<T> {
->Promise : Symbol(Promise, Decl(promiseTypeInference.ts, 0, 0))
->T : Symbol(T, Decl(promiseTypeInference.ts, 0, 22))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 22))
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 26))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 1, 9))
 >success : Symbol(success, Decl(promiseTypeInference.ts, 1, 12))
 >value : Symbol(value, Decl(promiseTypeInference.ts, 1, 23))
->T : Symbol(T, Decl(promiseTypeInference.ts, 0, 22))
->Promise : Symbol(Promise, Decl(promiseTypeInference.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 22))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 1, 9))
->Promise : Symbol(Promise, Decl(promiseTypeInference.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
 >U : Symbol(U, Decl(promiseTypeInference.ts, 1, 9))
 }
 interface IPromise<T> {
@@ -32,7 +32,7 @@ interface IPromise<T> {
 declare function load(name: string): Promise<string>;
 >load : Symbol(load, Decl(promiseTypeInference.ts, 5, 1))
 >name : Symbol(name, Decl(promiseTypeInference.ts, 6, 22))
->Promise : Symbol(Promise, Decl(promiseTypeInference.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 0))
 
 declare function convert(s: string): IPromise<number>;
 >convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 53))
@@ -41,9 +41,9 @@ declare function convert(s: string): IPromise<number>;
 
 var $$x = load("something").then(s => convert(s));
 >$$x : Symbol($$x, Decl(promiseTypeInference.ts, 9, 3))
->load("something").then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
+>load("something").then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 26))
 >load : Symbol(load, Decl(promiseTypeInference.ts, 5, 1))
->then : Symbol(Promise.then, Decl(promiseTypeInference.ts, 0, 26))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promiseTypeInference.ts, 0, 26))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
 >convert : Symbol(convert, Decl(promiseTypeInference.ts, 6, 53))
 >s : Symbol(s, Decl(promiseTypeInference.ts, 9, 33))
diff --git a/tests/baselines/reference/promiseTypeInference.types b/tests/baselines/reference/promiseTypeInference.types
index f3026c68f2123..cd1a57d6414ea 100644
--- a/tests/baselines/reference/promiseTypeInference.types
+++ b/tests/baselines/reference/promiseTypeInference.types
@@ -4,7 +4,7 @@ declare class Promise<T> {
 >T : T
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : <U>(success?: (value: T) => Promise<U>) => Promise<U>
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => Promise<U>
 >value : T
@@ -42,11 +42,11 @@ declare function convert(s: string): IPromise<number>;
 var $$x = load("something").then(s => convert(s));
 >$$x : Promise<number>
 >load("something").then(s => convert(s)) : Promise<number>
->load("something").then : <U>(success?: (value: string) => Promise<U>) => Promise<U>
+>load("something").then : { (onfulfilled?: (value: string) => string | PromiseLike<string>, onrejected?: (reason: any) => string | PromiseLike<string>): Promise<string>; <TResult>(onfulfilled: (value: string) => string | PromiseLike<string>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<string | TResult>; <TResult>(onfulfilled: (value: string) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
 >load("something") : Promise<string>
 >load : (name: string) => Promise<string>
 >"something" : "something"
->then : <U>(success?: (value: string) => Promise<U>) => Promise<U>
+>then : { (onfulfilled?: (value: string) => string | PromiseLike<string>, onrejected?: (reason: any) => string | PromiseLike<string>): Promise<string>; <TResult>(onfulfilled: (value: string) => string | PromiseLike<string>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<string | TResult>; <TResult>(onfulfilled: (value: string) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: string) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: string) => Promise<U>): Promise<U>; }
 >s => convert(s) : (s: string) => IPromise<number>
 >s : string
 >convert(s) : IPromise<number>
diff --git a/tests/baselines/reference/promiseTypeStrictNull.symbols b/tests/baselines/reference/promiseTypeStrictNull.symbols
index bf14c51656e05..f7972286d2f39 100644
--- a/tests/baselines/reference/promiseTypeStrictNull.symbols
+++ b/tests/baselines/reference/promiseTypeStrictNull.symbols
@@ -1,88 +1,88 @@
 === tests/cases/compiler/promiseTypeStrictNull.ts ===
 declare var p: Promise<boolean>;
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 
 const a = p.then();
 >a : Symbol(a, Decl(promiseTypeStrictNull.ts, 2, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const b = p.then(b => 1);
 >b : Symbol(b, Decl(promiseTypeStrictNull.ts, 3, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseTypeStrictNull.ts, 3, 17))
 
 const c = p.then(b => 1, e => 'error');
 >c : Symbol(c, Decl(promiseTypeStrictNull.ts, 4, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseTypeStrictNull.ts, 4, 17))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 4, 24))
 
 const d = p.then(b => 1, e => { });
 >d : Symbol(d, Decl(promiseTypeStrictNull.ts, 5, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseTypeStrictNull.ts, 5, 17))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 5, 24))
 
 const e = p.then(b => 1, e => { throw Error(); });
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 6, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseTypeStrictNull.ts, 6, 17))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 6, 24))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const f = p.then(b => 1, e => Promise.reject(Error()));
 >f : Symbol(f, Decl(promiseTypeStrictNull.ts, 7, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >b : Symbol(b, Decl(promiseTypeStrictNull.ts, 7, 17))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 7, 24))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const g = p.catch(e => 'error');
 >g : Symbol(g, Decl(promiseTypeStrictNull.ts, 8, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 8, 18))
 
 const h = p.catch(e => { });
 >h : Symbol(h, Decl(promiseTypeStrictNull.ts, 9, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 9, 18))
 
 const i = p.catch(e => { throw Error(); });
 >i : Symbol(i, Decl(promiseTypeStrictNull.ts, 10, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 10, 18))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const j = p.catch(e => Promise.reject(Error()));
 >j : Symbol(j, Decl(promiseTypeStrictNull.ts, 11, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >e : Symbol(e, Decl(promiseTypeStrictNull.ts, 11, 18))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
@@ -167,7 +167,7 @@ async function F() {
 
         return Promise.reject(Error());
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
     }
@@ -226,7 +226,7 @@ async function I() {
 
         return Promise.reject(Error());
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
     }
@@ -236,405 +236,405 @@ async function I() {
 
 const p00 = p.catch();
 >p00 : Symbol(p00, Decl(promiseTypeStrictNull.ts, 96, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p01 = p.catch(undefined);
 >p01 : Symbol(p01, Decl(promiseTypeStrictNull.ts, 97, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p07 = p.catch(null);
 >p07 : Symbol(p07, Decl(promiseTypeStrictNull.ts, 98, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p02 = p.catch(() => 1);
 >p02 : Symbol(p02, Decl(promiseTypeStrictNull.ts, 99, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p03 = p.catch(() => {});
 >p03 : Symbol(p03, Decl(promiseTypeStrictNull.ts, 100, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p04 = p.catch(() => {throw 1});
 >p04 : Symbol(p04, Decl(promiseTypeStrictNull.ts, 101, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p05 = p.catch(() => Promise.reject(1));
 >p05 : Symbol(p05, Decl(promiseTypeStrictNull.ts, 102, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p06 = p.catch(() => Promise.resolve(1));
 >p06 : Symbol(p06, Decl(promiseTypeStrictNull.ts, 103, 5))
->p.catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->catch : Symbol(Promise.catch, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>catch : Symbol(Promise.catch, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p10 = p.then();
 >p10 : Symbol(p10, Decl(promiseTypeStrictNull.ts, 105, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p20 = p.then(undefined);
 >p20 : Symbol(p20, Decl(promiseTypeStrictNull.ts, 107, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p21 = p.then(() => 1);
 >p21 : Symbol(p21, Decl(promiseTypeStrictNull.ts, 108, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p22 = p.then(() => {});
 >p22 : Symbol(p22, Decl(promiseTypeStrictNull.ts, 109, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p23 = p.then(() => {throw 1});
 >p23 : Symbol(p23, Decl(promiseTypeStrictNull.ts, 110, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p24 = p.then(() => Promise.resolve(1));
 >p24 : Symbol(p24, Decl(promiseTypeStrictNull.ts, 111, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p25 = p.then(() => Promise.reject(1));
 >p25 : Symbol(p25, Decl(promiseTypeStrictNull.ts, 112, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p30 = p.then(undefined, undefined);
 >p30 : Symbol(p30, Decl(promiseTypeStrictNull.ts, 114, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 >undefined : Symbol(undefined)
 
 const p31 = p.then(undefined, () => 1);
 >p31 : Symbol(p31, Decl(promiseTypeStrictNull.ts, 115, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p32 = p.then(undefined, () => {});
 >p32 : Symbol(p32, Decl(promiseTypeStrictNull.ts, 116, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p33 = p.then(undefined, () => {throw 1});
 >p33 : Symbol(p33, Decl(promiseTypeStrictNull.ts, 117, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p34 = p.then(undefined, () => Promise.resolve(1));
 >p34 : Symbol(p34, Decl(promiseTypeStrictNull.ts, 118, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p35 = p.then(undefined, () => Promise.reject(1));
 >p35 : Symbol(p35, Decl(promiseTypeStrictNull.ts, 119, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p40 = p.then(() => "1", undefined);
 >p40 : Symbol(p40, Decl(promiseTypeStrictNull.ts, 121, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p41 = p.then(() => "1", () => 1);
 >p41 : Symbol(p41, Decl(promiseTypeStrictNull.ts, 122, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p42 = p.then(() => "1", () => {});
 >p42 : Symbol(p42, Decl(promiseTypeStrictNull.ts, 123, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p43 = p.then(() => "1", () => {throw 1});
 >p43 : Symbol(p43, Decl(promiseTypeStrictNull.ts, 124, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p44 = p.then(() => "1", () => Promise.resolve(1));
 >p44 : Symbol(p44, Decl(promiseTypeStrictNull.ts, 125, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p45 = p.then(() => "1", () => Promise.reject(1));
 >p45 : Symbol(p45, Decl(promiseTypeStrictNull.ts, 126, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p50 = p.then(() => {}, undefined);
 >p50 : Symbol(p50, Decl(promiseTypeStrictNull.ts, 128, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p51 = p.then(() => {}, () => 1);
 >p51 : Symbol(p51, Decl(promiseTypeStrictNull.ts, 129, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p52 = p.then(() => {}, () => {});
 >p52 : Symbol(p52, Decl(promiseTypeStrictNull.ts, 130, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p53 = p.then(() => {}, () => {throw 1});
 >p53 : Symbol(p53, Decl(promiseTypeStrictNull.ts, 131, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p54 = p.then(() => {}, () => Promise.resolve(1));
 >p54 : Symbol(p54, Decl(promiseTypeStrictNull.ts, 132, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p55 = p.then(() => {}, () => Promise.reject(1));
 >p55 : Symbol(p55, Decl(promiseTypeStrictNull.ts, 133, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p60 = p.then(() => {throw 1}, undefined);
 >p60 : Symbol(p60, Decl(promiseTypeStrictNull.ts, 135, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p61 = p.then(() => {throw 1}, () => 1);
 >p61 : Symbol(p61, Decl(promiseTypeStrictNull.ts, 136, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p62 = p.then(() => {throw 1}, () => {});
 >p62 : Symbol(p62, Decl(promiseTypeStrictNull.ts, 137, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p63 = p.then(() => {throw 1}, () => {throw 1});
 >p63 : Symbol(p63, Decl(promiseTypeStrictNull.ts, 138, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
 const p64 = p.then(() => {throw 1}, () => Promise.resolve(1));
 >p64 : Symbol(p64, Decl(promiseTypeStrictNull.ts, 139, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p65 = p.then(() => {throw 1}, () => Promise.reject(1));
 >p65 : Symbol(p65, Decl(promiseTypeStrictNull.ts, 140, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p70 = p.then(() => Promise.resolve("1"), undefined);
 >p70 : Symbol(p70, Decl(promiseTypeStrictNull.ts, 142, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p71 = p.then(() => Promise.resolve("1"), () => 1);
 >p71 : Symbol(p71, Decl(promiseTypeStrictNull.ts, 143, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p72 = p.then(() => Promise.resolve("1"), () => {});
 >p72 : Symbol(p72, Decl(promiseTypeStrictNull.ts, 144, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p73 = p.then(() => Promise.resolve("1"), () => {throw 1});
 >p73 : Symbol(p73, Decl(promiseTypeStrictNull.ts, 145, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p74 = p.then(() => Promise.resolve("1"), () => Promise.resolve(1));
 >p74 : Symbol(p74, Decl(promiseTypeStrictNull.ts, 146, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p75 = p.then(() => Promise.resolve("1"), () => Promise.reject(1));
 >p75 : Symbol(p75, Decl(promiseTypeStrictNull.ts, 147, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p80 = p.then(() => Promise.reject(1), undefined);
 >p80 : Symbol(p80, Decl(promiseTypeStrictNull.ts, 149, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >undefined : Symbol(undefined)
 
 const p81 = p.then(() => Promise.reject(1), () => 1);
 >p81 : Symbol(p81, Decl(promiseTypeStrictNull.ts, 150, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p82 = p.then(() => Promise.reject(1), () => {});
 >p82 : Symbol(p82, Decl(promiseTypeStrictNull.ts, 151, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p83 = p.then(() => Promise.reject(1), () => {throw 1});
 >p83 : Symbol(p83, Decl(promiseTypeStrictNull.ts, 152, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p84 = p.then(() => Promise.reject(1), () => Promise.resolve(1));
 >p84 : Symbol(p84, Decl(promiseTypeStrictNull.ts, 153, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
 const p85 = p.then(() => Promise.reject(1), () => Promise.reject(1));
 >p85 : Symbol(p85, Decl(promiseTypeStrictNull.ts, 154, 5))
->p.then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>p.then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >p : Symbol(p, Decl(promiseTypeStrictNull.ts, 0, 11))
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >Promise.reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >reject : Symbol(PromiseConstructor.reject, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 
diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols
index 67747f5f1500d..722cd771890e6 100644
--- a/tests/baselines/reference/promiseVoidErrorCallback.symbols
+++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols
@@ -22,12 +22,12 @@ interface T3 {
 
 function f1(): Promise<T1> {
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0))
 
     return Promise.resolve({ __t1: "foo_t1" });
 >Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
 >resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
 >__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.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
->f1()    .then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>f1()    .then(f2, (e: Error) => {    throw e;})    .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
+>f1()    .then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1))
 
     .then(f2, (e: Error) => {
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1))
 >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15))
 >Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
@@ -62,7 +62,7 @@ var x3 = f1()
 
 })
     .then((x: T2) => {
->then : Symbol(Promise.then, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>then : Symbol(Promise.then, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11))
 >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1))
 
diff --git a/tests/baselines/reference/promises.symbols b/tests/baselines/reference/promises.symbols
index 623a9cfb20a50..e8f66a92cbb65 100644
--- a/tests/baselines/reference/promises.symbols
+++ b/tests/baselines/reference/promises.symbols
@@ -1,31 +1,31 @@
 === tests/cases/compiler/promises.ts ===
 interface Promise<T> {
->Promise : Symbol(Promise, Decl(promises.ts, 0, 0))
->T : Symbol(T, Decl(promises.ts, 0, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 18))
 
     then<U>(success?: (value: T) => U): Promise<U>;
->then : Symbol(Promise.then, Decl(promises.ts, 0, 22), Decl(promises.ts, 1, 51))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 22), Decl(promises.ts, 1, 51))
 >U : Symbol(U, Decl(promises.ts, 1, 9))
 >success : Symbol(success, Decl(promises.ts, 1, 12))
 >value : Symbol(value, Decl(promises.ts, 1, 23))
->T : Symbol(T, Decl(promises.ts, 0, 18))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 18))
 >U : Symbol(U, Decl(promises.ts, 1, 9))
->Promise : Symbol(Promise, Decl(promises.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 0))
 >U : Symbol(U, Decl(promises.ts, 1, 9))
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : Symbol(Promise.then, Decl(promises.ts, 0, 22), Decl(promises.ts, 1, 51))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 22), Decl(promises.ts, 1, 51))
 >U : Symbol(U, Decl(promises.ts, 2, 9))
 >success : Symbol(success, Decl(promises.ts, 2, 12))
 >value : Symbol(value, Decl(promises.ts, 2, 23))
->T : Symbol(T, Decl(promises.ts, 0, 18))
->Promise : Symbol(Promise, Decl(promises.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 0))
 >U : Symbol(U, Decl(promises.ts, 2, 9))
->Promise : Symbol(Promise, Decl(promises.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 0))
 >U : Symbol(U, Decl(promises.ts, 2, 9))
 
     value: T;
 >value : Symbol(Promise.value, Decl(promises.ts, 2, 60))
->T : Symbol(T, Decl(promises.ts, 0, 18))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promises.ts, 0, 18))
 }
 
diff --git a/tests/baselines/reference/promises.types b/tests/baselines/reference/promises.types
index 639d28677d732..90372af206b78 100644
--- a/tests/baselines/reference/promises.types
+++ b/tests/baselines/reference/promises.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(success?: (value: T) => U): Promise<U>;
->then : { <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => U
 >value : T
@@ -14,7 +14,7 @@ interface Promise<T> {
 >U : U
 
     then<U>(success?: (value: T) => Promise<U>): Promise<U>;
->then : { <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(success?: (value: T) => U): Promise<U>; <U>(success?: (value: T) => Promise<U>): Promise<U>; }
 >U : U
 >success : (value: T) => Promise<U>
 >value : T
diff --git a/tests/baselines/reference/promisesWithConstraints.symbols b/tests/baselines/reference/promisesWithConstraints.symbols
index a180a26135cca..c6ced6b291d0b 100644
--- a/tests/baselines/reference/promisesWithConstraints.symbols
+++ b/tests/baselines/reference/promisesWithConstraints.symbols
@@ -1,17 +1,17 @@
 === tests/cases/compiler/promisesWithConstraints.ts ===
 interface Promise<T> {
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
->T : Symbol(T, Decl(promisesWithConstraints.ts, 0, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 18))
 
     then<U>(cb: (x: T) => Promise<U>): Promise<U>;
->then : Symbol(Promise.then, Decl(promisesWithConstraints.ts, 0, 22))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 22))
 >U : Symbol(U, Decl(promisesWithConstraints.ts, 1, 9))
 >cb : Symbol(cb, Decl(promisesWithConstraints.ts, 1, 12))
 >x : Symbol(x, Decl(promisesWithConstraints.ts, 1, 17))
->T : Symbol(T, Decl(promisesWithConstraints.ts, 0, 18))
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(promisesWithConstraints.ts, 1, 9))
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(promisesWithConstraints.ts, 1, 9))
 }
 
@@ -27,9 +27,9 @@ interface CPromise<T extends { x: any; }> {
 >cb : Symbol(cb, Decl(promisesWithConstraints.ts, 5, 32))
 >x : Symbol(x, Decl(promisesWithConstraints.ts, 5, 37))
 >T : Symbol(T, Decl(promisesWithConstraints.ts, 4, 19))
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(promisesWithConstraints.ts, 5, 9))
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
 >U : Symbol(U, Decl(promisesWithConstraints.ts, 5, 9))
 }
 
@@ -44,12 +44,12 @@ interface Bar { x; y; }
 
 var a: Promise<Foo>;
 >a : Symbol(a, Decl(promisesWithConstraints.ts, 11, 3))
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
 >Foo : Symbol(Foo, Decl(promisesWithConstraints.ts, 6, 1))
 
 var b: Promise<Bar>;
 >b : Symbol(b, Decl(promisesWithConstraints.ts, 12, 3))
->Promise : Symbol(Promise, Decl(promisesWithConstraints.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(promisesWithConstraints.ts, 0, 0))
 >Bar : Symbol(Bar, Decl(promisesWithConstraints.ts, 8, 20))
 
 a = b; // ok
diff --git a/tests/baselines/reference/promisesWithConstraints.types b/tests/baselines/reference/promisesWithConstraints.types
index a8c4c64d3fd1c..d8ebc002a4f4d 100644
--- a/tests/baselines/reference/promisesWithConstraints.types
+++ b/tests/baselines/reference/promisesWithConstraints.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(cb: (x: T) => Promise<U>): Promise<U>;
->then : <U>(cb: (x: T) => Promise<U>) => Promise<U>
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(cb: (x: T) => Promise<U>): Promise<U>; }
 >U : U
 >cb : (x: T) => Promise<U>
 >x : T
diff --git a/tests/baselines/reference/specializationError.symbols b/tests/baselines/reference/specializationError.symbols
index b866a7034df3d..42b37b40c83bc 100644
--- a/tests/baselines/reference/specializationError.symbols
+++ b/tests/baselines/reference/specializationError.symbols
@@ -1,13 +1,13 @@
 === tests/cases/compiler/specializationError.ts ===
 interface Promise<T> {
->Promise : Symbol(Promise, Decl(specializationError.ts, 0, 0))
->T : Symbol(T, Decl(specializationError.ts, 0, 18))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 0))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 18))
 
     then<U>(value: T): void;
->then : Symbol(Promise.then, Decl(specializationError.ts, 0, 22))
+>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 22))
 >U : Symbol(U, Decl(specializationError.ts, 1, 9))
 >value : Symbol(value, Decl(specializationError.ts, 1, 12))
->T : Symbol(T, Decl(specializationError.ts, 0, 18))
+>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 18))
 }
 
 interface Bar {
@@ -16,21 +16,21 @@ interface Bar {
     bar(value: "Menu"): Promise<string>;
 >bar : Symbol(Bar.bar, Decl(specializationError.ts, 4, 15), Decl(specializationError.ts, 5, 40), Decl(specializationError.ts, 6, 55))
 >value : Symbol(value, Decl(specializationError.ts, 5, 8))
->Promise : Symbol(Promise, Decl(specializationError.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 0))
 
     bar<T>(value: string, element: string): Promise<T>;
 >bar : Symbol(Bar.bar, Decl(specializationError.ts, 4, 15), Decl(specializationError.ts, 5, 40), Decl(specializationError.ts, 6, 55))
 >T : Symbol(T, Decl(specializationError.ts, 6, 8))
 >value : Symbol(value, Decl(specializationError.ts, 6, 11))
 >element : Symbol(element, Decl(specializationError.ts, 6, 25))
->Promise : Symbol(Promise, Decl(specializationError.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 0))
 >T : Symbol(T, Decl(specializationError.ts, 6, 8))
 
     bar<T>(value: string): Promise<T>;
 >bar : Symbol(Bar.bar, Decl(specializationError.ts, 4, 15), Decl(specializationError.ts, 5, 40), Decl(specializationError.ts, 6, 55))
 >T : Symbol(T, Decl(specializationError.ts, 7, 8))
 >value : Symbol(value, Decl(specializationError.ts, 7, 11))
->Promise : Symbol(Promise, Decl(specializationError.ts, 0, 0))
+>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(specializationError.ts, 0, 0))
 >T : Symbol(T, Decl(specializationError.ts, 7, 8))
 }
 
diff --git a/tests/baselines/reference/specializationError.types b/tests/baselines/reference/specializationError.types
index c79816eaf8add..4260ca399befc 100644
--- a/tests/baselines/reference/specializationError.types
+++ b/tests/baselines/reference/specializationError.types
@@ -4,7 +4,7 @@ interface Promise<T> {
 >T : T
 
     then<U>(value: T): void;
->then : <U>(value: T) => void
+>then : { (onfulfilled?: (value: T) => T | PromiseLike<T>, onrejected?: (reason: any) => T | PromiseLike<T>): Promise<T>; <TResult>(onfulfilled: (value: T) => T | PromiseLike<T>, onrejected: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>; <TResult>(onfulfilled: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<TResult>; <TResult1, TResult2>(onfulfilled: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>; <U>(value: T): void; }
 >U : U
 >value : T
 >T : T
diff --git a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
index e966202c2777a..88f62aa6273cb 100644
--- a/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
+++ b/tests/baselines/reference/transformNestedGeneratorsWithTry.symbols
@@ -36,12 +36,12 @@ declare module "bluebird" {
     type Bluebird<T> = Promise<T>;
 >Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9))
 >T : Symbol(T, Decl(bluebird.d.ts, 1, 18))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >T : Symbol(T, Decl(bluebird.d.ts, 1, 18))
 
     const Bluebird: typeof Promise;
 >Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9))
->Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 
     export = Bluebird;
 >Bluebird : Symbol(Bluebird, Decl(bluebird.d.ts, 0, 27), Decl(bluebird.d.ts, 2, 9))
diff --git a/tests/cases/compiler/bluebirdStaticThis.ts b/tests/cases/compiler/bluebirdStaticThis.ts
index 55b1d0022d863..21b4d244decc6 100644
--- a/tests/cases/compiler/bluebirdStaticThis.ts
+++ b/tests/cases/compiler/bluebirdStaticThis.ts
@@ -2,7 +2,7 @@
 // and all the comments.
 // Then it adds explicit `this` arguments to the static members.
 // Tests by: Bart van der Schoor <https://github.com/Bartvds>
-declare class Promise<R> implements Promise.Thenable<R> {
+export declare class Promise<R> implements Promise.Thenable<R> {
 	constructor(callback: (resolve: (thenableOrResult: R | Promise.Thenable<R>) => void, reject: (error: any) => void) => void);
     static try<R>(dit: typeof Promise, fn: () => Promise.Thenable<R>, args?: any[], ctx?: any): Promise<R>;
     static try<R>(dit: typeof Promise, fn: () => R, args?: any[], ctx?: any): Promise<R>;
@@ -108,7 +108,7 @@ declare class Promise<R> implements Promise.Thenable<R> {
     static filter<R>(dit: typeof Promise, values: R[], filterer: (item: R, index: number, arrayLength: number) => boolean): Promise<R[]>;
 }
 
-declare module Promise {
+export declare module Promise {
 	export interface Thenable<R> {
 		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected: (error: any) => Thenable<U>): Thenable<U>;
 		then<U>(onFulfilled: (value: R) => Thenable<U>, onRejected?: (error: any) => U): Thenable<U>;
@@ -118,9 +118,6 @@ declare module Promise {
 
 }
 
-declare module 'bluebird' {
-	export = Promise;
-}
 interface Foo {
     a: number;
     b: string;
diff --git a/tests/cases/compiler/promiseIdentity.ts b/tests/cases/compiler/promiseIdentity.ts
index d568d75dfaaae..c9d7beabbdb5e 100644
--- a/tests/cases/compiler/promiseIdentity.ts
+++ b/tests/cases/compiler/promiseIdentity.ts
@@ -1,4 +1,4 @@
-interface IPromise<T> {
+export interface IPromise<T> {
     then<U>(callback: (x: T) => IPromise<U>): IPromise<U>;
 }
 interface Promise<T> {
diff --git a/tests/cases/compiler/promiseIdentity2.ts b/tests/cases/compiler/promiseIdentity2.ts
index b60cf92c12483..4454df6875bbf 100644
--- a/tests/cases/compiler/promiseIdentity2.ts
+++ b/tests/cases/compiler/promiseIdentity2.ts
@@ -1,7 +1,7 @@
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
     then<U, W>(callback: (x: T) => Promise<T, U>): Promise<T, W>;
 }
 
diff --git a/tests/cases/compiler/promiseIdentityWithAny.ts b/tests/cases/compiler/promiseIdentityWithAny.ts
index 7240eaca5467c..4cdc7c51b57cc 100644
--- a/tests/cases/compiler/promiseIdentityWithAny.ts
+++ b/tests/cases/compiler/promiseIdentityWithAny.ts
@@ -1,7 +1,7 @@
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
     then<U, W>(callback: (x: T) => Promise<any, any>): Promise<any, any>;
 }
 
diff --git a/tests/cases/compiler/promiseIdentityWithAny2.ts b/tests/cases/compiler/promiseIdentityWithAny2.ts
index 0572caeb7fd1c..e7a69077d033e 100644
--- a/tests/cases/compiler/promiseIdentityWithAny2.ts
+++ b/tests/cases/compiler/promiseIdentityWithAny2.ts
@@ -1,4 +1,4 @@
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U, W>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
 interface Promise<T, V> {
diff --git a/tests/cases/compiler/promiseIdentityWithConstraints.ts b/tests/cases/compiler/promiseIdentityWithConstraints.ts
index fc0368cbf7918..af94a6998bf98 100644
--- a/tests/cases/compiler/promiseIdentityWithConstraints.ts
+++ b/tests/cases/compiler/promiseIdentityWithConstraints.ts
@@ -1,7 +1,7 @@
-interface IPromise<T, V> {
+export interface IPromise<T, V> {
     then<U extends T, W extends V>(callback: (x: T) => IPromise<U, W>): IPromise<U, W>;
 }
-interface Promise<T, V> {
+export interface Promise<T, V> {
     then<U extends T, W extends V>(callback: (x: T) => Promise<U, W>): Promise<U, W>;
 }