npm - @typescript-deploys/pr-build - Versions diffs - 5.2.0-pr-52095-16 → 5.2.0-pr-55152-2 - Mend

@typescript-deploys/pr-build 5.2.0-pr-52095-16 → 5.2.0-pr-55152-2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/lib/tsc.js CHANGED Viewed

@@ -18,7 +18,7 @@ and limitations under the License.
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230725`;
+var version = `${versionMajorMinor}.0-insiders.20230726`;
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5764,6 +5764,7 @@ var Diagnostics = {
   Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, 1 /* Error */, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
   An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
   The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
+  The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1065, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1065", "The return type of an async function or method must be the global Promise<T> type."),
   In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* Error */, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
   Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, 1 /* Error */, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
   Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, 1 /* Error */, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
@@ -59802,6 +59803,7 @@ function createTypeChecker(host) {
     let overrideNextErrorInfo = 0;
     let lastSkippedInfo;
     let incompatibleStack;
+    let skipParentCounter = 0;
     Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
     const result = isRelatedTo(
       source,
@@ -59977,7 +59979,15 @@ function createTypeChecker(host) {
         reportIncompatibleStack();
       if (message.elidedInCompatabilityPyramid)
         return;
-      errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+      if (skipParentCounter === 0) {
+        errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+      } else {
+        skipParentCounter--;
+      }
+    }
+    function reportParentSkippedError(message, ...args) {
+      reportError(message, ...args);
+      skipParentCounter++;
     }
     function associateRelatedInfo(info) {
       Debug.assert(!!errorInfo);
@@ -60314,14 +60324,14 @@ function createTypeChecker(host) {
                   }
                 }
                 if (suggestion !== void 0) {
-                  reportError(
+                  reportParentSkippedError(
                     Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2,
                     symbolToString(prop),
                     typeToString(errorTarget),
                     suggestion
                   );
                 } else {
-                  reportError(
+                  reportParentSkippedError(
                     Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
                     symbolToString(prop),
                     typeToString(errorTarget)
@@ -61158,26 +61168,6 @@ function createTypeChecker(host) {
           )) {
             return result2;
           }
-          if (sourceFlags & 8388608 /* IndexedAccess */) {
-            const indexType = source2.indexType;
-            if (indexType.flags & 4194304 /* Index */) {
-              const unresolvedIndexConstraint = getBaseConstraintOfType(indexType.type);
-              const indexConstraint = unresolvedIndexConstraint && unresolvedIndexConstraint !== noConstraintType ? getIndexType(unresolvedIndexConstraint) : keyofConstraintType;
-              const constraint2 = getIndexedAccessType(source2.objectType, indexConstraint);
-              if (result2 = isRelatedTo(
-                constraint2,
-                target2,
-                1 /* Source */,
-                /*reportErrors*/
-                false,
-                /*headMessage*/
-                void 0,
-                intersectionState
-              )) {
-                return result2;
-              }
-            }
-          }
           if (isMappedTypeGenericIndexedAccess(source2)) {
             const indexConstraint = getConstraintOfType(source2.indexType);
             if (indexConstraint) {
@@ -67272,75 +67262,41 @@ function createTypeChecker(host) {
     return mapType(
       type,
       (t) => {
-        if (!(t.flags & 3670016 /* StructuredType */)) {
-          return void 0;
-        }
-        if (t.flags & 2097152 /* Intersection */) {
-          const intersection = t;
-          let applicableIndexedMappedTypeSubstitions;
-          let concretePropertyTypes;
-          let applicableIndexInfoCandidates;
-          for (const t2 of intersection.types) {
-            if (isGenericMappedType(t2) && !t2.declaration.nameType) {
-              applicableIndexedMappedTypeSubstitions = append(applicableIndexedMappedTypeSubstitions, getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t2));
-              continue;
-            }
-            const typeOfConcreteProperty = getTypeOfConcretePropertyOfContextualType(t2);
-            if (typeOfConcreteProperty) {
-              concretePropertyTypes = append(concretePropertyTypes, typeOfConcreteProperty);
-              continue;
-            }
-            applicableIndexInfoCandidates = append(applicableIndexInfoCandidates, t2);
-          }
-          if (concretePropertyTypes) {
-            return getIntersectionType(concatenate(concretePropertyTypes, applicableIndexedMappedTypeSubstitions));
+        var _a;
+        if (isGenericMappedType(t) && !t.declaration.nameType) {
+          const constraint = getConstraintTypeFromMappedType(t);
+          const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+          const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+          if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+            return substituteIndexedMappedType(t, propertyNameType);
+          }
+        } else if (t.flags & 3670016 /* StructuredType */) {
+          const prop = getPropertyOfType(t, name);
+          if (prop) {
+            return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
           }
-          const types = concatenate(mapDefined(applicableIndexInfoCandidates, getTypeOfApplicableIndexInfoOfContextualType), applicableIndexedMappedTypeSubstitions);
-          if (types.length > 0) {
-            return getIntersectionType(types);
+          if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
+            const restType = getElementTypeOfSliceOfTupleType(
+              t,
+              t.target.fixedLength,
+              /*endSkipCount*/
+              0,
+              /*writing*/
+              false,
+              /*noReductions*/
+              true
+            );
+            if (restType) {
+              return restType;
+            }
           }
-          return void 0;
+          return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
         }
-        return isGenericMappedType(t) && !t.declaration.nameType ? getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) : getTypeOfConcretePropertyOfContextualType(t) || getTypeOfApplicableIndexInfoOfContextualType(t);
+        return void 0;
       },
       /*noReductions*/
       true
     );
-    function getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) {
-      const constraint = getConstraintTypeFromMappedType(t);
-      const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-      const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-      if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-        return substituteIndexedMappedType(t, propertyNameType);
-      }
-      return void 0;
-    }
-    function getTypeOfConcretePropertyOfContextualType(t) {
-      const prop = getPropertyOfType(t, name);
-      if (prop) {
-        return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
-      }
-      if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-        const restType = getElementTypeOfSliceOfTupleType(
-          t,
-          t.target.fixedLength,
-          /*endSkipCount*/
-          0,
-          /*writing*/
-          false,
-          /*noReductions*/
-          true
-        );
-        if (restType) {
-          return restType;
-        }
-      }
-      return void 0;
-    }
-    function getTypeOfApplicableIndexInfoOfContextualType(t) {
-      var _a;
-      return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
-    }
   }
   function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
     Debug.assert(isObjectLiteralMethod(node));
@@ -75020,7 +74976,18 @@ function createTypeChecker(host) {
     addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
     function checkSignatureDeclarationDiagnostics() {
       checkCollisionWithArgumentsInGeneratedCode(node);
-      const returnTypeNode = getEffectiveReturnTypeNode(node);
+      let returnTypeNode = getEffectiveReturnTypeNode(node);
+      let returnTypeErrorLocation = returnTypeNode;
+      if (isInJSFile(node)) {
+        const typeTag = getJSDocTypeTag(node);
+        if (typeTag && typeTag.typeExpression && isTypeReferenceNode(typeTag.typeExpression.type)) {
+          const signature = getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
+          if (signature && signature.declaration) {
+            returnTypeNode = getEffectiveReturnTypeNode(signature.declaration);
+            returnTypeErrorLocation = typeTag.typeExpression.type;
+          }
+        }
+      }
       if (noImplicitAny && !returnTypeNode) {
         switch (node.kind) {
           case 180 /* ConstructSignature */:
@@ -75031,21 +74998,21 @@ function createTypeChecker(host) {
             break;
         }
       }
-      if (returnTypeNode) {
+      if (returnTypeNode && returnTypeErrorLocation) {
         const functionFlags2 = getFunctionFlags(node);
         if ((functionFlags2 & (4 /* Invalid */ | 1 /* Generator */)) === 1 /* Generator */) {
           const returnType = getTypeFromTypeNode(returnTypeNode);
           if (returnType === voidType) {
-            error(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+            error(returnTypeErrorLocation, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
           } else {
             const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
             const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
             const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
             const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
-            checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
+            checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeErrorLocation);
           }
         } else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
-          checkAsyncFunctionReturnType(node, returnTypeNode);
+          checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation);
         }
       }
       if (node.kind !== 181 /* IndexSignature */ && node.kind !== 324 /* JSDocFunctionType */) {
@@ -76127,7 +76094,7 @@ function createTypeChecker(host) {
     }
     return typeAsAwaitable.awaitedTypeOfType = type;
   }
-  function checkAsyncFunctionReturnType(node, returnTypeNode) {
+  function checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation) {
     const returnType = getTypeFromTypeNode(returnTypeNode);
     if (languageVersion >= 2 /* ES2015 */) {
       if (isErrorType(returnType)) {
@@ -76138,7 +76105,7 @@ function createTypeChecker(host) {
         true
       );
       if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) {
-        error(returnTypeNode, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
+        reportErrorForInvalidReturnType(Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, returnTypeNode, returnTypeErrorLocation, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
         return;
       }
     } else {
@@ -76148,7 +76115,7 @@ function createTypeChecker(host) {
       }
       const promiseConstructorName = getEntityNameFromTypeNode(returnTypeNode);
       if (promiseConstructorName === void 0) {
-        error(returnTypeNode, 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, typeToString(returnType));
+        reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, typeToString(returnType));
         return;
       }
       const promiseConstructorSymbol = resolveEntityName(
@@ -76163,9 +76130,9 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false
         )) {
-          error(returnTypeNode, 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);
+          error(returnTypeErrorLocation, 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(returnTypeNode, 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));
+          reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
         }
         return;
       }
@@ -76174,15 +76141,16 @@ function createTypeChecker(host) {
         true
       );
       if (globalPromiseConstructorLikeType === emptyObjectType) {
-        error(returnTypeNode, 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));
+        reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
         return;
       }
-      if (!checkTypeAssignableTo(
-        promiseConstructorType,
-        globalPromiseConstructorLikeType,
-        returnTypeNode,
-        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
-      )) {
+      const headMessage = 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;
+      const errorInfo = () => returnTypeNode === returnTypeErrorLocation ? void 0 : chainDiagnosticMessages(
+        /*details*/
+        void 0,
+        Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type
+      );
+      if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeErrorLocation, headMessage, errorInfo)) {
         return;
       }
       const rootName = promiseConstructorName && getFirstIdentifier(promiseConstructorName);
@@ -76204,6 +76172,14 @@ function createTypeChecker(host) {
       node,
       Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
     );
+    function reportErrorForInvalidReturnType(message, returnTypeNode2, returnTypeErrorLocation2, typeName) {
+      if (returnTypeNode2 === returnTypeErrorLocation2) {
+        error(returnTypeErrorLocation2, message, typeName);
+      } else {
+        const diag2 = error(returnTypeErrorLocation2, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
+        addRelatedInfo(diag2, createDiagnosticForNode(returnTypeNode2, message, typeName));
+      }
+    }
   }
   function checkDecorator(node) {
     const signature = getResolvedSignature(node);

package/lib/tsserver.js CHANGED Viewed

@@ -2329,7 +2329,7 @@ module.exports = __toCommonJS(server_exports);
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230725`;
+var version = `${versionMajorMinor}.0-insiders.20230726`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -9287,6 +9287,7 @@ var Diagnostics = {
   Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, 1 /* Error */, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
   An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
   The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
+  The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1065, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1065", "The return type of an async function or method must be the global Promise<T> type."),
   In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* Error */, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
   Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, 1 /* Error */, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
   Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, 1 /* Error */, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
@@ -64511,6 +64512,7 @@ function createTypeChecker(host) {
     let overrideNextErrorInfo = 0;
     let lastSkippedInfo;
     let incompatibleStack;
+    let skipParentCounter = 0;
     Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
     const result = isRelatedTo(
       source,
@@ -64686,7 +64688,15 @@ function createTypeChecker(host) {
         reportIncompatibleStack();
       if (message.elidedInCompatabilityPyramid)
         return;
-      errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+      if (skipParentCounter === 0) {
+        errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+      } else {
+        skipParentCounter--;
+      }
+    }
+    function reportParentSkippedError(message, ...args) {
+      reportError(message, ...args);
+      skipParentCounter++;
     }
     function associateRelatedInfo(info) {
       Debug.assert(!!errorInfo);
@@ -65023,14 +65033,14 @@ function createTypeChecker(host) {
                   }
                 }
                 if (suggestion !== void 0) {
-                  reportError(
+                  reportParentSkippedError(
                     Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2,
                     symbolToString(prop),
                     typeToString(errorTarget),
                     suggestion
                   );
                 } else {
-                  reportError(
+                  reportParentSkippedError(
                     Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
                     symbolToString(prop),
                     typeToString(errorTarget)
@@ -65867,26 +65877,6 @@ function createTypeChecker(host) {
           )) {
             return result2;
           }
-          if (sourceFlags & 8388608 /* IndexedAccess */) {
-            const indexType = source2.indexType;
-            if (indexType.flags & 4194304 /* Index */) {
-              const unresolvedIndexConstraint = getBaseConstraintOfType(indexType.type);
-              const indexConstraint = unresolvedIndexConstraint && unresolvedIndexConstraint !== noConstraintType ? getIndexType(unresolvedIndexConstraint) : keyofConstraintType;
-              const constraint2 = getIndexedAccessType(source2.objectType, indexConstraint);
-              if (result2 = isRelatedTo(
-                constraint2,
-                target2,
-                1 /* Source */,
-                /*reportErrors*/
-                false,
-                /*headMessage*/
-                void 0,
-                intersectionState
-              )) {
-                return result2;
-              }
-            }
-          }
           if (isMappedTypeGenericIndexedAccess(source2)) {
             const indexConstraint = getConstraintOfType(source2.indexType);
             if (indexConstraint) {
@@ -71981,75 +71971,41 @@ function createTypeChecker(host) {
     return mapType(
       type,
       (t) => {
-        if (!(t.flags & 3670016 /* StructuredType */)) {
-          return void 0;
-        }
-        if (t.flags & 2097152 /* Intersection */) {
-          const intersection = t;
-          let applicableIndexedMappedTypeSubstitions;
-          let concretePropertyTypes;
-          let applicableIndexInfoCandidates;
-          for (const t2 of intersection.types) {
-            if (isGenericMappedType(t2) && !t2.declaration.nameType) {
-              applicableIndexedMappedTypeSubstitions = append(applicableIndexedMappedTypeSubstitions, getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t2));
-              continue;
-            }
-            const typeOfConcreteProperty = getTypeOfConcretePropertyOfContextualType(t2);
-            if (typeOfConcreteProperty) {
-              concretePropertyTypes = append(concretePropertyTypes, typeOfConcreteProperty);
-              continue;
-            }
-            applicableIndexInfoCandidates = append(applicableIndexInfoCandidates, t2);
-          }
-          if (concretePropertyTypes) {
-            return getIntersectionType(concatenate(concretePropertyTypes, applicableIndexedMappedTypeSubstitions));
+        var _a;
+        if (isGenericMappedType(t) && !t.declaration.nameType) {
+          const constraint = getConstraintTypeFromMappedType(t);
+          const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+          const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+          if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+            return substituteIndexedMappedType(t, propertyNameType);
+          }
+        } else if (t.flags & 3670016 /* StructuredType */) {
+          const prop = getPropertyOfType(t, name);
+          if (prop) {
+            return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
           }
-          const types = concatenate(mapDefined(applicableIndexInfoCandidates, getTypeOfApplicableIndexInfoOfContextualType), applicableIndexedMappedTypeSubstitions);
-          if (types.length > 0) {
-            return getIntersectionType(types);
+          if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
+            const restType = getElementTypeOfSliceOfTupleType(
+              t,
+              t.target.fixedLength,
+              /*endSkipCount*/
+              0,
+              /*writing*/
+              false,
+              /*noReductions*/
+              true
+            );
+            if (restType) {
+              return restType;
+            }
           }
-          return void 0;
+          return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
         }
-        return isGenericMappedType(t) && !t.declaration.nameType ? getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) : getTypeOfConcretePropertyOfContextualType(t) || getTypeOfApplicableIndexInfoOfContextualType(t);
+        return void 0;
       },
       /*noReductions*/
       true
     );
-    function getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) {
-      const constraint = getConstraintTypeFromMappedType(t);
-      const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-      const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-      if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-        return substituteIndexedMappedType(t, propertyNameType);
-      }
-      return void 0;
-    }
-    function getTypeOfConcretePropertyOfContextualType(t) {
-      const prop = getPropertyOfType(t, name);
-      if (prop) {
-        return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
-      }
-      if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-        const restType = getElementTypeOfSliceOfTupleType(
-          t,
-          t.target.fixedLength,
-          /*endSkipCount*/
-          0,
-          /*writing*/
-          false,
-          /*noReductions*/
-          true
-        );
-        if (restType) {
-          return restType;
-        }
-      }
-      return void 0;
-    }
-    function getTypeOfApplicableIndexInfoOfContextualType(t) {
-      var _a;
-      return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
-    }
   }
   function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
     Debug.assert(isObjectLiteralMethod(node));
@@ -79729,7 +79685,18 @@ function createTypeChecker(host) {
     addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
     function checkSignatureDeclarationDiagnostics() {
       checkCollisionWithArgumentsInGeneratedCode(node);
-      const returnTypeNode = getEffectiveReturnTypeNode(node);
+      let returnTypeNode = getEffectiveReturnTypeNode(node);
+      let returnTypeErrorLocation = returnTypeNode;
+      if (isInJSFile(node)) {
+        const typeTag = getJSDocTypeTag(node);
+        if (typeTag && typeTag.typeExpression && isTypeReferenceNode(typeTag.typeExpression.type)) {
+          const signature = getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
+          if (signature && signature.declaration) {
+            returnTypeNode = getEffectiveReturnTypeNode(signature.declaration);
+            returnTypeErrorLocation = typeTag.typeExpression.type;
+          }
+        }
+      }
       if (noImplicitAny && !returnTypeNode) {
         switch (node.kind) {
           case 180 /* ConstructSignature */:
@@ -79740,21 +79707,21 @@ function createTypeChecker(host) {
             break;
         }
       }
-      if (returnTypeNode) {
+      if (returnTypeNode && returnTypeErrorLocation) {
         const functionFlags2 = getFunctionFlags(node);
         if ((functionFlags2 & (4 /* Invalid */ | 1 /* Generator */)) === 1 /* Generator */) {
           const returnType = getTypeFromTypeNode(returnTypeNode);
           if (returnType === voidType) {
-            error2(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+            error2(returnTypeErrorLocation, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
           } else {
             const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
             const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
             const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
             const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
-            checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
+            checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeErrorLocation);
           }
         } else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
-          checkAsyncFunctionReturnType(node, returnTypeNode);
+          checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation);
         }
       }
       if (node.kind !== 181 /* IndexSignature */ && node.kind !== 324 /* JSDocFunctionType */) {
@@ -80836,7 +80803,7 @@ function createTypeChecker(host) {
     }
     return typeAsAwaitable.awaitedTypeOfType = type;
   }
-  function checkAsyncFunctionReturnType(node, returnTypeNode) {
+  function checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation) {
     const returnType = getTypeFromTypeNode(returnTypeNode);
     if (languageVersion >= 2 /* ES2015 */) {
       if (isErrorType(returnType)) {
@@ -80847,7 +80814,7 @@ function createTypeChecker(host) {
         true
       );
       if (globalPromiseType !== emptyGenericType && !isReferenceToType2(returnType, globalPromiseType)) {
-        error2(returnTypeNode, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
+        reportErrorForInvalidReturnType(Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, returnTypeNode, returnTypeErrorLocation, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
         return;
       }
     } else {
@@ -80857,7 +80824,7 @@ function createTypeChecker(host) {
       }
       const promiseConstructorName = getEntityNameFromTypeNode(returnTypeNode);
       if (promiseConstructorName === void 0) {
-        error2(returnTypeNode, 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, typeToString(returnType));
+        reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, typeToString(returnType));
         return;
       }
       const promiseConstructorSymbol = resolveEntityName(
@@ -80872,9 +80839,9 @@ function createTypeChecker(host) {
           /*reportErrors*/
           false
         )) {
-          error2(returnTypeNode, 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);
+          error2(returnTypeErrorLocation, 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 {
-          error2(returnTypeNode, 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));
+          reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
         }
         return;
       }
@@ -80883,15 +80850,16 @@ function createTypeChecker(host) {
         true
       );
       if (globalPromiseConstructorLikeType === emptyObjectType) {
-        error2(returnTypeNode, 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));
+        reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
         return;
       }
-      if (!checkTypeAssignableTo(
-        promiseConstructorType,
-        globalPromiseConstructorLikeType,
-        returnTypeNode,
-        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
-      )) {
+      const headMessage = 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;
+      const errorInfo = () => returnTypeNode === returnTypeErrorLocation ? void 0 : chainDiagnosticMessages(
+        /*details*/
+        void 0,
+        Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type
+      );
+      if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeErrorLocation, headMessage, errorInfo)) {
         return;
       }
       const rootName = promiseConstructorName && getFirstIdentifier(promiseConstructorName);
@@ -80913,6 +80881,14 @@ function createTypeChecker(host) {
       node,
       Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
     );
+    function reportErrorForInvalidReturnType(message, returnTypeNode2, returnTypeErrorLocation2, typeName) {
+      if (returnTypeNode2 === returnTypeErrorLocation2) {
+        error2(returnTypeErrorLocation2, message, typeName);
+      } else {
+        const diag2 = error2(returnTypeErrorLocation2, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
+        addRelatedInfo(diag2, createDiagnosticForNode(returnTypeNode2, message, typeName));
+      }
+    }
   }
   function checkDecorator(node) {
     const signature = getResolvedSignature(node);

package/lib/tsserverlibrary.js CHANGED Viewed

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.2";
-      version = `${versionMajorMinor}.0-insiders.20230725`;
+      version = `${versionMajorMinor}.0-insiders.20230726`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7068,6 +7068,7 @@ ${lanes.join("\n")}
         Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, 1 /* Error */, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
         An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
         The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
+        The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1065, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1065", "The return type of an async function or method must be the global Promise<T> type."),
         In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* Error */, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
         Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, 1 /* Error */, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
         Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, 1 /* Error */, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
@@ -62276,6 +62277,7 @@ ${lanes.join("\n")}
       let overrideNextErrorInfo = 0;
       let lastSkippedInfo;
       let incompatibleStack;
+      let skipParentCounter = 0;
       Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
       const result = isRelatedTo(
         source,
@@ -62451,7 +62453,15 @@ ${lanes.join("\n")}
           reportIncompatibleStack();
         if (message.elidedInCompatabilityPyramid)
           return;
-        errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+        if (skipParentCounter === 0) {
+          errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+        } else {
+          skipParentCounter--;
+        }
+      }
+      function reportParentSkippedError(message, ...args) {
+        reportError(message, ...args);
+        skipParentCounter++;
       }
       function associateRelatedInfo(info) {
         Debug.assert(!!errorInfo);
@@ -62788,14 +62798,14 @@ ${lanes.join("\n")}
                     }
                   }
                   if (suggestion !== void 0) {
-                    reportError(
+                    reportParentSkippedError(
                       Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2,
                       symbolToString(prop),
                       typeToString(errorTarget),
                       suggestion
                     );
                   } else {
-                    reportError(
+                    reportParentSkippedError(
                       Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
                       symbolToString(prop),
                       typeToString(errorTarget)
@@ -63632,26 +63642,6 @@ ${lanes.join("\n")}
             )) {
               return result2;
             }
-            if (sourceFlags & 8388608 /* IndexedAccess */) {
-              const indexType = source2.indexType;
-              if (indexType.flags & 4194304 /* Index */) {
-                const unresolvedIndexConstraint = getBaseConstraintOfType(indexType.type);
-                const indexConstraint = unresolvedIndexConstraint && unresolvedIndexConstraint !== noConstraintType ? getIndexType(unresolvedIndexConstraint) : keyofConstraintType;
-                const constraint2 = getIndexedAccessType(source2.objectType, indexConstraint);
-                if (result2 = isRelatedTo(
-                  constraint2,
-                  target2,
-                  1 /* Source */,
-                  /*reportErrors*/
-                  false,
-                  /*headMessage*/
-                  void 0,
-                  intersectionState
-                )) {
-                  return result2;
-                }
-              }
-            }
             if (isMappedTypeGenericIndexedAccess(source2)) {
               const indexConstraint = getConstraintOfType(source2.indexType);
               if (indexConstraint) {
@@ -69746,75 +69736,41 @@ ${lanes.join("\n")}
       return mapType(
         type,
         (t) => {
-          if (!(t.flags & 3670016 /* StructuredType */)) {
-            return void 0;
-          }
-          if (t.flags & 2097152 /* Intersection */) {
-            const intersection = t;
-            let applicableIndexedMappedTypeSubstitions;
-            let concretePropertyTypes;
-            let applicableIndexInfoCandidates;
-            for (const t2 of intersection.types) {
-              if (isGenericMappedType(t2) && !t2.declaration.nameType) {
-                applicableIndexedMappedTypeSubstitions = append(applicableIndexedMappedTypeSubstitions, getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t2));
-                continue;
-              }
-              const typeOfConcreteProperty = getTypeOfConcretePropertyOfContextualType(t2);
-              if (typeOfConcreteProperty) {
-                concretePropertyTypes = append(concretePropertyTypes, typeOfConcreteProperty);
-                continue;
-              }
-              applicableIndexInfoCandidates = append(applicableIndexInfoCandidates, t2);
-            }
-            if (concretePropertyTypes) {
-              return getIntersectionType(concatenate(concretePropertyTypes, applicableIndexedMappedTypeSubstitions));
+          var _a;
+          if (isGenericMappedType(t) && !t.declaration.nameType) {
+            const constraint = getConstraintTypeFromMappedType(t);
+            const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+            const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+            if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+              return substituteIndexedMappedType(t, propertyNameType);
+            }
+          } else if (t.flags & 3670016 /* StructuredType */) {
+            const prop = getPropertyOfType(t, name);
+            if (prop) {
+              return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
             }
-            const types = concatenate(mapDefined(applicableIndexInfoCandidates, getTypeOfApplicableIndexInfoOfContextualType), applicableIndexedMappedTypeSubstitions);
-            if (types.length > 0) {
-              return getIntersectionType(types);
+            if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
+              const restType = getElementTypeOfSliceOfTupleType(
+                t,
+                t.target.fixedLength,
+                /*endSkipCount*/
+                0,
+                /*writing*/
+                false,
+                /*noReductions*/
+                true
+              );
+              if (restType) {
+                return restType;
+              }
             }
-            return void 0;
+            return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
           }
-          return isGenericMappedType(t) && !t.declaration.nameType ? getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) : getTypeOfConcretePropertyOfContextualType(t) || getTypeOfApplicableIndexInfoOfContextualType(t);
+          return void 0;
         },
         /*noReductions*/
         true
       );
-      function getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) {
-        const constraint = getConstraintTypeFromMappedType(t);
-        const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-        const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-        if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-          return substituteIndexedMappedType(t, propertyNameType);
-        }
-        return void 0;
-      }
-      function getTypeOfConcretePropertyOfContextualType(t) {
-        const prop = getPropertyOfType(t, name);
-        if (prop) {
-          return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
-        }
-        if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-          const restType = getElementTypeOfSliceOfTupleType(
-            t,
-            t.target.fixedLength,
-            /*endSkipCount*/
-            0,
-            /*writing*/
-            false,
-            /*noReductions*/
-            true
-          );
-          if (restType) {
-            return restType;
-          }
-        }
-        return void 0;
-      }
-      function getTypeOfApplicableIndexInfoOfContextualType(t) {
-        var _a;
-        return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
-      }
     }
     function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
       Debug.assert(isObjectLiteralMethod(node));
@@ -77494,7 +77450,18 @@ ${lanes.join("\n")}
       addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
       function checkSignatureDeclarationDiagnostics() {
         checkCollisionWithArgumentsInGeneratedCode(node);
-        const returnTypeNode = getEffectiveReturnTypeNode(node);
+        let returnTypeNode = getEffectiveReturnTypeNode(node);
+        let returnTypeErrorLocation = returnTypeNode;
+        if (isInJSFile(node)) {
+          const typeTag = getJSDocTypeTag(node);
+          if (typeTag && typeTag.typeExpression && isTypeReferenceNode(typeTag.typeExpression.type)) {
+            const signature = getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
+            if (signature && signature.declaration) {
+              returnTypeNode = getEffectiveReturnTypeNode(signature.declaration);
+              returnTypeErrorLocation = typeTag.typeExpression.type;
+            }
+          }
+        }
         if (noImplicitAny && !returnTypeNode) {
           switch (node.kind) {
             case 180 /* ConstructSignature */:
@@ -77505,21 +77472,21 @@ ${lanes.join("\n")}
               break;
           }
         }
-        if (returnTypeNode) {
+        if (returnTypeNode && returnTypeErrorLocation) {
           const functionFlags2 = getFunctionFlags(node);
           if ((functionFlags2 & (4 /* Invalid */ | 1 /* Generator */)) === 1 /* Generator */) {
             const returnType = getTypeFromTypeNode(returnTypeNode);
             if (returnType === voidType) {
-              error2(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+              error2(returnTypeErrorLocation, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
             } else {
               const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
               const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
               const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
               const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
-              checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
+              checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeErrorLocation);
             }
           } else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
-            checkAsyncFunctionReturnType(node, returnTypeNode);
+            checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation);
           }
         }
         if (node.kind !== 181 /* IndexSignature */ && node.kind !== 324 /* JSDocFunctionType */) {
@@ -78601,7 +78568,7 @@ ${lanes.join("\n")}
       }
       return typeAsAwaitable.awaitedTypeOfType = type;
     }
-    function checkAsyncFunctionReturnType(node, returnTypeNode) {
+    function checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation) {
       const returnType = getTypeFromTypeNode(returnTypeNode);
       if (languageVersion >= 2 /* ES2015 */) {
         if (isErrorType(returnType)) {
@@ -78612,7 +78579,7 @@ ${lanes.join("\n")}
           true
         );
         if (globalPromiseType !== emptyGenericType && !isReferenceToType2(returnType, globalPromiseType)) {
-          error2(returnTypeNode, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
+          reportErrorForInvalidReturnType(Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, returnTypeNode, returnTypeErrorLocation, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
           return;
         }
       } else {
@@ -78622,7 +78589,7 @@ ${lanes.join("\n")}
         }
         const promiseConstructorName = getEntityNameFromTypeNode(returnTypeNode);
         if (promiseConstructorName === void 0) {
-          error2(returnTypeNode, 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, typeToString(returnType));
+          reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, typeToString(returnType));
           return;
         }
         const promiseConstructorSymbol = resolveEntityName(
@@ -78637,9 +78604,9 @@ ${lanes.join("\n")}
             /*reportErrors*/
             false
           )) {
-            error2(returnTypeNode, 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);
+            error2(returnTypeErrorLocation, 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 {
-            error2(returnTypeNode, 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));
+            reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
           }
           return;
         }
@@ -78648,15 +78615,16 @@ ${lanes.join("\n")}
           true
         );
         if (globalPromiseConstructorLikeType === emptyObjectType) {
-          error2(returnTypeNode, 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));
+          reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
           return;
         }
-        if (!checkTypeAssignableTo(
-          promiseConstructorType,
-          globalPromiseConstructorLikeType,
-          returnTypeNode,
-          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
-        )) {
+        const headMessage = 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;
+        const errorInfo = () => returnTypeNode === returnTypeErrorLocation ? void 0 : chainDiagnosticMessages(
+          /*details*/
+          void 0,
+          Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type
+        );
+        if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeErrorLocation, headMessage, errorInfo)) {
           return;
         }
         const rootName = promiseConstructorName && getFirstIdentifier(promiseConstructorName);
@@ -78678,6 +78646,14 @@ ${lanes.join("\n")}
         node,
         Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
       );
+      function reportErrorForInvalidReturnType(message, returnTypeNode2, returnTypeErrorLocation2, typeName) {
+        if (returnTypeNode2 === returnTypeErrorLocation2) {
+          error2(returnTypeErrorLocation2, message, typeName);
+        } else {
+          const diag2 = error2(returnTypeErrorLocation2, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
+          addRelatedInfo(diag2, createDiagnosticForNode(returnTypeNode2, message, typeName));
+        }
+      }
     }
     function checkDecorator(node) {
       const signature = getResolvedSignature(node);

package/lib/typescript.js CHANGED Viewed

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.2";
-      version = `${versionMajorMinor}.0-insiders.20230725`;
+      version = `${versionMajorMinor}.0-insiders.20230726`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7068,6 +7068,7 @@ ${lanes.join("\n")}
         Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, 1 /* Error */, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
         An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
         The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
+        The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1065, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1065", "The return type of an async function or method must be the global Promise<T> type."),
         In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* Error */, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
         Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, 1 /* Error */, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
         Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, 1 /* Error */, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),
@@ -62276,6 +62277,7 @@ ${lanes.join("\n")}
       let overrideNextErrorInfo = 0;
       let lastSkippedInfo;
       let incompatibleStack;
+      let skipParentCounter = 0;
       Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking");
       const result = isRelatedTo(
         source,
@@ -62451,7 +62453,15 @@ ${lanes.join("\n")}
           reportIncompatibleStack();
         if (message.elidedInCompatabilityPyramid)
           return;
-        errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+        if (skipParentCounter === 0) {
+          errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
+        } else {
+          skipParentCounter--;
+        }
+      }
+      function reportParentSkippedError(message, ...args) {
+        reportError(message, ...args);
+        skipParentCounter++;
       }
       function associateRelatedInfo(info) {
         Debug.assert(!!errorInfo);
@@ -62788,14 +62798,14 @@ ${lanes.join("\n")}
                     }
                   }
                   if (suggestion !== void 0) {
-                    reportError(
+                    reportParentSkippedError(
                       Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2,
                       symbolToString(prop),
                       typeToString(errorTarget),
                       suggestion
                     );
                   } else {
-                    reportError(
+                    reportParentSkippedError(
                       Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,
                       symbolToString(prop),
                       typeToString(errorTarget)
@@ -63632,26 +63642,6 @@ ${lanes.join("\n")}
             )) {
               return result2;
             }
-            if (sourceFlags & 8388608 /* IndexedAccess */) {
-              const indexType = source2.indexType;
-              if (indexType.flags & 4194304 /* Index */) {
-                const unresolvedIndexConstraint = getBaseConstraintOfType(indexType.type);
-                const indexConstraint = unresolvedIndexConstraint && unresolvedIndexConstraint !== noConstraintType ? getIndexType(unresolvedIndexConstraint) : keyofConstraintType;
-                const constraint2 = getIndexedAccessType(source2.objectType, indexConstraint);
-                if (result2 = isRelatedTo(
-                  constraint2,
-                  target2,
-                  1 /* Source */,
-                  /*reportErrors*/
-                  false,
-                  /*headMessage*/
-                  void 0,
-                  intersectionState
-                )) {
-                  return result2;
-                }
-              }
-            }
             if (isMappedTypeGenericIndexedAccess(source2)) {
               const indexConstraint = getConstraintOfType(source2.indexType);
               if (indexConstraint) {
@@ -69746,75 +69736,41 @@ ${lanes.join("\n")}
       return mapType(
         type,
         (t) => {
-          if (!(t.flags & 3670016 /* StructuredType */)) {
-            return void 0;
-          }
-          if (t.flags & 2097152 /* Intersection */) {
-            const intersection = t;
-            let applicableIndexedMappedTypeSubstitions;
-            let concretePropertyTypes;
-            let applicableIndexInfoCandidates;
-            for (const t2 of intersection.types) {
-              if (isGenericMappedType(t2) && !t2.declaration.nameType) {
-                applicableIndexedMappedTypeSubstitions = append(applicableIndexedMappedTypeSubstitions, getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t2));
-                continue;
-              }
-              const typeOfConcreteProperty = getTypeOfConcretePropertyOfContextualType(t2);
-              if (typeOfConcreteProperty) {
-                concretePropertyTypes = append(concretePropertyTypes, typeOfConcreteProperty);
-                continue;
-              }
-              applicableIndexInfoCandidates = append(applicableIndexInfoCandidates, t2);
-            }
-            if (concretePropertyTypes) {
-              return getIntersectionType(concatenate(concretePropertyTypes, applicableIndexedMappedTypeSubstitions));
+          var _a;
+          if (isGenericMappedType(t) && !t.declaration.nameType) {
+            const constraint = getConstraintTypeFromMappedType(t);
+            const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+            const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+            if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+              return substituteIndexedMappedType(t, propertyNameType);
+            }
+          } else if (t.flags & 3670016 /* StructuredType */) {
+            const prop = getPropertyOfType(t, name);
+            if (prop) {
+              return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
             }
-            const types = concatenate(mapDefined(applicableIndexInfoCandidates, getTypeOfApplicableIndexInfoOfContextualType), applicableIndexedMappedTypeSubstitions);
-            if (types.length > 0) {
-              return getIntersectionType(types);
+            if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
+              const restType = getElementTypeOfSliceOfTupleType(
+                t,
+                t.target.fixedLength,
+                /*endSkipCount*/
+                0,
+                /*writing*/
+                false,
+                /*noReductions*/
+                true
+              );
+              if (restType) {
+                return restType;
+              }
             }
-            return void 0;
+            return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
           }
-          return isGenericMappedType(t) && !t.declaration.nameType ? getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) : getTypeOfConcretePropertyOfContextualType(t) || getTypeOfApplicableIndexInfoOfContextualType(t);
+          return void 0;
         },
         /*noReductions*/
         true
       );
-      function getTypeOfApplicableIndexedMappedTypeSubstitutionOfContextualType(t) {
-        const constraint = getConstraintTypeFromMappedType(t);
-        const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-        const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-        if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-          return substituteIndexedMappedType(t, propertyNameType);
-        }
-        return void 0;
-      }
-      function getTypeOfConcretePropertyOfContextualType(t) {
-        const prop = getPropertyOfType(t, name);
-        if (prop) {
-          return isCircularMappedProperty(prop) ? void 0 : getTypeOfSymbol(prop);
-        }
-        if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-          const restType = getElementTypeOfSliceOfTupleType(
-            t,
-            t.target.fixedLength,
-            /*endSkipCount*/
-            0,
-            /*writing*/
-            false,
-            /*noReductions*/
-            true
-          );
-          if (restType) {
-            return restType;
-          }
-        }
-        return void 0;
-      }
-      function getTypeOfApplicableIndexInfoOfContextualType(t) {
-        var _a;
-        return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
-      }
     }
     function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
       Debug.assert(isObjectLiteralMethod(node));
@@ -77494,7 +77450,18 @@ ${lanes.join("\n")}
       addLazyDiagnostic(checkSignatureDeclarationDiagnostics);
       function checkSignatureDeclarationDiagnostics() {
         checkCollisionWithArgumentsInGeneratedCode(node);
-        const returnTypeNode = getEffectiveReturnTypeNode(node);
+        let returnTypeNode = getEffectiveReturnTypeNode(node);
+        let returnTypeErrorLocation = returnTypeNode;
+        if (isInJSFile(node)) {
+          const typeTag = getJSDocTypeTag(node);
+          if (typeTag && typeTag.typeExpression && isTypeReferenceNode(typeTag.typeExpression.type)) {
+            const signature = getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression));
+            if (signature && signature.declaration) {
+              returnTypeNode = getEffectiveReturnTypeNode(signature.declaration);
+              returnTypeErrorLocation = typeTag.typeExpression.type;
+            }
+          }
+        }
         if (noImplicitAny && !returnTypeNode) {
           switch (node.kind) {
             case 180 /* ConstructSignature */:
@@ -77505,21 +77472,21 @@ ${lanes.join("\n")}
               break;
           }
         }
-        if (returnTypeNode) {
+        if (returnTypeNode && returnTypeErrorLocation) {
           const functionFlags2 = getFunctionFlags(node);
           if ((functionFlags2 & (4 /* Invalid */ | 1 /* Generator */)) === 1 /* Generator */) {
             const returnType = getTypeFromTypeNode(returnTypeNode);
             if (returnType === voidType) {
-              error2(returnTypeNode, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
+              error2(returnTypeErrorLocation, Diagnostics.A_generator_cannot_have_a_void_type_annotation);
             } else {
               const generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* Yield */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || anyType;
               const generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* Return */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || generatorYieldType;
               const generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* Next */, returnType, (functionFlags2 & 2 /* Async */) !== 0) || unknownType;
               const generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags2 & 2 /* Async */));
-              checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode);
+              checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeErrorLocation);
             }
           } else if ((functionFlags2 & 3 /* AsyncGenerator */) === 2 /* Async */) {
-            checkAsyncFunctionReturnType(node, returnTypeNode);
+            checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation);
           }
         }
         if (node.kind !== 181 /* IndexSignature */ && node.kind !== 324 /* JSDocFunctionType */) {
@@ -78601,7 +78568,7 @@ ${lanes.join("\n")}
       }
       return typeAsAwaitable.awaitedTypeOfType = type;
     }
