@typescript-deploys/pr-build 5.2.0-pr-52095-16 → 5.2.0-pr-54753-25

package/lib/tsc.js

@@ -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."),
@@ -53913,7 +53914,12 @@ function createTypeChecker(host) {
       for (const current of type.types) {
         for (const prop of getPropertiesOfType(current)) {
           if (!members.has(prop.escapedName)) {
-            const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
+            const combinedProp = getPropertyOfUnionOrIntersectionType(
+              type,
+              prop.escapedName,
+              /*skipObjectFunctionPropertyAugment*/
+              !!(type.flags & 2097152 /* Intersection */)
+            );
             if (combinedProp) {
               members.set(prop.escapedName, combinedProp);
             }
@@ -54393,13 +54399,17 @@ function createTypeChecker(host) {
     return result;
   }
   function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
-    var _a, _b;
+    var _a, _b, _c;
     let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
     if (!property) {
       property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
       if (property) {
         const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
         properties.set(name, property);
+        if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+          const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
+          properties2.set(name, property);
+        }
       }
     }
     return property;
@@ -54519,7 +54529,22 @@ function createTypeChecker(host) {
       }
       return getPropertyOfObjectType(globalObjectType, name);
     }
-    if (type.flags & 3145728 /* UnionOrIntersection */) {
+    if (type.flags & 2097152 /* Intersection */) {
+      const prop = getPropertyOfUnionOrIntersectionType(
+        type,
+        name,
+        /*skipObjectFunctionPropertyAugment*/
+        true
+      );
+      if (prop) {
+        return prop;
+      }
+      if (!skipObjectFunctionPropertyAugment) {
+        return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
+      }
+      return void 0;
+    }
+    if (type.flags & 1048576 /* Union */) {
       return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
     }
     return void 0;
@@ -61158,26 +61183,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 +67277,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 +74991,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 +75013,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 +76109,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 +76120,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 +76130,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 +76145,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 +76156,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 +76187,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);