@typescript-deploys/pr-build 5.1.0-pr-53098-13 → 5.1.0-pr-50951-3

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.20230310`;
+var version = `${versionMajorMinor}.0-insiders.20230313`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -1306,7 +1306,7 @@ function trimEndImpl(s) {
   return s.slice(0, end + 1);
 }
 function isNodeLikeSystem() {
-  return typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object";
+  return typeof process !== "undefined" && !!process.nextTick && !process.browser && typeof module === "object";
 }
 
 // src/compiler/debug.ts
@@ -4914,7 +4914,7 @@ var sys = (() => {
       getAccessibleSortedChildDirectories: (path) => getAccessibleFileSystemEntries(path).directories,
       realpath,
       tscWatchFile: process.env.TSC_WATCHFILE,
-      useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER,
+      useNonPollingWatchers: !!process.env.TSC_NONPOLLING_WATCHER,
       tscWatchDirectory: process.env.TSC_WATCHDIRECTORY,
       inodeWatching: isLinuxOrMacOs,
       sysLog
@@ -5000,8 +5000,10 @@ var sys = (() => {
         process.stdout.write("\x1Bc");
       },
       setBlocking: () => {
-        if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) {
-          process.stdout._handle.setBlocking(true);
+        var _a2;
+        const handle = (_a2 = process.stdout) == null ? void 0 : _a2._handle;
+        if (handle && handle.setBlocking) {
+          handle.setBlocking(true);
         }
       },
       bufferFrom,
@@ -10279,32 +10281,36 @@ function getModifiers(node) {
     return filter(node.modifiers, isModifier);
   }
 }
-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]];
-      }
+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]];
     }
   }
   return emptyArray;
 }
-function getJSDocParameterTags(param) {
+function getJSDocParameterTags(node) {
   return getJSDocParameterTagsWorker(
-    param,
+    node,
     /*noCache*/
     false
   );
 }
-function getJSDocParameterTagsNoCache(param) {
+function getJSDocParameterTagsNoCache(node) {
   return getJSDocParameterTagsWorker(
-    param,
+    node,
     /*noCache*/
     true
   );
@@ -13732,7 +13738,7 @@ function getJSDocCommentsAndTags(hostNode, noCache) {
     if (hasJSDocNodes(node)) {
       result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
     }
-    if (node.kind === 167 /* Parameter */) {
+    if (node.kind === 167 /* Parameter */ || node.kind === 206 /* BindingElement */) {
       result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
       break;
     }
@@ -36574,6 +36580,10 @@ function getOriginalAndResolvedFileName(fileName, host, traceEnabled) {
     originalPath: pathsAreEqual ? void 0 : fileName
   };
 }
+function getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState) {
+  const nameForLookup = endsWith(typeRoot, "/node_modules/@types") || endsWith(typeRoot, "/node_modules/@types/") ? mangleScopedPackageNameWithTrace(typeReferenceDirectiveName, moduleResolutionState) : typeReferenceDirectiveName;
+  return combinePaths(typeRoot, nameForLookup);
+}
 function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) {
   Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");
   const traceEnabled = isTraceEnabled(options, host);
@@ -36692,7 +36702,7 @@ function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFil
         trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
       }
       return firstDefined(typeRoots, (typeRoot) => {
-        const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
+        const candidate = getCandidateFromTypeRoot(typeRoot, typeReferenceDirectiveName, moduleResolutionState);
         const directoryExists = directoryProbablyExists(typeRoot, host);
         if (!directoryExists && traceEnabled) {
           trace(host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
@@ -38678,7 +38688,7 @@ function resolveFromTypeRoot(moduleName, state) {
   if (!state.compilerOptions.typeRoots)
     return;
   for (const typeRoot of state.compilerOptions.typeRoots) {
-    const candidate = combinePaths(typeRoot, moduleName);
+    const candidate = getCandidateFromTypeRoot(typeRoot, moduleName, state);
     const directoryExists = directoryProbablyExists(typeRoot, state.host);
     if (!directoryExists && state.traceEnabled) {
       trace(state.host, Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, typeRoot);
@@ -42675,7 +42685,6 @@ 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();
@@ -53944,13 +53953,6 @@ 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);
@@ -56320,10 +56322,10 @@ function createTypeChecker(host) {
     }
     return links.resolvedType;
   }
-  function createIndexType(type, indexFlags) {
+  function createIndexType(type, stringsOnly) {
     const result = createType(4194304 /* Index */);
     result.type = type;
-    result.indexFlags = indexFlags;
+    result.stringsOnly = stringsOnly;
     return result;
   }
   function createOriginIndexType(type) {
@@ -56331,23 +56333,31 @@ function createTypeChecker(host) {
     result.type = type;
     return result;
   }
-  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 getIndexTypeForGenericType(type, stringsOnly) {
+    return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(
+      type,
+      /*stringsOnly*/
+      true
+    )) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(
+      type,
+      /*stringsOnly*/
+      false
+    ));
   }
-  function getIndexTypeForMappedType(type, indexFlags) {
+  function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
     const typeParameter = getTypeParameterFromMappedType(type);
     const constraintType = getConstraintTypeFromMappedType(type);
     const nameType = getNameTypeFromMappedType(type.target || type);
-    if (!nameType && !(indexFlags & 2 /* NoIndexSignatures */)) {
+    if (!nameType && !noIndexSignatures) {
       return constraintType;
     }
     const keyTypes = [];
     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
       if (!isGenericIndexType(constraintType)) {
         const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
+        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
       } else {
-        return getIndexTypeForGenericType(type, indexFlags);
+        return getIndexTypeForGenericType(type, stringsOnly);
       }
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
@@ -56355,7 +56365,7 @@ function createTypeChecker(host) {
     if (isGenericIndexType(constraintType)) {
       forEachType(constraintType, addMemberForKeyType);
     }
-    const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
+    const result = 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;
     }
@@ -56408,15 +56418,19 @@ function createTypeChecker(host) {
       origin
     );
   }
-  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 isPossiblyReducibleByInstantiation(type) {
+    const uniqueFilled = getUniqueLiteralFilledInstantiation(type);
+    return getReducedType(uniqueFilled) !== uniqueFilled;
   }
-  function getIndexType(type, indexFlags = defaultIndexFlags) {
+  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 getIndexType(type, stringsOnly = keyofStringsOnly, noIndexSignatures) {
     type = getReducedType(type);
-    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(
+    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(
       type,
-      (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
-      indexFlags === defaultIndexFlags
+      (noIndexSignatures ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (stringsOnly ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
+      stringsOnly === keyofStringsOnly && !noIndexSignatures
     );
   }
   function getExtractStringType(type) {
@@ -56956,13 +56970,12 @@ 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)) || isGenericReducibleType(objectType))) {
+    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 (objectType.flags & 3 /* AnyOrUnknown */) {
         return objectType;
       }
@@ -58148,6 +58161,9 @@ 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));
   }
@@ -58639,20 +58655,8 @@ function createTypeChecker(host) {
         return result;
       }
       const moreThanOneRealChildren = length(validChildren) > 1;
-      let arrayLikeTargetParts;
-      let nonArrayLikeTargetParts;
-      const iterableType = getGlobalIterableType(
-        /*reportErrors*/
-        false
-      );
-      if (iterableType !== emptyGenericType) {
-        const anyIterable = createIterableType(anyType);
-        arrayLikeTargetParts = filterType(childrenTargetType, (t) => isTypeAssignableTo(t, anyIterable));
-        nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isTypeAssignableTo(t, anyIterable));
-      } else {
-        arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType);
-        nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isArrayOrTupleLikeType(t));
-      }
+      const arrayLikeTargetParts = filterType(childrenTargetType, isAssignableToAvailableAnyIterable);
+      const nonArrayLikeTargetParts = filterType(childrenTargetType, (t) => !isAssignableToAvailableAnyIterable(t));
       if (moreThanOneRealChildren) {
         if (arrayLikeTargetParts !== neverType) {
           const realSource = createTupleType(checkJsxChildren(containingElement, 0 /* Normal */));
@@ -60342,7 +60346,7 @@ function createTypeChecker(host) {
         } else {
           const constraint = getSimplifiedTypeOrConstraint(targetType);
           if (constraint) {
-            if (isRelatedTo(source2, getIndexType(constraint, target2.indexFlags | 4 /* NoReducibleCheck */), 2 /* Target */, reportErrors2) === -1 /* True */) {
+            if (isRelatedTo(source2, getIndexType(constraint, target2.stringsOnly), 2 /* Target */, reportErrors2) === -1 /* True */) {
               return -1 /* True */;
             }
           } else if (isGenericMappedType(targetType)) {
@@ -60423,7 +60427,13 @@ function createTypeChecker(host) {
           }
           if (!isGenericMappedType(source2)) {
             const targetKeys = keysRemapped ? getNameTypeFromMappedType(target2) : getConstraintTypeFromMappedType(target2);
-            const sourceKeys = getIndexType(source2, 2 /* NoIndexSignatures */);
+            const sourceKeys = getIndexType(
+              source2,
+              /*stringsOnly*/
+              void 0,
+              /*noIndexSignatures*/
+              true
+            );
             const includeOptional = modifiers & 4 /* IncludeOptional */;
             const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
             if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
@@ -61932,6 +61942,13 @@ function createTypeChecker(host) {
   function isArrayOrTupleLikeType(type) {
     return isArrayLikeType(type) || isTupleLikeType(type);
   }
+  function isAssignableToAvailableAnyIterable(type) {
+    const anyIterable = getGlobalIterableType(
+      /*reportErrors*/
+      false
+    ) !== emptyGenericType && createIterableType(anyType);
+    return anyIterable ? isTypeAssignableTo(type, anyIterable) : isArrayOrTupleLikeType(type);
+  }
   function getTupleElementType(type, index) {
     const propType = getTypeOfPropertyOfType(type, "" + index);
     if (propType) {
@@ -66685,7 +66702,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function getContextualTypeForElementExpression(arrayContextualType, index) {
-    return arrayContextualType && (index >= 0 && getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
+    return arrayContextualType && (index >= 0 && getTypeOfPropertyOfContextualType(filterType(arrayContextualType, (t) => !!getIndexTypeOfType(t, numberType) || isAssignableToAvailableAnyIterable(t)), "" + index) || mapType(
       arrayContextualType,
       (t) => isTupleType(t) ? getElementTypeOfSliceOfTupleType(
         t,
@@ -74656,7 +74673,11 @@ function createTypeChecker(host) {
     }
     const objectType = type.objectType;
     const indexType = type.indexType;
-    if (isTypeAssignableTo(indexType, getIndexType(objectType, 0 /* None */))) {
+    if (isTypeAssignableTo(indexType, getIndexType(
+      objectType,
+      /*stringsOnly*/
+      false
+    ))) {
       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));
       }