-    function checkAsyncFunctionReturnType(node, returnTypeNode) {
+    function checkAsyncFunctionReturnType(node, returnTypeNode, returnTypeErrorLocation) {
       const returnType = getTypeFromTypeNode(returnTypeNode);
       if (languageVersion >= 2 /* ES2015 */) {
         if (isErrorType(returnType)) {
@@ -78612,7 +78579,7 @@ ${lanes.join("\n")}
           true
         );
         if (globalPromiseType !== emptyGenericType && !isReferenceToType2(returnType, globalPromiseType)) {
-          error2(returnTypeNode, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
+          reportErrorForInvalidReturnType(Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, returnTypeNode, returnTypeErrorLocation, typeToString(getAwaitedTypeNoAlias(returnType) || voidType));
           return;
         }
       } else {
@@ -78622,7 +78589,7 @@ ${lanes.join("\n")}
         }
         const promiseConstructorName = getEntityNameFromTypeNode(returnTypeNode);
         if (promiseConstructorName === void 0) {
-          error2(returnTypeNode, 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, typeToString(returnType));
+          reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, typeToString(returnType));
           return;
         }
         const promiseConstructorSymbol = resolveEntityName(
@@ -78637,9 +78604,9 @@ ${lanes.join("\n")}
             /*reportErrors*/
             false
           )) {
-            error2(returnTypeNode, 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);
+            error2(returnTypeErrorLocation, 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 {
-            error2(returnTypeNode, 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));
+            reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
           }
           return;
         }
@@ -78648,15 +78615,16 @@ ${lanes.join("\n")}
           true
         );
         if (globalPromiseConstructorLikeType === emptyObjectType) {
-          error2(returnTypeNode, 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));
+          reportErrorForInvalidReturnType(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, returnTypeNode, returnTypeErrorLocation, entityNameToString(promiseConstructorName));
           return;
         }
