Revert default behavior to allow custom Promise return types for async functions.

Author: rbuckton

src/compiler/checker.ts

@@ -12623,7 +12623,7 @@ namespace ts {
           * callable `then` signature.
           */
         function checkAsyncFunctionReturnType(node: FunctionLikeDeclaration): Type {
-            if (languageVersion >= ScriptTarget.ES6) {
+            if (compilerOptions.noCustomAsyncPromise && languageVersion >= ScriptTarget.ES6) {
                 const returnType = getTypeFromTypeNode(node.type);
                 return checkCorrectPromiseType(returnType, node.type);
             }
@@ -13029,6 +13029,10 @@ namespace ts {
         }
 
         function checkCollisionWithGlobalPromiseInGeneratedCode(node: Node, name: Identifier): void {
+            if (!compilerOptions.noCustomAsyncPromise) {
+                return;
+            }
+
             if (!needCollisionCheckForIdentifier(node, name, "Promise")) {
                 return;
             }

src/compiler/commandLineParser.ts

@@ -299,6 +299,11 @@ namespace ts {
             name: "noImplicitUseStrict",
             type: "boolean",
             description: Diagnostics.Do_not_emit_use_strict_directives_in_module_output
+        },
+        {
+            name: "noCustomAsyncPromise",
+            type: "boolean",
+            experimental: true
         }
     ];
 

src/compiler/emitter.ts

@@ -296,21 +296,21 @@ namespace ts {
      * If loop contains block scoped binding captured in some function then loop body is converted to a function.
      * Lexical bindings declared in loop initializer will be passed into the loop body function as parameters,
      * however if this binding is modified inside the body - this new value should be propagated back to the original binding.
-     * This is done by declaring new variable (out parameter holder) outside of the loop for every binding that is reassigned inside the body. 
+     * This is done by declaring new variable (out parameter holder) outside of the loop for every binding that is reassigned inside the body.
      * On every iteration this variable is initialized with value of corresponding binding.
      * At every point where control flow leaves the loop either explicitly (break/continue) or implicitly (at the end of loop body)
      * we copy the value inside the loop to the out parameter holder.
-     * 
+     *
      * for (let x;;) {
      *     let a = 1;
      *     let b = () => a;
      *     x++
      *     if (...) break;
      *     ...
      * }
-     * 
+     *
      * will be converted to
-     * 
+     *
      * var out_x;
      * var loop = function(x) {
      *     var a = 1;
@@ -326,7 +326,7 @@ namespace ts {
      *     x = out_x;
      *     if (state === "break") break;
      * }
-     * 
+     *
      * NOTE: values to out parameters are not copies if loop is abrupted with 'return' - in this case this will end the entire enclosing function
      * so nobody can observe this new value.
      */
@@ -3049,7 +3049,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                 }
 
                 writeLine();
-                // end of loop body -> copy out parameter 
+                // end of loop body -> copy out parameter
                 copyLoopOutParameters(convertedLoopState, CopyDirection.ToOutParameter, /*emitAsStatements*/true);
 
                 decreaseIndent();
@@ -4685,7 +4685,7 @@ const _super = (function (geti, seti) {
                     write(", void 0, ");
                 }
 
-                if (languageVersion >= ScriptTarget.ES6 || !promiseConstructor) {
+                if (!promiseConstructor || (compilerOptions.noCustomAsyncPromise && languageVersion >= ScriptTarget.ES6)) {
                     write("void 0");
                 }
                 else {
@@ -7245,7 +7245,7 @@ const _super = (function (geti, seti) {
                     }
 
                     // text should be quoted string
-                    // for deduplication purposes in key remove leading and trailing quotes so 'a' and "a" will be considered the same                     
+                    // for deduplication purposes in key remove leading and trailing quotes so 'a' and "a" will be considered the same
                     const key = text.substr(1, text.length - 2);
 
                     if (hasProperty(groupIndices, key)) {

src/compiler/types.ts

@@ -2442,6 +2442,8 @@ namespace ts {
         /* @internal */ skipDefaultLibCheck?: boolean;
         // Do not perform validation of output file name in transpile scenarios
         /* @internal */ suppressOutputPathCheck?: boolean;
+        // Disallow custom promise return types in async functions.
+        /* @internal */ noCustomAsyncPromise?: boolean;
 
         [option: string]: string | number | boolean;
     }

tests/baselines/reference/asyncAliasReturnType_es6.errors.txt

@@ -0,0 +1,10 @@
+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.
+    }

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, void 0, function* () {
+    return __awaiter(this, void 0, PromiseAlias, function* () {
     });
 }

tests/baselines/reference/asyncAliasReturnType_es6.symbols

@@ -4,5 +4,5 @@ var foo = async (): Promise<void> => {
 };
 
 //// [asyncArrowFunction1_es6.js]
-var foo = () => __awaiter(this, void 0, void 0, function* () {
+var foo = () => __awaiter(this, void 0, Promise, function* () {
 });

tests/baselines/reference/asyncAliasReturnType_es6.types

@@ -4,5 +4,5 @@ var foo = async (a = await): Promise<void> => {
 }
 
 //// [asyncArrowFunction6_es6.js]
-var foo = (a = yield ) => __awaiter(this, void 0, void 0, function* () {
+var foo = (a = yield ) => __awaiter(this, void 0, Promise, function* () {
 });