Assigning a @type to an async function emits an error about typescript HOT 1 OPEN

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d0a2843989..13407fdb86 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -39900,7 +39900,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         function checkSignatureDeclarationDiagnostics() {
             checkCollisionWithArgumentsInGeneratedCode(node);
 
-            let returnTypeNode = getEffectiveReturnTypeNode(node);
+            let returnTypeNode = getEffectiveReturnTypeNode(node, /*ignoreTypeTag*/ true);
             let returnTypeErrorLocation = returnTypeNode;
 
             if (isInJSFile(node)) {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 018eda7cb1..5ad67a9cd6 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -6657,10 +6657,10 @@ export function getTypeAnnotationNode(node: Node): TypeNode | undefined {
  *
  * @internal
  */
-export function getEffectiveReturnTypeNode(node: SignatureDeclaration | JSDocSignature): TypeNode | undefined {
+export function getEffectiveReturnTypeNode(node: SignatureDeclaration | JSDocSignature, ignoreTypeTag = false): TypeNode | undefined {
     return isJSDocSignature(node) ?
         node.type && node.type.typeExpression && node.type.typeExpression.type :
-        node.type || (isInJSFile(node) ? getJSDocReturnType(node) : undefined);
+        node.type || (isInJSFile(node) ? getJSDocReturnType(node, ignoreTypeTag) : undefined);
 }
 
 /** @internal */
diff --git a/src/compiler/utilitiesPublic.ts b/src/compiler/utilitiesPublic.ts
index 60e19b0e47..b8370acca9 100644
--- a/src/compiler/utilitiesPublic.ts
+++ b/src/compiler/utilitiesPublic.ts
@@ -1182,11 +1182,14 @@ export function getJSDocType(node: Node): TypeNode | undefined {
  * @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function
  * gets the type from inside the braces, after the fat arrow, etc.
  */
-export function getJSDocReturnType(node: Node): TypeNode | undefined {
+export function getJSDocReturnType(node: Node, ignoreTypeTag = false): TypeNode | undefined {
     const returnTag = getJSDocReturnTag(node);
     if (returnTag && returnTag.typeExpression) {
         return returnTag.typeExpression.type;
     }
+    if (ignoreTypeTag) {
+        return;
+    }
     const typeTag = getJSDocTypeTag(node);
     if (typeTag && typeTag.typeExpression) {
         const type = typeTag.typeExpression.type;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index ad1b05ed05..aa5623451e 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -8577,7 +8577,7 @@ declare namespace ts {
      * @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function
      * gets the type from inside the braces, after the fat arrow, etc.
      */
-    function getJSDocReturnType(node: Node): TypeNode | undefined;
+    function getJSDocReturnType(node: Node, ignoreTypeTag?: boolean): TypeNode | undefined;
     /** Get all JSDoc tags related to a node, including those on parent nodes. */
     function getJSDocTags(node: Node): readonly JSDocTag[];
     /** Gets all JSDoc tags that match a specified predicate */
diff --git a/tests/baselines/reference/asyncArrowFunction_allowJs.errors.txt b/tests/baselines/reference/asyncArrowFunction_allowJs.errors.txt
index 417262fef3..36b0ddea7b 100644
--- a/tests/baselines/reference/asyncArrowFunction_allowJs.errors.txt
+++ b/tests/baselines/reference/asyncArrowFunction_allowJs.errors.txt
@@ -1,13 +1,11 @@
 file.js(3,17): error TS2322: Type 'number' is not assignable to type 'string'.
-file.js(6,24): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<string>'?
 file.js(7,23): error TS2322: Type 'number' is not assignable to type 'string'.
-file.js(10,24): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<string>'?
 file.js(12,2): error TS2322: Type 'number' is not assignable to type 'string'.
-file.js(19,3): error TS2345: Argument of type '() => Promise<number>' is not assignable to parameter of type '() => string'.
+file.js(24,3): error TS2345: Argument of type '() => Promise<number>' is not assignable to parameter of type '() => string'.
   Type 'Promise<number>' is not assignable to type 'string'.
 
 
-==== file.js (6 errors) ====
+==== file.js (4 errors) ====
     // Error (good)
     /** @type {function(): string} */
     const a = () => 0
@@ -16,22 +14,23 @@ file.js(19,3): error TS2345: Argument of type '() => Promise<number>' is not ass
     
     // Error (good)
     /** @type {function(): string} */
-                           ~~~~~~
-!!! error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<string>'?
     const b = async () => 0
                           ~
 !!! error TS2322: Type 'number' is not assignable to type 'string'.
     
     // No error (bad)
     /** @type {function(): string} */
-                           ~~~~~~
-!!! error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<string>'?
     const c = async () => {
     	return 0
     	~~~~~~
 !!! error TS2322: Type 'number' is not assignable to type 'string'.
     }
     
+    /** @type {function(): string} */
+    const d = async () => {
+    	return ""
+    }
+    
     /** @type {function(function(): string): void} */
     const f = (p) => {}
     
diff --git a/tests/baselines/reference/asyncArrowFunction_allowJs.symbols b/tests/baselines/reference/asyncArrowFunction_allowJs.symbols
index 6cb66a2b9e..8ee40f15df 100644
--- a/tests/baselines/reference/asyncArrowFunction_allowJs.symbols
+++ b/tests/baselines/reference/asyncArrowFunction_allowJs.symbols
@@ -19,14 +19,21 @@ const c = async () => {
 	return 0
 }
 
+/** @type {function(): string} */
+const d = async () => {
+>d : Symbol(d, Decl(file.js, 15, 5))
+
+	return ""
+}
+
 /** @type {function(function(): string): void} */
 const f = (p) => {}
->f : Symbol(f, Decl(file.js, 15, 5))
->p : Symbol(p, Decl(file.js, 15, 11))
+>f : Symbol(f, Decl(file.js, 20, 5))
+>p : Symbol(p, Decl(file.js, 20, 11))
 
 // Error (good)
 f(async () => {
->f : Symbol(f, Decl(file.js, 15, 5))
+>f : Symbol(f, Decl(file.js, 20, 5))
 
 	return 0
 })
diff --git a/tests/baselines/reference/asyncArrowFunction_allowJs.types b/tests/baselines/reference/asyncArrowFunction_allowJs.types
index ecf9f7d9cc..068136f341 100644
--- a/tests/baselines/reference/asyncArrowFunction_allowJs.types
+++ b/tests/baselines/reference/asyncArrowFunction_allowJs.types
@@ -34,6 +34,18 @@ const c = async () => {
 >  : ^
 }
 
+/** @type {function(): string} */
+const d = async () => {
+>d : () => string
+>  : ^^^^^^^^^^^^
+>async () => {	return ""} : () => string
+>                         : ^^^^^^^^^^^^
+
+	return ""
+>"" : ""
+>   : ^^
+}
+
 /** @type {function(function(): string): void} */
 const f = (p) => {}
 >f : (arg0: () => string) => void
diff --git a/tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction_allowJs.ts b/tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction_allowJs.ts
index 9c21ae8557..7e490966d1 100644
--- a/tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction_allowJs.ts
+++ b/tests/cases/conformance/async/es2017/asyncArrowFunction/asyncArrowFunction_allowJs.ts
@@ -18,6 +18,11 @@ const c = async () => {
 	return 0
 }
 
+/** @type {function(): string} */
+const d = async () => {
+	return ""
+}
+
 /** @type {function(function(): string): void} */
 const f = (p) => {}