Error for Promise redeclaration in module with async

Author: rbuckton

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 {
@@ -11625,6 +11636,9 @@ namespace ts {
                             checkTypeAssignableTo(iterableIteratorInstantiation, returnType, node.type);
                         }
                     }
+                    else if (isAsyncFunctionLike(node)) {
+                        checkAsyncFunctionReturnType(<FunctionLikeDeclaration>node);
+                    }
                 }
             }
 
@@ -12549,6 +12563,21 @@ namespace ts {
                 return unknownType;
             }
 
+            if (languageVersion >= ScriptTarget.ES6) {
+                const promisedType = getPromisedType(promiseType);
+                if (!promisedType) {
+                    error(node, Diagnostics.Type_0_is_not_a_valid_async_function_return_type, typeToString(promiseType));
+                    return unknownType;
+                }
+
+                const promiseInstantiation = createPromiseType(promisedType);
+                if (!checkTypeAssignableTo(promiseInstantiation, promiseType, node.type, Diagnostics.Type_0_is_not_a_valid_async_function_return_type)) {
+                    return unknownType;
+                }
+
+                return promisedType;
+            }
+
             const promiseConstructor = getNodeLinks(node.type).resolvedSymbol;
             if (!promiseConstructor || !symbolIsValue(promiseConstructor)) {
                 const typeName = promiseConstructor
@@ -12723,6 +12752,7 @@ namespace ts {
                 checkCollisionWithCapturedSuperVariable(node, node.name);
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
             }
         }
 
@@ -12907,6 +12937,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 require and exports are reserved keywords
+                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 +13134,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 +13900,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 +14407,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 +14512,7 @@ namespace ts {
 
                 checkCollisionWithCapturedThisVariable(node, node.name);
                 checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+                checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
                 checkExportsOnMergedDeclarations(node);
                 const symbol = getSymbolOfNode(node);
 
@@ -14652,6 +14705,7 @@ namespace ts {
         function checkImportBinding(node: ImportEqualsDeclaration | ImportClause | NamespaceImport | ImportSpecifier) {
             checkCollisionWithCapturedThisVariable(node, node.name);
             checkCollisionWithRequireExportsInGeneratedCode(node, node.name);
+            checkCollisionWithGlobalPromiseInGeneratedCode(node, node.name);
             checkAliasSymbol(node);
         }
 

src/compiler/diagnosticMessages.json

@@ -794,7 +794,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 +1687,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

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); }
@@ -4535,11 +4535,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.

tests/baselines/reference/asyncAliasReturnType_es6.errors.txt

@@ -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* () {
     });
 }

tests/baselines/reference/asyncAliasReturnType_es6.js

@@ -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))
+}

tests/baselines/reference/asyncAliasReturnType_es6.symbols

@@ -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>
+}

tests/baselines/reference/asyncAliasReturnType_es6.types

@@ -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* () {
 });

tests/baselines/reference/asyncArrowFunction1_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* () {
 });

tests/baselines/reference/asyncArrowFunction6_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* () {
     });
 });