diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 92c40e32bacdf..5b5196e121059 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -2473,10 +2473,21 @@ namespace ts {
 
         function getDeclarationContainer(node: Node): Node {
             node = getRootDeclaration(node);
+            while (node) {
+                switch (node.kind) {
+                    case SyntaxKind.VariableDeclaration:
+                    case SyntaxKind.VariableDeclarationList:
+                    case SyntaxKind.ImportSpecifier:
+                    case SyntaxKind.NamedImports:
+                    case SyntaxKind.NamespaceImport:
+                    case SyntaxKind.ImportClause:
+                        node = node.parent;
+                        break;
 
-            // Parent chain:
-            // VaribleDeclaration -> VariableDeclarationList -> VariableStatement -> 'Declaration Container'
-            return node.kind === SyntaxKind.VariableDeclaration ? node.parent.parent.parent : node.parent;
+                    default:
+                        return node.parent;
+                }
+            }
         }
 
         function getTypeOfPrototypeProperty(prototype: Symbol): Type {
@@ -2618,7 +2629,7 @@ namespace ts {
                 }
             }
             else if (declaration.kind === SyntaxKind.Parameter) {
-                // If it's a parameter, see if the parent has a jsdoc comment with an @param 
+                // If it's a parameter, see if the parent has a jsdoc comment with an @param
                 // annotation.
                 const paramTag = getCorrespondingJSDocParameterTag(<ParameterDeclaration>declaration);
                 if (paramTag && paramTag.typeExpression) {
@@ -2633,7 +2644,7 @@ namespace ts {
         function getTypeForVariableLikeDeclaration(declaration: VariableLikeDeclaration): Type {
             if (declaration.parserContextFlags & ParserContextFlags.JavaScriptFile) {
                 // If this is a variable in a JavaScript file, then use the JSDoc type (if it has
-                // one as its type), otherwise fallback to the below standard TS codepaths to 
+                // one as its type), otherwise fallback to the below standard TS codepaths to
                 // try to figure it out.
                 const type = getTypeForVariableLikeDeclarationFromJSDocComment(declaration);
                 if (type && type !== unknownType) {
@@ -4058,7 +4069,7 @@ namespace ts {
                 const isJSConstructSignature = isJSDocConstructSignature(declaration);
                 let returnType: Type = undefined;
 
-                // If this is a JSDoc construct signature, then skip the first parameter in the 
+                // If this is a JSDoc construct signature, then skip the first parameter in the
                 // parameter list.  The first parameter represents the return type of the construct
                 // signature.
                 for (let i = isJSConstructSignature ? 1 : 0, n = declaration.parameters.length; i < n; i++) {
@@ -4461,7 +4472,7 @@ namespace ts {
             }
 
             if (symbol.flags & SymbolFlags.Value && node.kind === SyntaxKind.JSDocTypeReference) {
-                // A JSDocTypeReference may have resolved to a value (as opposed to a type). In 
+                // A JSDocTypeReference may have resolved to a value (as opposed to a type). In
                 // that case, the type of this reference is just the type of the value we resolved
                 // to.
                 return getTypeOfSymbol(symbol);
@@ -10468,7 +10479,7 @@ namespace ts {
 
         /*
          *TypeScript Specification 1.0 (6.3) - July 2014
-         * An explicitly typed function whose return type isn't the Void type, 
+         * An explicitly typed function whose return type isn't the Void type,
          * the Any type, or a union type containing the Void or Any type as a constituent
          * must have at least one return statement somewhere in its body.
          * An exception to this rule is if the function implementation consists of a single 'throw' statement.
@@ -11625,6 +11636,9 @@ namespace ts {
                             checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type);
                         }
                     }
+                    else if (isAsyncFunctionLike(node)) {
+                        checkAsyncFunctionReturnType(<FunctionLikeDeclaration>node);
+                    }
                 }
             }
 
@@ -12494,6 +12508,36 @@ namespace ts {
             }
         }
 
+        /**
+         * Checks that the return type provided is an instantiation of the global Promise<T> type
+         * and returns the awaited type of the return type.
+         *
+         * @param returnType The return type of a FunctionLikeDeclaration
+         * @param location The node on which to report the error.
+         */
+        function checkCorrectPromiseType(returnType: Type, location: Node) {
+            if (returnType === unknownType) {
+                // The return type already had some other error, so we ignore and return
+                // the unknown type.
+                return unknownType;
+            }
+
+            const globalPromiseType = getGlobalPromiseType();
+            if (globalPromiseType === emptyGenericType
+                || globalPromiseType === getTargetType(returnType)) {
+                // Either we couldn't resolve the global promise type, which would have already
+                // reported an error, or we could resolve it and the return type is a valid type
+                // reference to the global type. In either case, we return the awaited type for
+                // the return type.
+                return checkAwaitedType(returnType, location, Diagnostics.An_async_function_or_method_must_have_a_valid_awaitable_return_type);
+            }
+
+            // The promise type was not a valid type reference to the global promise type, so we
+            // report an error and return the unknown type.
+            error(location, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
+            return unknownType;
+        }
+
         /**
           * Checks the return type of an async function to ensure it is a compatible
           * Promise implementation.
@@ -12508,6 +12552,11 @@ namespace ts {
           * callable `then` signature.
           */
         function checkAsyncFunctionReturnType(node: FunctionLikeDeclaration): Type {
+            if (languageVersion >= ScriptTarget.ES6) {
+                const returnType = getTypeFromTypeNode(node.type);
+                return checkCorrectPromiseType(returnType, node.type);
+            }
+
             const globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType();
             if (globalPromiseConstructorLikeType === emptyObjectType) {
                 // If we couldn't resolve the global PromiseConstructorLike type we cannot verify
@@ -12723,6 +12772,7 @@ namespace ts {
                 checkCollisionWithCapturedSuperVariable(node, node.name);
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
             }
         }
 
@@ -12907,6 +12957,25 @@ namespace ts {
             }
         }
 
+        function checkCollisionWithGlobalPromiseInGeneratedCode(node: Node, name: Identifier): void {
+            if (!needCollisionCheckForIdentifier(node, name, "Promise")) {
+                return;
+            }
+
+            // Uninstantiated modules shouldnt do this check
+            if (node.kind === SyntaxKind.ModuleDeclaration && getModuleInstanceState(node) !== ModuleInstanceState.Instantiated) {
+                return;
+            }
+
+            // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent
+            const parent = getDeclarationContainer(node);
+            if (parent.kind === SyntaxKind.SourceFile && isExternalOrCommonJsModule(<SourceFile>parent) && parent.flags & NodeFlags.HasAsyncFunctions) {
+                // If the declaration happens to be in external module, report error that Promise is a reserved identifier.
+                error(name, Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions,
+                    declarationNameToString(name), declarationNameToString(name));
+            }
+        }
+
         function checkVarDeclaredNamesNotShadowed(node: VariableDeclaration | BindingElement) {
             // - ScriptBody : StatementList
             // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList
@@ -13085,6 +13154,7 @@ namespace ts {
                 checkCollisionWithCapturedSuperVariable(node, <Identifier>node.name);
                 checkCollisionWithCapturedThisVariable(node, <Identifier>node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, <Identifier>node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, <Identifier>node.name);
             }
         }
 
@@ -13850,6 +13920,7 @@ namespace ts {
                 checkTypeNameIsReserved(node.name, Diagnostics.Class_name_cannot_be_0);
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
             }
             checkTypeParameters(node.typeParameters);
             checkExportsOnMergedDeclarations(node);
@@ -14356,6 +14427,7 @@ namespace ts {
             checkTypeNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0);
             checkCollisionWithCapturedThisVariable(node, node.name);
             checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+            checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
             checkExportsOnMergedDeclarations(node);
 
             computeEnumMemberValues(node);
@@ -14460,6 +14532,7 @@ namespace ts {
 
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
                 checkExportsOnMergedDeclarations(node);
                 const symbol = getSymbolOfNode(node);
 
@@ -14652,6 +14725,7 @@ namespace ts {
         function checkImportBinding(node: ImportEqualsDeclaration | ImportClause | NamespaceImport | ImportSpecifier) {
             checkCollisionWithCapturedThisVariable(node, node.name);
             checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+            checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
             checkAliasSymbol(node);
         }
 
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 8fd40f7b42169..27ce11f5286f4 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -195,6 +195,10 @@
         "category": "Error",
         "code": 1063
     },
+    "The return type of an async function or method must be the global Promise<T> type.": {
+        "category": "Error",
+        "code": 1064
+    },
     "In ambient enum declarations member initializer must be constant expression.": {
         "category": "Error",
         "code": 1066
@@ -794,7 +798,7 @@
     "A decorator can only decorate a method implementation, not an overload.": {
         "category": "Error",
         "code": 1249
-    }, 
+    },
     "'with' statements are not allowed in an async function block.": {
         "category": "Error",
         "code": 1300
@@ -1687,6 +1691,10 @@
         "category": "Error",
         "code": 2528
     },
+    "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions.": {
+        "category": "Error",
+        "code": 2529
+    },
     "JSX element attributes type '{0}' may not be a union type.": {
         "category": "Error",
         "code": 2600
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index a3fb38d32c8a2..632f128fb27ac 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -320,7 +320,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 
         const awaiterHelper = `
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -4531,11 +4531,11 @@ const _super = (function (geti, seti) {
                     write(", void 0, ");
                 }
 
-                if (promiseConstructor) {
-                    emitEntityNameAsExpression(promiseConstructor, /*useFallback*/ false);
+                if (languageVersion >= ScriptTarget.ES6 || !promiseConstructor) {
+                    write("void 0");
                 }
                 else {
-                    write("Promise");
+                    emitEntityNameAsExpression(promiseConstructor, /*useFallback*/ false);
                 }
 
                 // Emit the call to __awaiter.
diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.errors.txt b/tests/baselines/reference/asyncAliasReturnType_es6.errors.txt
deleted file mode 100644
index ec532d1380d20..0000000000000
--- a/tests/baselines/reference/asyncAliasReturnType_es6.errors.txt
+++ /dev/null
@@ -1,10 +0,0 @@
-tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts(3,16): error TS1055: Type 'PromiseAlias' is not a valid async function return type.
-
-
-==== tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts (1 errors) ====
-    type PromiseAlias<T> = Promise<T>;
-    
-    async function f(): PromiseAlias<void> {
-                   ~
-!!! error TS1055: Type 'PromiseAlias' is not a valid async function return type.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.js b/tests/baselines/reference/asyncAliasReturnType_es6.js
index 0af63b0bfa604..45fe3228f6ebd 100644
--- a/tests/baselines/reference/asyncAliasReturnType_es6.js
+++ b/tests/baselines/reference/asyncAliasReturnType_es6.js
@@ -6,6 +6,6 @@ async function f(): PromiseAlias<void> {
 
 //// [asyncAliasReturnType_es6.js]
 function f() {
-    return __awaiter(this, void 0, PromiseAlias, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.symbols b/tests/baselines/reference/asyncAliasReturnType_es6.symbols
new file mode 100644
index 0000000000000..4d6db6a1ef4c4
--- /dev/null
+++ b/tests/baselines/reference/asyncAliasReturnType_es6.symbols
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts ===
+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.d.ts, --, --), Decl(lib.d.ts, --, --))
+>T : Symbol(T, Decl(asyncAliasReturnType_es6.ts, 0, 18))
+
+async function f(): PromiseAlias<void> {
+>f : Symbol(f, Decl(asyncAliasReturnType_es6.ts, 0, 34))
+>PromiseAlias : Symbol(PromiseAlias, Decl(asyncAliasReturnType_es6.ts, 0, 0))
+}
diff --git a/tests/baselines/reference/asyncAliasReturnType_es6.types b/tests/baselines/reference/asyncAliasReturnType_es6.types
new file mode 100644
index 0000000000000..8426d2a3542f4
--- /dev/null
+++ b/tests/baselines/reference/asyncAliasReturnType_es6.types
@@ -0,0 +1,11 @@
+=== tests/cases/conformance/async/es6/asyncAliasReturnType_es6.ts ===
+type PromiseAlias<T> = Promise<T>;
+>PromiseAlias : Promise<T>
+>T : T
+>Promise : Promise<T>
+>T : T
+
+async function f(): PromiseAlias<void> {
+>f : () => Promise<void>
+>PromiseAlias : Promise<T>
+}
diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.js b/tests/baselines/reference/asyncArrowFunction1_es6.js
index 4f03acc5ced43..0026cd91a7ef9 100644
--- a/tests/baselines/reference/asyncArrowFunction1_es6.js
+++ b/tests/baselines/reference/asyncArrowFunction1_es6.js
@@ -4,5 +4,5 @@ var foo = async (): Promise<void> => {
 };
 
 //// [asyncArrowFunction1_es6.js]
-var foo = () => __awaiter(this, void 0, Promise, function* () {
+var foo = () => __awaiter(this, void 0, void 0, function* () {
 });
diff --git a/tests/baselines/reference/asyncArrowFunction6_es6.js b/tests/baselines/reference/asyncArrowFunction6_es6.js
index 54b8aa1f6b154..a01e53f5b114f 100644
--- a/tests/baselines/reference/asyncArrowFunction6_es6.js
+++ b/tests/baselines/reference/asyncArrowFunction6_es6.js
@@ -4,5 +4,5 @@ var foo = async (a = await): Promise<void> => {
 }
 
 //// [asyncArrowFunction6_es6.js]
-var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () {
+var foo = (a = yield ) => __awaiter(this, void 0, void 0, function* () {
 });
diff --git a/tests/baselines/reference/asyncArrowFunction7_es6.js b/tests/baselines/reference/asyncArrowFunction7_es6.js
index ac68a8fd2f865..fab705c0b76e2 100644
--- a/tests/baselines/reference/asyncArrowFunction7_es6.js
+++ b/tests/baselines/reference/asyncArrowFunction7_es6.js
@@ -7,8 +7,8 @@ var bar = async (): Promise<void> => {
 }
 
 //// [asyncArrowFunction7_es6.js]
-var bar = () => __awaiter(this, void 0, Promise, function* () {
+var bar = () => __awaiter(this, void 0, void 0, function* () {
     // 'await' here is an identifier, and not an await expression.
-    var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () {
+    var foo = (a = yield ) => __awaiter(this, void 0, void 0, function* () {
     });
 });
diff --git a/tests/baselines/reference/asyncArrowFunction8_es6.js b/tests/baselines/reference/asyncArrowFunction8_es6.js
index 9cee5ee1525d7..0c33cfcfa2de0 100644
--- a/tests/baselines/reference/asyncArrowFunction8_es6.js
+++ b/tests/baselines/reference/asyncArrowFunction8_es6.js
@@ -5,6 +5,6 @@ var foo = async (): Promise<void> => {
 }
 
 //// [asyncArrowFunction8_es6.js]
-var foo = () => __awaiter(this, void 0, Promise, function* () {
+var foo = () => __awaiter(this, void 0, void 0, function* () {
     var v = { [yield ]: foo };
 });
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js
index fdaa365836ddb..ca79eed6c8eb0 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.js
@@ -11,6 +11,6 @@ class C {
 class C {
     method() {
         function other() { }
-        var fn = () => __awaiter(this, arguments, Promise, function* () { return yield other.apply(this, arguments); });
+        var fn = () => __awaiter(this, arguments, void 0, function* () { return yield other.apply(this, arguments); });
     }
 }
diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js
index 0f09e366ef3dc..de7eb23ed7811 100644
--- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js
+++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.js
@@ -9,6 +9,6 @@ class C {
 //// [asyncArrowFunctionCapturesThis_es6.js]
 class C {
     method() {
-        var fn = () => __awaiter(this, void 0, Promise, function* () { return yield this; });
+        var fn = () => __awaiter(this, void 0, void 0, function* () { return yield this; });
     }
 }
diff --git a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js
index 213ecfd53a6b7..4022fde7f54e8 100644
--- a/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js
+++ b/tests/baselines/reference/asyncAwaitIsolatedModules_es6.js
@@ -41,7 +41,7 @@ module M {
 
 //// [asyncAwaitIsolatedModules_es6.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -49,65 +49,65 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 function f0() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 function f1() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 function f3() {
-    return __awaiter(this, void 0, MyPromise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 let f4 = function () {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 };
 let f5 = function () {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 };
 let f6 = function () {
-    return __awaiter(this, void 0, MyPromise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 };
-let f7 = () => __awaiter(this, void 0, Promise, function* () { });
-let f8 = () => __awaiter(this, void 0, Promise, function* () { });
-let f9 = () => __awaiter(this, void 0, MyPromise, function* () { });
-let f10 = () => __awaiter(this, void 0, Promise, function* () { return p; });
-let f11 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f12 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f13 = () => __awaiter(this, void 0, MyPromise, function* () { return p; });
+let f7 = () => __awaiter(this, void 0, void 0, function* () { });
+let f8 = () => __awaiter(this, void 0, void 0, function* () { });
+let f9 = () => __awaiter(this, void 0, void 0, function* () { });
+let f10 = () => __awaiter(this, void 0, void 0, function* () { return p; });
+let f11 = () => __awaiter(this, void 0, void 0, function* () { return mp; });
+let f12 = () => __awaiter(this, void 0, void 0, function* () { return mp; });
+let f13 = () => __awaiter(this, void 0, void 0, function* () { return p; });
 let o = {
     m1() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     },
     m2() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     },
     m3() {
-        return __awaiter(this, void 0, MyPromise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
 };
 class C {
     m1() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     m2() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     m3() {
-        return __awaiter(this, void 0, MyPromise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     static m4() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     static m5() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     static m6() {
-        return __awaiter(this, void 0, MyPromise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
 }
 var M;
 (function (M) {
     function f1() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     M.f1 = f1;
 })(M || (M = {}));
diff --git a/tests/baselines/reference/asyncAwait_es6.js b/tests/baselines/reference/asyncAwait_es6.js
index 14dfc7fc9aa84..be2eb90e3e4fb 100644
--- a/tests/baselines/reference/asyncAwait_es6.js
+++ b/tests/baselines/reference/asyncAwait_es6.js
@@ -41,7 +41,7 @@ module M {
 
 //// [asyncAwait_es6.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -49,65 +49,65 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 function f0() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 function f1() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 function f3() {
-    return __awaiter(this, void 0, MyPromise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 let f4 = function () {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 };
 let f5 = function () {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 };
 let f6 = function () {
-    return __awaiter(this, void 0, MyPromise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 };
-let f7 = () => __awaiter(this, void 0, Promise, function* () { });
-let f8 = () => __awaiter(this, void 0, Promise, function* () { });
-let f9 = () => __awaiter(this, void 0, MyPromise, function* () { });
-let f10 = () => __awaiter(this, void 0, Promise, function* () { return p; });
-let f11 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f12 = () => __awaiter(this, void 0, Promise, function* () { return mp; });
-let f13 = () => __awaiter(this, void 0, MyPromise, function* () { return p; });
+let f7 = () => __awaiter(this, void 0, void 0, function* () { });
+let f8 = () => __awaiter(this, void 0, void 0, function* () { });
+let f9 = () => __awaiter(this, void 0, void 0, function* () { });
+let f10 = () => __awaiter(this, void 0, void 0, function* () { return p; });
+let f11 = () => __awaiter(this, void 0, void 0, function* () { return mp; });
+let f12 = () => __awaiter(this, void 0, void 0, function* () { return mp; });
+let f13 = () => __awaiter(this, void 0, void 0, function* () { return p; });
 let o = {
     m1() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     },
     m2() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     },
     m3() {
-        return __awaiter(this, void 0, MyPromise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
 };
 class C {
     m1() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     m2() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     m3() {
-        return __awaiter(this, void 0, MyPromise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     static m4() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     static m5() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     static m6() {
-        return __awaiter(this, void 0, MyPromise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
 }
 var M;
 (function (M) {
     function f1() {
-        return __awaiter(this, void 0, Promise, function* () { });
+        return __awaiter(this, void 0, void 0, function* () { });
     }
     M.f1 = f1;
 })(M || (M = {}));
diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js
index a44343cef7822..6fe8921434c84 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.js
@@ -4,6 +4,6 @@ async function await(): Promise<void> {
 
 //// [asyncFunctionDeclaration11_es6.js]
 function await() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js
index 4257c8691c25b..6fab6c39947d3 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration13_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration13_es6.js
@@ -7,7 +7,7 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration13_es6.js]
 function foo() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         // Legal to use 'await' in a type context.
         var v;
     });
diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js
index f32d106f92e37..f584f9178426f 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.js
@@ -5,7 +5,7 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration14_es6.js]
 function foo() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         return;
     });
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
index bc1ef24127a45..7b682f9dcdefe 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
@@ -1,12 +1,8 @@
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,16): error TS1055: Type '{}' is not a valid async function return type.
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(7,16): error TS1055: Type 'any' is not a valid async function return type.
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,16): error TS1055: Type 'number' is not a valid async function return type.
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,16): error TS1055: Type 'PromiseLike' is not a valid async function return type.
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,16): error TS1055: Type 'typeof Thenable' is not a valid async function return type.
-  Type 'Thenable' is not assignable to type 'PromiseLike<any>'.
-    Types of property 'then' are incompatible.
-      Type '() => void' is not assignable to type '{ <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>; <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>; }'.
-        Type 'void' is not assignable to type 'PromiseLike<any>'.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,23): error TS1064: The return type of an async function or method must be the global Promise<T>.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(7,23): error TS1064: The return type of an async function or method must be the global Promise<T>.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,23): error TS1064: The return type of an async function or method must be the global Promise<T>.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,23): error TS1064: The return type of an async function or method must be the global Promise<T>.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,23): error TS1064: The return type of an async function or method must be the global Promise<T>.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(17,16): error TS1059: Return expression in async function does not have a valid callable 'then' member.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(23,25): error TS1058: Operand for 'await' does not have a valid callable 'then' member.
 
@@ -18,24 +14,20 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1
     declare let thenable: Thenable;
     async function fn1() { } // valid: Promise<void>
     async function fn2(): { } { } // error
-                   ~~~
-!!! error TS1055: Type '{}' is not a valid async function return type.
+                          ~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
     async function fn3(): any { } // error
-                   ~~~
-!!! error TS1055: Type 'any' is not a valid async function return type.
+                          ~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
     async function fn4(): number { } // error
-                   ~~~
-!!! error TS1055: Type 'number' is not a valid async function return type.
+                          ~~~~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
     async function fn5(): PromiseLike<void> { } // error
-                   ~~~
-!!! error TS1055: Type 'PromiseLike' is not a valid async function return type.
+                          ~~~~~~~~~~~~~~~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
     async function fn6(): Thenable { } // error
-                   ~~~
-!!! error TS1055: Type 'typeof Thenable' is not a valid async function return type.
-!!! error TS1055:   Type 'Thenable' is not assignable to type 'PromiseLike<any>'.
-!!! error TS1055:     Types of property 'then' are incompatible.
-!!! error TS1055:       Type '() => void' is not assignable to type '{ <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => TResult | PromiseLike<TResult>): PromiseLike<TResult>; <TResult>(onfulfilled?: (value: any) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>; }'.
-!!! error TS1055:         Type 'void' is not assignable to type 'PromiseLike<any>'.
+                          ~~~~~~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
     async function fn7() { return; } // valid: Promise<void>
     async function fn8() { return 1; } // valid: Promise<number>
     async function fn9() { return null; } // valid: Promise<any>
diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.js b/tests/baselines/reference/asyncFunctionDeclaration15_es6.js
index c72062e24b23a..174a95d6f669f 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration15_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.js
@@ -26,59 +26,59 @@ async function fn19() { await thenable; } // error
 
 //// [asyncFunctionDeclaration15_es6.js]
 function fn1() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 } // valid: Promise<void>
 function fn2() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 } // error
 function fn3() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 } // error
 function fn4() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 } // error
 function fn5() {
-    return __awaiter(this, void 0, PromiseLike, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 } // error
 function fn6() {
-    return __awaiter(this, void 0, Thenable, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 } // error
 function fn7() {
-    return __awaiter(this, void 0, Promise, function* () { return; });
+    return __awaiter(this, void 0, void 0, function* () { return; });
 } // valid: Promise<void>
 function fn8() {
-    return __awaiter(this, void 0, Promise, function* () { return 1; });
+    return __awaiter(this, void 0, void 0, function* () { return 1; });
 } // valid: Promise<number>
 function fn9() {
-    return __awaiter(this, void 0, Promise, function* () { return null; });
+    return __awaiter(this, void 0, void 0, function* () { return null; });
 } // valid: Promise<any>
 function fn10() {
-    return __awaiter(this, void 0, Promise, function* () { return undefined; });
+    return __awaiter(this, void 0, void 0, function* () { return undefined; });
 } // valid: Promise<any>
 function fn11() {
-    return __awaiter(this, void 0, Promise, function* () { return a; });
+    return __awaiter(this, void 0, void 0, function* () { return a; });
 } // valid: Promise<any>
 function fn12() {
-    return __awaiter(this, void 0, Promise, function* () { return obj; });
+    return __awaiter(this, void 0, void 0, function* () { return obj; });
 } // valid: Promise<{ then: string; }>
 function fn13() {
-    return __awaiter(this, void 0, Promise, function* () { return thenable; });
+    return __awaiter(this, void 0, void 0, function* () { return thenable; });
 } // error
 function fn14() {
-    return __awaiter(this, void 0, Promise, function* () { yield 1; });
+    return __awaiter(this, void 0, void 0, function* () { yield 1; });
 } // valid: Promise<void>
 function fn15() {
-    return __awaiter(this, void 0, Promise, function* () { yield null; });
+    return __awaiter(this, void 0, void 0, function* () { yield null; });
 } // valid: Promise<void>
 function fn16() {
-    return __awaiter(this, void 0, Promise, function* () { yield undefined; });
+    return __awaiter(this, void 0, void 0, function* () { yield undefined; });
 } // valid: Promise<void>
 function fn17() {
-    return __awaiter(this, void 0, Promise, function* () { yield a; });
+    return __awaiter(this, void 0, void 0, function* () { yield a; });
 } // valid: Promise<void>
 function fn18() {
-    return __awaiter(this, void 0, Promise, function* () { yield obj; });
+    return __awaiter(this, void 0, void 0, function* () { yield obj; });
 } // valid: Promise<void>
 function fn19() {
-    return __awaiter(this, void 0, Promise, function* () { yield thenable; });
+    return __awaiter(this, void 0, void 0, function* () { yield thenable; });
 } // error
diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js
index 263e27fa35efa..e92d55dc0e2ce 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.js
@@ -4,6 +4,6 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration1_es6.js]
 function foo() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js
index 8c37968ab4c22..a70316989b380 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration6_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration6_es6.js
@@ -4,6 +4,6 @@ async function foo(a = await): Promise<void> {
 
 //// [asyncFunctionDeclaration6_es6.js]
 function foo(a = yield ) {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
diff --git a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js
index ef66df4e4133a..0d360fa866ccb 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration7_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration7_es6.js
@@ -7,10 +7,10 @@ async function bar(): Promise<void> {
 
 //// [asyncFunctionDeclaration7_es6.js]
 function bar() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         // 'await' here is an identifier, and not a yield expression.
         function foo(a = yield ) {
-            return __awaiter(this, void 0, Promise, function* () {
+            return __awaiter(this, void 0, void 0, function* () {
             });
         }
     });
diff --git a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js
index 9723a69f2a23b..c57c0eb395a72 100644
--- a/tests/baselines/reference/asyncFunctionDeclaration9_es6.js
+++ b/tests/baselines/reference/asyncFunctionDeclaration9_es6.js
@@ -5,7 +5,7 @@ async function foo(): Promise<void> {
 
 //// [asyncFunctionDeclaration9_es6.js]
 function foo() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         var v = { [yield ]: foo };
     });
 }
diff --git a/tests/baselines/reference/asyncFunctionsAcrossFiles.js b/tests/baselines/reference/asyncFunctionsAcrossFiles.js
index 7e8a58205e29c..94ccff2358c28 100644
--- a/tests/baselines/reference/asyncFunctionsAcrossFiles.js
+++ b/tests/baselines/reference/asyncFunctionsAcrossFiles.js
@@ -17,7 +17,7 @@ export const b = {
 
 //// [b.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -26,13 +26,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { a } from './a';
 export const b = {
-    f: () => __awaiter(this, void 0, Promise, function* () {
+    f: () => __awaiter(this, void 0, void 0, function* () {
         yield a.f();
     })
 };
 //// [a.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -41,7 +41,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { b } from './b';
 export const a = {
-    f: () => __awaiter(this, void 0, Promise, function* () {
+    f: () => __awaiter(this, void 0, void 0, function* () {
         yield b.f();
     })
 };
diff --git a/tests/baselines/reference/asyncImportedPromise_es6.errors.txt b/tests/baselines/reference/asyncImportedPromise_es6.errors.txt
new file mode 100644
index 0000000000000..994445dbedd5d
--- /dev/null
+++ b/tests/baselines/reference/asyncImportedPromise_es6.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/async/es6/test.ts(3,25): error TS1064: The return type of an async function or method must be the global Promise<T>.
+
+
+==== tests/cases/conformance/async/es6/task.ts (0 errors) ====
+    export class Task<T> extends Promise<T> { }
+    
+==== tests/cases/conformance/async/es6/test.ts (1 errors) ====
+    import { Task } from "./task";
+    class Test {
+        async example<T>(): Task<T> { return; }
+                            ~~~~~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncImportedPromise_es6.js b/tests/baselines/reference/asyncImportedPromise_es6.js
index dfff0b7bd3e8e..56a41b0283f5b 100644
--- a/tests/baselines/reference/asyncImportedPromise_es6.js
+++ b/tests/baselines/reference/asyncImportedPromise_es6.js
@@ -17,16 +17,15 @@ exports.Task = Task;
 //// [test.js]
 "use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
         step((generator = generator.apply(thisArg, _arguments)).next());
     });
 };
-const task_1 = require("./task");
 class Test {
     example() {
-        return __awaiter(this, void 0, task_1.Task, function* () { return; });
+        return __awaiter(this, void 0, void 0, function* () { return; });
     }
 }
diff --git a/tests/baselines/reference/asyncImportedPromise_es6.symbols b/tests/baselines/reference/asyncImportedPromise_es6.symbols
deleted file mode 100644
index 45cf47d2b45b2..0000000000000
--- a/tests/baselines/reference/asyncImportedPromise_es6.symbols
+++ /dev/null
@@ -1,20 +0,0 @@
-=== tests/cases/conformance/async/es6/task.ts ===
-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.d.ts, --, --), Decl(lib.d.ts, --, --))
->T : Symbol(T, Decl(task.ts, 0, 18))
-
-=== tests/cases/conformance/async/es6/test.ts ===
-import { Task } from "./task";
->Task : Symbol(Task, Decl(test.ts, 0, 8))
-
-class Test {
->Test : Symbol(Test, Decl(test.ts, 0, 30))
-
-    async example<T>(): Task<T> { return; }
->example : Symbol(example, Decl(test.ts, 1, 12))
->T : Symbol(T, Decl(test.ts, 2, 18))
->Task : Symbol(Task, Decl(test.ts, 0, 8))
->T : Symbol(T, Decl(test.ts, 2, 18))
-}
diff --git a/tests/baselines/reference/asyncImportedPromise_es6.types b/tests/baselines/reference/asyncImportedPromise_es6.types
deleted file mode 100644
index 424f14b34d37f..0000000000000
--- a/tests/baselines/reference/asyncImportedPromise_es6.types
+++ /dev/null
@@ -1,20 +0,0 @@
-=== tests/cases/conformance/async/es6/task.ts ===
-export class Task<T> extends Promise<T> { }
->Task : Task<T>
->T : T
->Promise : Promise<T>
->T : T
-
-=== tests/cases/conformance/async/es6/test.ts ===
-import { Task } from "./task";
->Task : typeof Task
-
-class Test {
->Test : Test
-
-    async example<T>(): Task<T> { return; }
->example : <T>() => Task<T>
->T : T
->Task : Task<T>
->T : T
-}
diff --git a/tests/baselines/reference/asyncMethodWithSuper_es6.js b/tests/baselines/reference/asyncMethodWithSuper_es6.js
index 74d4de7988111..eacb0a882b2f7 100644
--- a/tests/baselines/reference/asyncMethodWithSuper_es6.js
+++ b/tests/baselines/reference/asyncMethodWithSuper_es6.js
@@ -59,7 +59,7 @@ class B extends A {
     // async method with only call/get on 'super' does not require a binding
     simple() {
         const _super = name => super[name];
-        return __awaiter(this, void 0, Promise, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             // call with property access
             _super("x").call(this);
             // call with element access
@@ -76,7 +76,7 @@ class B extends A {
             const cache = Object.create(null);
             return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });
         })(name => super[name], (name, value) => super[name] = value);
-        return __awaiter(this, void 0, Promise, function* () {
+        return __awaiter(this, void 0, void 0, function* () {
             const f = () => { };
             // call with property access
             _super("x").value.call(this);
diff --git a/tests/baselines/reference/asyncMultiFile.js b/tests/baselines/reference/asyncMultiFile.js
index 6229c29f02c2a..cbf3445ecc992 100644
--- a/tests/baselines/reference/asyncMultiFile.js
+++ b/tests/baselines/reference/asyncMultiFile.js
@@ -7,7 +7,7 @@ function g() { }
 
 //// [a.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 function f() {
-    return __awaiter(this, void 0, Promise, function* () { });
+    return __awaiter(this, void 0, void 0, function* () { });
 }
 //// [b.js]
 function g() { }
diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.errors.txt b/tests/baselines/reference/asyncQualifiedReturnType_es6.errors.txt
new file mode 100644
index 0000000000000..f1d01bb2a7aee
--- /dev/null
+++ b/tests/baselines/reference/asyncQualifiedReturnType_es6.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/async/es6/asyncQualifiedReturnType_es6.ts(6,21): error TS1064: The return type of an async function or method must be the global Promise<T>.
+
+
+==== tests/cases/conformance/async/es6/asyncQualifiedReturnType_es6.ts (1 errors) ====
+    namespace X {
+        export class MyPromise<T> extends Promise<T> {
+        }
+    }
+    
+    async function f(): X.MyPromise<void> {
+                        ~~~~~~~~~~~~~~~~~
+!!! error TS1064: The return type of an async function or method must be the global Promise<T>.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.js b/tests/baselines/reference/asyncQualifiedReturnType_es6.js
index 1da37946254f6..4d5aa87bbffb4 100644
--- a/tests/baselines/reference/asyncQualifiedReturnType_es6.js
+++ b/tests/baselines/reference/asyncQualifiedReturnType_es6.js
@@ -15,6 +15,6 @@ var X;
     X.MyPromise = MyPromise;
 })(X || (X = {}));
 function f() {
-    return __awaiter(this, void 0, X.MyPromise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols b/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols
deleted file mode 100644
index 5d27d04ea3bdc..0000000000000
--- a/tests/baselines/reference/asyncQualifiedReturnType_es6.symbols
+++ /dev/null
@@ -1,17 +0,0 @@
-=== tests/cases/conformance/async/es6/asyncQualifiedReturnType_es6.ts ===
-namespace X {
->X : Symbol(X, Decl(asyncQualifiedReturnType_es6.ts, 0, 0))
-
-    export class MyPromise<T> extends Promise<T> {
->MyPromise : Symbol(MyPromise, Decl(asyncQualifiedReturnType_es6.ts, 0, 13))
->T : Symbol(T, Decl(asyncQualifiedReturnType_es6.ts, 1, 27))
->Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
->T : Symbol(T, Decl(asyncQualifiedReturnType_es6.ts, 1, 27))
-    }
-}
-
-async function f(): X.MyPromise<void> {
->f : Symbol(f, Decl(asyncQualifiedReturnType_es6.ts, 3, 1))
->X : Symbol(X, Decl(asyncQualifiedReturnType_es6.ts, 0, 0))
->MyPromise : Symbol(X.MyPromise, Decl(asyncQualifiedReturnType_es6.ts, 0, 13))
-}
diff --git a/tests/baselines/reference/asyncQualifiedReturnType_es6.types b/tests/baselines/reference/asyncQualifiedReturnType_es6.types
deleted file mode 100644
index 3b438eb93b68a..0000000000000
--- a/tests/baselines/reference/asyncQualifiedReturnType_es6.types
+++ /dev/null
@@ -1,17 +0,0 @@
-=== tests/cases/conformance/async/es6/asyncQualifiedReturnType_es6.ts ===
-namespace X {
->X : typeof X
-
-    export class MyPromise<T> extends Promise<T> {
->MyPromise : MyPromise<T>
->T : T
->Promise : Promise<T>
->T : T
-    }
-}
-
-async function f(): X.MyPromise<void> {
->f : () => X.MyPromise<void>
->X : any
->MyPromise : X.MyPromise<T>
-}
diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.js b/tests/baselines/reference/awaitBinaryExpression1_es6.js
index 8deb771f5abf2..a19e94353d595 100644
--- a/tests/baselines/reference/awaitBinaryExpression1_es6.js
+++ b/tests/baselines/reference/awaitBinaryExpression1_es6.js
@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression1_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = (yield p) || a;
         "after";
diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.js b/tests/baselines/reference/awaitBinaryExpression2_es6.js
index 506af50a0efba..7fb1a70446b26 100644
--- a/tests/baselines/reference/awaitBinaryExpression2_es6.js
+++ b/tests/baselines/reference/awaitBinaryExpression2_es6.js
@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression2_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = (yield p) && a;
         "after";
diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.js b/tests/baselines/reference/awaitBinaryExpression3_es6.js
index 4b298d7b94751..f845ce1242148 100644
--- a/tests/baselines/reference/awaitBinaryExpression3_es6.js
+++ b/tests/baselines/reference/awaitBinaryExpression3_es6.js
@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression3_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = (yield p) + a;
         "after";
diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.js b/tests/baselines/reference/awaitBinaryExpression4_es6.js
index 4d31358898442..b6e14c8248761 100644
--- a/tests/baselines/reference/awaitBinaryExpression4_es6.js
+++ b/tests/baselines/reference/awaitBinaryExpression4_es6.js
@@ -9,7 +9,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression4_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = yield p, a;
         "after";
diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.js b/tests/baselines/reference/awaitBinaryExpression5_es6.js
index 01d6c50f6f03e..65a5bbfee777f 100644
--- a/tests/baselines/reference/awaitBinaryExpression5_es6.js
+++ b/tests/baselines/reference/awaitBinaryExpression5_es6.js
@@ -10,7 +10,7 @@ async function func(): Promise<void> {
 
 //// [awaitBinaryExpression5_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var o;
         o.a = yield p;
diff --git a/tests/baselines/reference/awaitCallExpression1_es6.js b/tests/baselines/reference/awaitCallExpression1_es6.js
index f9dad87a8b6b3..aeeb598e3bf18 100644
--- a/tests/baselines/reference/awaitCallExpression1_es6.js
+++ b/tests/baselines/reference/awaitCallExpression1_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression1_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = fn(a, a, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression2_es6.js b/tests/baselines/reference/awaitCallExpression2_es6.js
index 87d99cd079399..b41735275a842 100644
--- a/tests/baselines/reference/awaitCallExpression2_es6.js
+++ b/tests/baselines/reference/awaitCallExpression2_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression2_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = fn(yield p, a, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression3_es6.js b/tests/baselines/reference/awaitCallExpression3_es6.js
index f397d83c3a14e..74dee3e7e427c 100644
--- a/tests/baselines/reference/awaitCallExpression3_es6.js
+++ b/tests/baselines/reference/awaitCallExpression3_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression3_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = fn(a, yield p, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression4_es6.js b/tests/baselines/reference/awaitCallExpression4_es6.js
index d8824d7e7a007..682a1776ac53c 100644
--- a/tests/baselines/reference/awaitCallExpression4_es6.js
+++ b/tests/baselines/reference/awaitCallExpression4_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression4_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = (yield pfn)(a, a, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression5_es6.js b/tests/baselines/reference/awaitCallExpression5_es6.js
index f39a633765d88..30889b350115f 100644
--- a/tests/baselines/reference/awaitCallExpression5_es6.js
+++ b/tests/baselines/reference/awaitCallExpression5_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression5_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = o.fn(a, a, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression6_es6.js b/tests/baselines/reference/awaitCallExpression6_es6.js
index de8477fa9388a..55d86119d6495 100644
--- a/tests/baselines/reference/awaitCallExpression6_es6.js
+++ b/tests/baselines/reference/awaitCallExpression6_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression6_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = o.fn(yield p, a, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression7_es6.js b/tests/baselines/reference/awaitCallExpression7_es6.js
index 24edc3b9393e6..df805266ff3a2 100644
--- a/tests/baselines/reference/awaitCallExpression7_es6.js
+++ b/tests/baselines/reference/awaitCallExpression7_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression7_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = o.fn(a, yield p, a);
         "after";
diff --git a/tests/baselines/reference/awaitCallExpression8_es6.js b/tests/baselines/reference/awaitCallExpression8_es6.js
index 8bee6112a7a39..8d7bb4b83ce96 100644
--- a/tests/baselines/reference/awaitCallExpression8_es6.js
+++ b/tests/baselines/reference/awaitCallExpression8_es6.js
@@ -13,7 +13,7 @@ async function func(): Promise<void> {
 
 //// [awaitCallExpression8_es6.js]
 function func() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         "before";
         var b = (yield po).fn(a, a, a);
         "after";
diff --git a/tests/baselines/reference/awaitUnion_es6.js b/tests/baselines/reference/awaitUnion_es6.js
index 80c68f811ef95..9603454b969aa 100644
--- a/tests/baselines/reference/awaitUnion_es6.js
+++ b/tests/baselines/reference/awaitUnion_es6.js
@@ -14,7 +14,7 @@ async function f() {
 
 //// [awaitUnion_es6.js]
 function f() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         let await_a = yield a;
         let await_b = yield b;
         let await_c = yield c;
diff --git a/tests/baselines/reference/reachabilityChecks7.js b/tests/baselines/reference/reachabilityChecks7.js
index 7533874270039..0a6b5b0dac7b5 100644
--- a/tests/baselines/reference/reachabilityChecks7.js
+++ b/tests/baselines/reference/reachabilityChecks7.js
@@ -32,7 +32,7 @@ let x1 = () => { use("Test"); }
 
 //// [reachabilityChecks7.js]
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new P(function (resolve, reject) {
+    return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator.throw(value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
@@ -41,26 +41,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 // async function without return type annotation - error
 function f1() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
 let x = function () {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 };
 // async function with which promised type is void - return can be omitted
 function f2() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
 function f3(x) {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
         if (x)
             return 10;
     });
 }
 function f4() {
-    return __awaiter(this, void 0, Promise, function* () {
+    return __awaiter(this, void 0, void 0, function* () {
     });
 }
 function voidFunc() {