@typescript-deploys/pr-build 5.1.0-pr-50951-3 → 5.1.0-pr-53258-7

package/README.md

@@ -17,13 +17,13 @@ Find others who are using TypeScript at [our community page](https://www.typescr
 For the latest stable version:
 
 ```bash
-npm install -g typescript
+npm install -D typescript
 ```
 
 For our nightly builds:
 
 ```bash
-npm install -g typescript@next
+npm install -D typescript@next
 ```
 
 ## Contribute

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230313`;
+var version = `${versionMajorMinor}.0-insiders.20230314`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -5935,6 +5935,7 @@ var Diagnostics = {
   Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."),
   Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."),
   Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."),
+  Abstract_properties_can_only_appear_within_an_abstract_class: diag(1253, 1 /* Error */, "Abstract_properties_can_only_appear_within_an_abstract_class_1253", "Abstract properties can only appear within an abstract class."),
   A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, 1 /* Error */, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."),
   A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, 1 /* Error */, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."),
   A_required_element_cannot_follow_an_optional_element: diag(1257, 1 /* Error */, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."),
@@ -10281,36 +10282,32 @@ function getModifiers(node) {
     return filter(node.modifiers, isModifier);
   }
 }
-function getJSDocParameterTagsWorker(node, noCache) {
-  const declaration = getRootDeclaration(node);
-  if (isParameter(declaration)) {
-    const name = node.name;
-    const signatureDeclaration = declaration.parent;
-    const jsDocParameterTags = filter(getJSDocTagsWorker(signatureDeclaration, noCache), isJSDocParameterTag);
-    if (length(jsDocParameterTags) === 0) {
-      return emptyArray;
-    }
-    if (isIdentifier(name)) {
-      return filter(jsDocParameterTags, (tag) => isIdentifier(tag.name) && tag.name.escapedText === name.escapedText);
-    }
-    const i = signatureDeclaration.parameters.indexOf(declaration);
-    Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
-    if (i < length(jsDocParameterTags)) {
-      return [jsDocParameterTags[i]];
+function getJSDocParameterTagsWorker(param, noCache) {
+  if (param.name) {
+    if (isIdentifier(param.name)) {
+      const name = param.name.escapedText;
+      return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);
+    } else {
+      const i = param.parent.parameters.indexOf(param);
+      Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
+      const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);
+      if (i < paramTags.length) {
+        return [paramTags[i]];
+      }
     }
   }
   return emptyArray;
 }
-function getJSDocParameterTags(node) {
+function getJSDocParameterTags(param) {
   return getJSDocParameterTagsWorker(
-    node,
+    param,
     /*noCache*/
     false
   );
 }
-function getJSDocParameterTagsNoCache(node) {
+function getJSDocParameterTagsNoCache(param) {
   return getJSDocParameterTagsWorker(
-    node,
+    param,
     /*noCache*/
     true
   );
@@ -13738,7 +13735,7 @@ function getJSDocCommentsAndTags(hostNode, noCache) {
     if (hasJSDocNodes(node)) {
       result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
     }
-    if (node.kind === 167 /* Parameter */ || node.kind === 206 /* BindingElement */) {
+    if (node.kind === 167 /* Parameter */) {
       result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
       break;
     }
@@ -42685,6 +42682,7 @@ function createTypeChecker(host) {
   var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
   var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
+  var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
   var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
   var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
   var checkBinaryExpression = createCheckBinaryExpression();
@@ -53953,6 +53951,13 @@ function createTypeChecker(host) {
   function isConflictingPrivateProperty(prop) {
     return !prop.valueDeclaration && !!(getCheckFlags(prop) & 1024 /* ContainsPrivate */);
   }
+  function isGenericReducibleType(type) {
+    return !!(type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */ && some(type.types, isGenericReducibleType) || type.flags & 2097152 /* Intersection */ && isReducibleIntersection(type));
+  }
+  function isReducibleIntersection(type) {
+    const uniqueFilled = type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
+    return getReducedType(uniqueFilled) !== uniqueFilled;
+  }
   function elaborateNeverIntersection(errorInfo, type) {
     if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 33554432 /* IsNeverIntersection */) {
       const neverProp = find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
@@ -56322,10 +56327,10 @@ function createTypeChecker(host) {
     }
     return links.resolvedType;
   }
-  function createIndexType(type, stringsOnly) {
+  function createIndexType(type, indexFlags) {
     const result = createType(4194304 /* Index */);
     result.type = type;
-    result.stringsOnly = stringsOnly;
+    result.indexFlags = indexFlags;
     return result;
   }
   function createOriginIndexType(type) {
@@ -56333,31 +56338,23 @@ function createTypeChecker(host) {
     result.type = type;
     return result;
   }
-  function getIndexTypeForGenericType(type, stringsOnly) {
-    return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(
-      type,
-      /*stringsOnly*/
-      true
-    )) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(
-      type,
-      /*stringsOnly*/
-      false
-    ));
+  function getIndexTypeForGenericType(type, indexFlags) {
+    return indexFlags & 1 /* StringsOnly */ ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, 1 /* StringsOnly */)) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, 0 /* None */));
   }
-  function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
+  function getIndexTypeForMappedType(type, indexFlags) {
     const typeParameter = getTypeParameterFromMappedType(type);
     const constraintType = getConstraintTypeFromMappedType(type);
     const nameType = getNameTypeFromMappedType(type.target || type);
-    if (!nameType && !noIndexSignatures) {
+    if (!nameType && !(indexFlags & 2 /* NoIndexSignatures */)) {
       return constraintType;
     }
     const keyTypes = [];
     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
       if (!isGenericIndexType(constraintType)) {
         const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
+        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
       } else {
-        return getIndexTypeForGenericType(type, stringsOnly);
+        return getIndexTypeForGenericType(type, indexFlags);
       }
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
@@ -56365,7 +56362,7 @@ function createTypeChecker(host) {
     if (isGenericIndexType(constraintType)) {
       forEachType(constraintType, addMemberForKeyType);
     }
-    const result = noIndexSignatures ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
+    const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
     if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
       return constraintType;
     }
@@ -56418,19 +56415,15 @@ function createTypeChecker(host) {
       origin
     );
   }
-  function isPossiblyReducibleByInstantiation(type) {
-    const uniqueFilled = getUniqueLiteralFilledInstantiation(type);
-    return getReducedType(uniqueFilled) !== uniqueFilled;
-  }
-  function shouldDeferIndexType(type) {
-    return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && some(type.types, isPossiblyReducibleByInstantiation) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
+  function shouldDeferIndexType(type, indexFlags = 0 /* None */) {
+    return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && !(indexFlags & 4 /* NoReducibleCheck */) && isGenericReducibleType(type) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
   }
-  function getIndexType(type, stringsOnly = keyofStringsOnly, noIndexSignatures) {
+  function getIndexType(type, indexFlags = defaultIndexFlags) {
     type = getReducedType(type);
-    return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
+    return shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
       type,
-      (noIndexSignatures ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (stringsOnly ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
-      stringsOnly === keyofStringsOnly && !noIndexSignatures
+      (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
+      indexFlags === defaultIndexFlags
     );
   }
   function getExtractStringType(type) {
@@ -56970,12 +56963,13 @@ function createTypeChecker(host) {
     if (objectType === wildcardType || indexType === wildcardType) {
       return wildcardType;
     }
+    objectType = getReducedType(objectType);
     if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
       indexType = stringType;
     }
     if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */)
       accessFlags |= 1 /* IncludeUndefined */;
-    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 197 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) {
+    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 197 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)) || isGenericReducibleType(objectType))) {
       if (objectType.flags & 3 /* AnyOrUnknown */) {
         return objectType;
       }
@@ -58161,9 +58155,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function getUniqueLiteralFilledInstantiation(type) {
-    return type.flags & (402784252 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
-  }
   function getPermissiveInstantiation(type) {
     return type.flags & (402784252 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
   }
@@ -58875,7 +58866,12 @@ function createTypeChecker(host) {
     const paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
-      const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
+      const sourceType = i === restIndex ? getRestTypeAtPosition(
+        source,
+        i,
+        /*readonly*/
+        true
+      ) : tryGetTypeAtPosition(source, i);
       const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
@@ -60346,7 +60342,7 @@ function createTypeChecker(host) {
         } else {
           const constraint = getSimplifiedTypeOrConstraint(targetType);
           if (constraint) {
-            if (isRelatedTo(source2, getIndexType(constraint, target2.stringsOnly), 2 /* Target */, reportErrors2) === -1 /* True */) {
+            if (isRelatedTo(source2, getIndexType(constraint, target2.indexFlags | 4 /* NoReducibleCheck */), 2 /* Target */, reportErrors2) === -1 /* True */) {
               return -1 /* True */;
             }
           } else if (isGenericMappedType(targetType)) {
@@ -60427,13 +60423,7 @@ function createTypeChecker(host) {
           }
           if (!isGenericMappedType(source2)) {
             const targetKeys = keysRemapped ? getNameTypeFromMappedType(target2) : getConstraintTypeFromMappedType(target2);
-            const sourceKeys = getIndexType(
-              source2,
-              /*stringsOnly*/
-              void 0,
-              /*noIndexSignatures*/
-              true
-            );
+            const sourceKeys = getIndexType(source2, 2 /* NoIndexSignatures */);
             const includeOptional = modifiers & 4 /* IncludeOptional */;
             const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
             if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
@@ -71366,12 +71356,12 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getRestTypeAtPosition(source, pos) {
+  function getRestTypeAtPosition(source, pos, readonly = false) {
     const parameterCount = getParameterCount(source);
     const minArgumentCount = getMinArgumentCount(source);
     const restType = getEffectiveRestType(source);
     if (restType && pos >= parameterCount - 1) {
-      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
+      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType), readonly);
     }
     const types = [];
     const flags = [];
@@ -71389,13 +71379,7 @@ function createTypeChecker(host) {
         names.push(name);
       }
     }
-    return createTupleType(
-      types,
-      flags,
-      /*readonly*/
-      false,
-      length(names) === length(types) ? names : void 0
-    );
+    return createTupleType(types, flags, readonly, length(names) === length(types) ? names : void 0);
   }
   function getParameterCount(signature) {
     const length2 = signature.parameters.length;
@@ -74673,11 +74657,7 @@ function createTypeChecker(host) {
     }
     const objectType = type.objectType;
     const indexType = type.indexType;
-    if (isTypeAssignableTo(indexType, getIndexType(
-      objectType,
-      /*stringsOnly*/
-      false
-    ))) {
+    if (isTypeAssignableTo(indexType, getIndexType(objectType, 0 /* None */))) {
       if (accessNode.kind === 210 /* ElementAccessExpression */ && isAssignmentTarget(accessNode) && getObjectFlags(objectType) & 32 /* Mapped */ && getMappedTypeModifiers(objectType) & 1 /* IncludeReadonly */) {
         error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
       }
@@ -81497,7 +81477,8 @@ function createTypeChecker(host) {
                 return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
               }
               if (!(node.parent.kind === 261 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 256 /* Abstract */))) {
-                return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
+                const message = node.kind === 170 /* PropertyDeclaration */ ? Diagnostics.Abstract_properties_can_only_appear_within_an_abstract_class : Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class;
+                return grammarErrorOnNode(modifier, message);
               }
               if (flags & 32 /* Static */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");