-        if (!checkTypeAssignableTo(
-          promiseConstructorType,
-          globalPromiseConstructorLikeType,
-          returnTypeNode,
-          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
-        )) {
+        const headMessage = 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;
+        const errorInfo = () => returnTypeNode === returnTypeErrorLocation ? void 0 : chainDiagnosticMessages(
+          /*details*/
+          void 0,
+          Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type
+        );
+        if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeErrorLocation, headMessage, errorInfo)) {
           return;
         }
         const rootName = promiseConstructorName && getFirstIdentifier(promiseConstructorName);
@@ -78678,6 +78646,14 @@ ${lanes.join("\n")}
         node,
         Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
       );
+      function reportErrorForInvalidReturnType(message, returnTypeNode2, returnTypeErrorLocation2, typeName) {
+        if (returnTypeNode2 === returnTypeErrorLocation2) {
+          error2(returnTypeErrorLocation2, message, typeName);
+        } else {
+          const diag2 = error2(returnTypeErrorLocation2, Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type);
+          addRelatedInfo(diag2, createDiagnosticForNode(returnTypeNode2, message, typeName));
+        }
+      }
     }
     function checkDecorator(node) {
       const signature = getResolvedSignature(node);

package/lib/typingsInstaller.js CHANGED Viewed

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-insiders.20230725`;
+var version = `${versionMajorMinor}.0-insiders.20230726`;
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5138,6 +5138,7 @@ var Diagnostics = {
   Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, 1 /* Error */, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."),
   An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, 1 /* Error */, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."),
   The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{0}>'?"),
+  The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1065, 1 /* Error */, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1065", "The return type of an async function or method must be the global Promise<T> type."),
   In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, 1 /* Error */, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."),
   Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, 1 /* Error */, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."),
   Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, 1 /* Error */, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."),

package/package.json CHANGED Viewed

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.2.0-pr-52095-16",
+  "version": "5.2.0-pr-55152-2",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -114,5 +114,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "50adcbc61a52891e41529278e8225593f95a63ff"
+  "gitHead": "4e746373c1770c712d9801932e5188ab7bc6447e"
 }