@typescript-deploys/pr-build 5.4.0-pr-56908-56 → 5.4.0-pr-49218-45

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20240108`;
+var version = `${versionMajorMinor}.0-insiders.20240110`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -12673,7 +12673,7 @@ function isPartOfTypeNode(node) {
     case 116 /* VoidKeyword */:
       return node.parent.kind !== 222 /* VoidExpression */;
     case 233 /* ExpressionWithTypeArguments */:
-      return isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+      return isPartOfTypeExpressionWithTypeArguments(node);
     case 168 /* TypeParameter */:
       return node.parent.kind === 200 /* MappedType */ || node.parent.kind === 195 /* InferType */;
     case 80 /* Identifier */:
@@ -12698,7 +12698,7 @@ function isPartOfTypeNode(node) {
       }
       switch (parent.kind) {
         case 233 /* ExpressionWithTypeArguments */:
-          return isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
+          return isPartOfTypeExpressionWithTypeArguments(parent);
         case 168 /* TypeParameter */:
           return node === parent.constraint;
         case 352 /* JSDocTemplateTag */:
@@ -12732,6 +12732,9 @@ function isPartOfTypeNode(node) {
   }
   return false;
 }
+function isPartOfTypeExpressionWithTypeArguments(node) {
+  return isJSDocImplementsTag(node.parent) || isJSDocAugmentsTag(node.parent) || isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
+}
 function forEachReturnStatement(body, visitor) {
   return traverse(body);
   function traverse(node) {
@@ -17492,6 +17495,9 @@ function hasContextSensitiveParameters(node) {
 function isInfinityOrNaNString(name) {
   return name === "Infinity" || name === "-Infinity" || name === "NaN";
 }
+function isCatchClauseVariableDeclaration(node) {
+  return node.kind === 260 /* VariableDeclaration */ && node.parent.kind === 299 /* CatchClause */;
+}
 function isFunctionExpressionOrArrowFunction(node) {
   return node.kind === 218 /* FunctionExpression */ || node.kind === 219 /* ArrowFunction */;
 }
@@ -44278,6 +44284,14 @@ function createTypeChecker(host) {
     emptyArray,
     emptyArray
   );
+  var resolvingApparentMappedType = createAnonymousType(
+    /*symbol*/
+    void 0,
+    emptySymbols,
+    emptyArray,
+    emptyArray,
+    emptyArray
+  );
   var markerSuperType = createTypeParameter();
   var markerSubType = createTypeParameter();
   markerSubType.constraint = markerSuperType;
@@ -47327,29 +47341,7 @@ function createTypeChecker(host) {
   function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) {
     const container = getParentOfSymbol(symbol);
     if (container && !(symbol.flags & 262144 /* TypeParameter */)) {
-      const additionalContainers = mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
-      const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
-      const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning);
-      if (enclosingDeclaration && container.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(
-        container,
-        enclosingDeclaration,
-        1920 /* Namespace */,
-        /*useOnlyExternalAliasing*/
-        false
-      )) {
-        return append(concatenate(concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer);
-      }
-      const firstVariableMatch = !(container.flags & getQualifiedLeftMeaning(meaning)) && container.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
-        return forEachEntry(t, (s) => {
-          if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container)) {
-            return s;
-          }
-        });
-      }) : void 0;
-      let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container] : [...additionalContainers, container];
-      res = append(res, objectLiteralContainer);
-      res = addRange(res, reexportContainers);
-      return res;
+      return getWithAlternativeContainers(container);
     }
     const candidates = mapDefined(symbol.declarations, (d) => {
       if (!isAmbientModule(d) && d.parent) {
@@ -47371,7 +47363,40 @@ function createTypeChecker(host) {
     if (!length(candidates)) {
       return void 0;
     }
-    return mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
+    const containers = mapDefined(candidates, (candidate) => getAliasForSymbolInContainer(candidate, symbol) ? candidate : void 0);
+    let bestContainers = [];
+    let alternativeContainers = [];
+    for (const container2 of containers) {
+      const [bestMatch, ...rest] = getWithAlternativeContainers(container2);
+      bestContainers = append(bestContainers, bestMatch);
+      alternativeContainers = addRange(alternativeContainers, rest);
+    }
+    return concatenate(bestContainers, alternativeContainers);
+    function getWithAlternativeContainers(container2) {
+      const additionalContainers = mapDefined(container2.declarations, fileSymbolIfFileSymbolExportEqualsContainer);
+      const reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration);
+      const objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container2, meaning);
+      if (enclosingDeclaration && container2.flags & getQualifiedLeftMeaning(meaning) && getAccessibleSymbolChain(
+        container2,
+        enclosingDeclaration,
+        1920 /* Namespace */,
+        /*useOnlyExternalAliasing*/
+        false
+      )) {
+        return append(concatenate(concatenate([container2], additionalContainers), reexportContainers), objectLiteralContainer);
+      }
+      const firstVariableMatch = !(container2.flags & getQualifiedLeftMeaning(meaning)) && container2.flags & 788968 /* Type */ && getDeclaredTypeOfSymbol(container2).flags & 524288 /* Object */ && meaning === 111551 /* Value */ ? forEachSymbolTableInScope(enclosingDeclaration, (t) => {
+        return forEachEntry(t, (s) => {
+          if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container2)) {
+            return s;
+          }
+        });
+      }) : void 0;
+      let res = firstVariableMatch ? [firstVariableMatch, ...additionalContainers, container2] : [...additionalContainers, container2];
+      res = append(res, objectLiteralContainer);
+      res = addRange(res, reexportContainers);
+      return res;
+    }
     function fileSymbolIfFileSymbolExportEqualsContainer(d) {
       return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container);
     }
@@ -47409,6 +47434,13 @@ function createTypeChecker(host) {
     });
   }
   function getSymbolIfSameReference(s1, s2) {
+    var _a, _b;
+    if (s1.flags & 524288 /* TypeAlias */ && ((_a = s2.declarations) == null ? void 0 : _a.find(isTypeAlias))) {
+      s2 = getDeclaredTypeOfTypeAlias(s2).aliasSymbol || s2;
+    }
+    if (s2.flags & 524288 /* TypeAlias */ && ((_b = s1.declarations) == null ? void 0 : _b.find(isTypeAlias))) {
+      s1 = getDeclaredTypeOfTypeAlias(s1).aliasSymbol || s1;
+    }
     if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) {
       return s1;
     }
@@ -55147,14 +55179,30 @@ function createTypeChecker(host) {
     return !!(typeParameter.symbol && forEach(typeParameter.symbol.declarations, (decl) => isTypeParameterDeclaration(decl) && decl.default));
   }
   function getApparentTypeOfMappedType(type) {
-    return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type));
+    if (type.resolvedApparentType) {
+      if (type.resolvedApparentType === resolvingApparentMappedType) {
+        return type.resolvedApparentType = type;
+      }
+      return type.resolvedApparentType;
+    }
+    type.resolvedApparentType = resolvingApparentMappedType;
+    return type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type);
   }
   function getResolvedApparentTypeOfMappedType(type) {
-    const typeVariable = getHomomorphicTypeVariable(type);
-    if (typeVariable && !type.declaration.nameType) {
-      const constraint = getConstraintOfTypeParameter(typeVariable);
+    const mappedType = type.target || type;
+    const typeVariable = getHomomorphicTypeVariable(mappedType);
+    if (typeVariable && !mappedType.declaration.nameType) {
+      let constraint;
+      if (!type.target) {
+        constraint = getConstraintOfTypeParameter(typeVariable);
+      } else {
+        const modifiersConstraint = getConstraintOfType(getModifiersTypeFromMappedType(type));
+        if (modifiersConstraint) {
+          constraint = getApparentType(modifiersConstraint);
+        }
+      }
       if (constraint && everyType(constraint, isArrayOrTupleType)) {
-        return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
+        return instantiateType(mappedType, prependTypeMapping(typeVariable, constraint, mappedType.mapper));
       }
     }
     return type;
@@ -55245,6 +55293,7 @@ function createTypeChecker(host) {
         clone2.parent = (_c = (_b = singleProp.valueDeclaration) == null ? void 0 : _b.symbol) == null ? void 0 : _c.parent;
         clone2.links.containingType = containingType;
         clone2.links.mapper = links == null ? void 0 : links.mapper;
+        clone2.links.writeType = getWriteTypeOfSymbol(singleProp);
         return clone2;
       } else {
         return singleProp;
@@ -60480,7 +60529,37 @@ function createTypeChecker(host) {
     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 targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
+      let targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
+      if (i === restIndex && targetType && sourceType && isTupleType(sourceType)) {
+        targetType = mapType(targetType, (t) => {
+          if (!isTupleType(t) || // When both sides are tuples of the same structure, we don't want to "propagate" types from elements of variable positions
+          // to the following positions as that would disallow signatures of the exact same structures when trailing fixed elements are involved:
+          //
+          // let fn: (...rest: [...string[], number]) => void = (...rest: [...string[], number]) => {}; // ok
+          //
+          // Since we want to allow contextual types to flow into paremeters, we don't need to differentiate between rest and variadic elements
+          // as that doesn't affect the contextual type of the parameter
+          isTupleTypeStructureMatching(sourceType, t, 2 /* MatchVariable */)) {
+            return t;
+          }
+          const elementTypes = [];
+          const elementFlags = [];
+          const sourceArity = getTypeReferenceArity(sourceType);
+          const targetArity = getTypeReferenceArity(t);
+          for (let i2 = 0; i2 < sourceArity; i2++) {
+            if (i2 >= targetArity) {
+              if (sourceType.target.elementFlags[i2] & 3 /* Fixed */) {
+                elementTypes.push(undefinedType);
+                elementFlags.push(sourceType.target.elementFlags[i2]);
+              }
+              continue;
+            }
+            elementTypes.push(getTupleElementType(t, i2));
+            elementFlags.push(sourceType.target.elementFlags[i2]);
+          }
+          return createTupleType(elementTypes, elementFlags);
+        });
+      }
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(source, i) ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
         const targetSig = checkMode & 3 /* Callback */ || isInstantiatedGenericParameter(target, i) ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
@@ -61870,6 +61949,18 @@ function createTypeChecker(host) {
       }
       return result2;
     }
+    function getApparentMappedTypeKeys(nameType, targetType) {
+      const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
+      const mappedKeys = [];
+      forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
+        modifiersType,
+        8576 /* StringOrNumberLiteralOrUnique */,
+        /*stringsOnly*/
+        false,
+        (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
+      );
+      return getUnionType(mappedKeys);
+    }
     function structuredTypeRelatedToWorker(source2, target2, reportErrors2, intersectionState, saveErrorInfo) {
       let result2;
       let originalErrorInfo;
@@ -62052,16 +62143,8 @@ function createTypeChecker(host) {
             const constraintType = getConstraintTypeFromMappedType(targetType);
             let targetKeys;
             if (nameType && isMappedTypeWithKeyofConstraintDeclaration(targetType)) {
-              const modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType));
-              const mappedKeys = [];
-              forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(
-                modifiersType,
-                8576 /* StringOrNumberLiteralOrUnique */,
-                /*stringsOnly*/
-                false,
-                (t) => void mappedKeys.push(instantiateType(nameType, appendTypeMapping(targetType.mapper, getTypeParameterFromMappedType(targetType), t)))
-              );
-              targetKeys = getUnionType([...mappedKeys, nameType]);
+              const mappedKeys = getApparentMappedTypeKeys(nameType, targetType);
+              targetKeys = getUnionType([mappedKeys, nameType]);
             } else {
               targetKeys = nameType || constraintType;
             }
@@ -62232,9 +62315,18 @@ function createTypeChecker(host) {
           }
         }
       } else if (sourceFlags & 4194304 /* Index */) {
-        if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2)) {
+        const isDeferredMappedIndex = shouldDeferIndexType(source2.type, source2.indexFlags) && getObjectFlags(source2.type) & 32 /* Mapped */;
+        if (result2 = isRelatedTo(keyofConstraintType, target2, 1 /* Source */, reportErrors2 && !isDeferredMappedIndex)) {
           return result2;
         }
+        if (isDeferredMappedIndex) {
+          const mappedType = source2.type;
+          const nameType = getNameTypeFromMappedType(mappedType);
+          const sourceMappedKeys = nameType && isMappedTypeWithKeyofConstraintDeclaration(mappedType) ? getApparentMappedTypeKeys(nameType, mappedType) : nameType || getConstraintTypeFromMappedType(mappedType);
+          if (result2 = isRelatedTo(sourceMappedKeys, target2, 1 /* Source */, reportErrors2)) {
+            return result2;
+          }
+        }
       } else if (sourceFlags & 134217728 /* TemplateLiteral */ && !(targetFlags & 524288 /* Object */)) {
         if (!(targetFlags & 134217728 /* TemplateLiteral */)) {
           const constraint = getBaseConstraintOfType(source2);
@@ -63724,8 +63816,11 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function isTupleTypeStructureMatching(t1, t2) {
-    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
+  function isTupleTypeStructureMatching(t1, t2, tupleStructureComparisonKind) {
+    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f1, i) => {
+      const f2 = t2.target.elementFlags[i];
+      return f1 === f2 || !!(tupleStructureComparisonKind & 1 /* MatchFixed */ && f1 & 3 /* Fixed */ && f2 & 3 /* Fixed */) || !!(tupleStructureComparisonKind & 2 /* MatchVariable */ && f1 & 12 /* Variable */ && f2 & 12 /* Variable */);
+    });
   }
   function isZeroBigInt({ value }) {
     return value.base10Value === "0";
@@ -64933,7 +65028,7 @@ function createTypeChecker(host) {
             const targetArity = getTypeReferenceArity(target);
             const elementTypes = getTypeArguments(target);
             const elementFlags = target.target.elementFlags;
-            if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
+            if (isTupleType(source) && isTupleTypeStructureMatching(source, target, 1 /* MatchFixed */)) {
               for (let i = 0; i < targetArity; i++) {
                 inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
               }
@@ -66180,7 +66275,7 @@ function createTypeChecker(host) {
       case 206 /* ObjectBindingPattern */:
       case 207 /* ArrayBindingPattern */:
         const rootDeclaration = getRootDeclaration(node.parent);
-        return isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
+        return isParameter(rootDeclaration) || isCatchClauseVariableDeclaration(rootDeclaration) ? !isSomeSymbolAssigned(rootDeclaration) : isVariableDeclaration(rootDeclaration) && isVarConstLike(rootDeclaration);
     }
     return false;
   }
@@ -113474,7 +113569,14 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   function willEmitLeadingNewLine(node) {
     if (!currentSourceFile)
       return false;
-    if (some(getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine))
+    const leadingCommentRanges = getLeadingCommentRanges(currentSourceFile.text, node.pos);
+    if (leadingCommentRanges) {
+      const parseNode = getParseTreeNode(node);
+      if (parseNode && isParenthesizedExpression(parseNode.parent)) {
+        return true;
+      }
+    }
+    if (some(leadingCommentRanges, commentWillEmitNewLine))
       return true;
     if (some(getSyntheticLeadingComments(node), commentWillEmitNewLine))
       return true;