@typescript-deploys/pr-build 5.5.0-pr-49218-53 → 5.5.0-pr-57619-14

package/lib/lib.esnext.d.ts

@@ -25,3 +25,4 @@ and limitations under the License.
 /// <reference lib="esnext.collection" />
 /// <reference lib="esnext.array" />
 /// <reference lib="esnext.regexp" />
+/// <reference lib="esnext.string" />

package/lib/lib.esnext.string.d.ts

@@ -0,0 +1,29 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference no-default-lib="true"/>
+
+interface String {
+    /**
+     * Returns true if all leading surrogates and trailing surrogates appear paired and in order.
+     */
+    isWellFormed(): boolean;
+
+    /**
+     * Returns a string where all lone or out-of-order surrogates have been replaced by the Unicode replacement character (U+FFFD).
+     */
+    toWellFormed(): string;
+}

package/lib/tsc.js

@@ -12083,6 +12083,10 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2022: [
         "at"
+      ],
+      esnext: [
+        "isWellFormed",
+        "toWellFormed"
       ]
     })),
     StringConstructor: new Map(Object.entries({
@@ -34442,6 +34446,7 @@ var libEntries = [
   ["esnext.object", "lib.esnext.object.d.ts"],
   ["esnext.array", "lib.esnext.array.d.ts"],
   ["esnext.regexp", "lib.esnext.regexp.d.ts"],
+  ["esnext.string", "lib.esnext.string.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -54700,21 +54705,58 @@ function createTypeChecker(host) {
     result.flags |= callChainFlags;
     return result;
   }
+  function getFallbackExpandedLabels(restType, restDeclaration) {
+    if (!restDeclaration) {
+      return;
+    }
+    Debug.assertNode(restDeclaration, isParameter);
+    if (restDeclaration.name.kind !== 207 /* ArrayBindingPattern */) {
+      return;
+    }
+    const nameElements = restDeclaration.name.elements;
+    const elementFlags = restType.target.elementFlags;
+    let structuresMatch = true;
+    return map(elementFlags, (elementFlag, i) => {
+      if (!structuresMatch || i >= nameElements.length) {
+        return void 0;
+      }
+      const nameElement = nameElements[i];
+      if (elementFlag & 12 /* Variable */) {
+        structuresMatch = false;
+        if (nameElement.kind === 208 /* BindingElement */ && nameElement.name.kind === 80 /* Identifier */ && nameElement.dotDotDotToken) {
+          return nameElement.name.escapedText;
+        }
+        return void 0;
+      }
+      if (nameElement.kind !== 208 /* BindingElement */) {
+        return void 0;
+      }
+      if (nameElement.dotDotDotToken) {
+        structuresMatch = false;
+        return void 0;
+      }
+      if (nameElement.kind === 208 /* BindingElement */ && nameElement.name.kind === 80 /* Identifier */) {
+        return nameElement.name.escapedText;
+      }
+      return void 0;
+    });
+  }
   function getExpandedParameters(sig, skipUnionExpanding) {
     if (signatureHasRestParameter(sig)) {
       const restIndex = sig.parameters.length - 1;
       const restName = sig.parameters[restIndex].escapedName;
       const restType = getTypeOfSymbol(sig.parameters[restIndex]);
+      const restDeclaration = sig.parameters[restIndex].valueDeclaration;
       if (isTupleType(restType)) {
-        return [expandSignatureParametersWithTupleMembers(restType, restIndex, restName)];
+        return [expandSignatureParametersWithTupleMembers(restType, restIndex, restName, getFallbackExpandedLabels(restType, restDeclaration))];
       } else if (!skipUnionExpanding && restType.flags & 1048576 /* Union */ && every(restType.types, isTupleType)) {
-        return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex, restName));
+        return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex, restName, getFallbackExpandedLabels(t, restDeclaration)));
       }
     }
     return [sig.parameters];
-    function expandSignatureParametersWithTupleMembers(restType, restIndex, restName) {
+    function expandSignatureParametersWithTupleMembers(restType, restIndex, restName, fallbackLabels) {
       const elementTypes = getTypeArguments(restType);
-      const associatedNames = getUniqAssociatedNamesFromTupleType(restType, restName);
+      const associatedNames = getUniqAssociatedNamesFromTupleType(restType, restName, fallbackLabels);
       const restParams = map(elementTypes, (t, i) => {
         const name = associatedNames && associatedNames[i] ? associatedNames[i] : getParameterNameAtPosition(sig, restIndex + i, restType);
         const flags = restType.target.elementFlags[i];
@@ -54725,10 +54767,10 @@ function createTypeChecker(host) {
       });
       return concatenate(sig.parameters.slice(0, restIndex), restParams);
     }
-    function getUniqAssociatedNamesFromTupleType(type, restName) {
+    function getUniqAssociatedNamesFromTupleType(type, restName, fallbackLabels) {
       const associatedNamesMap = /* @__PURE__ */ new Map();
       return map(type.target.labeledElementDeclarations, (labeledElement, i) => {
-        const name = getTupleElementLabel(labeledElement, i, restName);
+        const name = getTupleElementLabel(labeledElement, i, restName, fallbackLabels == null ? void 0 : fallbackLabels[i]);
         const prevCounter = associatedNamesMap.get(name);
         if (prevCounter === void 0) {
           associatedNamesMap.set(name, 1);
@@ -61239,37 +61281,7 @@ function createTypeChecker(host) {
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
       const sourceType = i === restIndex ? getRestOrAnyTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
-      let targetType = i === restIndex ? getRestOrAnyTypeAtPosition(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);
-        });
-      }
+      const targetType = i === restIndex ? getRestOrAnyTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       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));
@@ -64540,11 +64552,8 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  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 isTupleTypeStructureMatching(t1, t2) {
+    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
   }
   function isZeroBigInt({ value }) {
     return value.base10Value === "0";
@@ -65785,7 +65794,7 @@ function createTypeChecker(host) {
             const targetArity = getTypeReferenceArity(target);
             const elementTypes = getTypeArguments(target);
             const elementFlags = target.target.elementFlags;
-            if (isTupleType(source) && isTupleTypeStructureMatching(source, target, 1 /* MatchFixed */)) {
+            if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
               for (let i = 0; i < targetArity; i++) {
                 inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
               }
@@ -71440,7 +71449,10 @@ function createTypeChecker(host) {
       if (indexInfo.isReadonly && (isAssignmentTarget(node) || isDeleteTarget(node))) {
         error(node, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
       }
-      propType = compilerOptions.noUncheckedIndexedAccess && !isAssignmentTarget(node) ? getUnionType([indexInfo.type, missingType]) : indexInfo.type;
+      propType = indexInfo.type;
+      if (compilerOptions.noUncheckedIndexedAccess && getAssignmentTargetKind(node) !== 1 /* Definite */) {
+        propType = getUnionType([propType, missingType]);
+      }
       if (compilerOptions.noPropertyAccessFromIndexSignature && isPropertyAccessExpression(node)) {
         error(right, Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, unescapeLeadingUnderscores(right.escapedText));
       }
@@ -71890,7 +71902,16 @@ function createTypeChecker(host) {
       return errorType;
     }
     const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
-    const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
+    const assignmentTargetKind = getAssignmentTargetKind(node);
+    let accessFlags;
+    if (assignmentTargetKind === 0 /* None */) {
+      accessFlags = 32 /* ExpressionPosition */;
+    } else {
+      accessFlags = 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0);
+      if (assignmentTargetKind === 2 /* Compound */) {
+        accessFlags |= 32 /* ExpressionPosition */;
+      }
+    }
     const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
     return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
   }
@@ -74213,9 +74234,9 @@ function createTypeChecker(host) {
       !!declaration && (hasInitializer(declaration) || isOptionalDeclaration(declaration))
     );
   }
-  function getTupleElementLabel(d, index, restParameterName = "arg") {
+  function getTupleElementLabel(d, index, restParameterName = "arg", fallbackLabel) {
     if (!d) {
-      return `${restParameterName}_${index}`;
+      return fallbackLabel ?? `${restParameterName}_${index}`;
     }
     Debug.assert(isIdentifier(d.name));
     return d.name.escapedText;

package/lib/typescript.js

@@ -15916,6 +15916,10 @@ var getScriptTargetFeatures = /* @__PURE__ */ memoize(
       ],
       es2022: [
         "at"
+      ],
+      esnext: [
+        "isWellFormed",
+        "toWellFormed"
       ]
     })),
     StringConstructor: new Map(Object.entries({
@@ -38888,6 +38892,7 @@ var libEntries = [
   ["esnext.object", "lib.esnext.object.d.ts"],
   ["esnext.array", "lib.esnext.array.d.ts"],
   ["esnext.regexp", "lib.esnext.regexp.d.ts"],
+  ["esnext.string", "lib.esnext.string.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -59502,21 +59507,58 @@ function createTypeChecker(host) {
     result.flags |= callChainFlags;
     return result;
   }
+  function getFallbackExpandedLabels(restType, restDeclaration) {
+    if (!restDeclaration) {
+      return;
+    }
+    Debug.assertNode(restDeclaration, isParameter);
+    if (restDeclaration.name.kind !== 207 /* ArrayBindingPattern */) {
+      return;
+    }
+    const nameElements = restDeclaration.name.elements;
+    const elementFlags = restType.target.elementFlags;
+    let structuresMatch = true;
+    return map(elementFlags, (elementFlag, i) => {
+      if (!structuresMatch || i >= nameElements.length) {
+        return void 0;
+      }
+      const nameElement = nameElements[i];
+      if (elementFlag & 12 /* Variable */) {
+        structuresMatch = false;
+        if (nameElement.kind === 208 /* BindingElement */ && nameElement.name.kind === 80 /* Identifier */ && nameElement.dotDotDotToken) {
+          return nameElement.name.escapedText;
+        }
+        return void 0;
+      }
+      if (nameElement.kind !== 208 /* BindingElement */) {
+        return void 0;
+      }
+      if (nameElement.dotDotDotToken) {
+        structuresMatch = false;
+        return void 0;
+      }
+      if (nameElement.kind === 208 /* BindingElement */ && nameElement.name.kind === 80 /* Identifier */) {
+        return nameElement.name.escapedText;
+      }
+      return void 0;
+    });
+  }
   function getExpandedParameters(sig, skipUnionExpanding) {
     if (signatureHasRestParameter(sig)) {
       const restIndex = sig.parameters.length - 1;
       const restName = sig.parameters[restIndex].escapedName;
       const restType = getTypeOfSymbol(sig.parameters[restIndex]);
+      const restDeclaration = sig.parameters[restIndex].valueDeclaration;
       if (isTupleType(restType)) {
-        return [expandSignatureParametersWithTupleMembers(restType, restIndex, restName)];
+        return [expandSignatureParametersWithTupleMembers(restType, restIndex, restName, getFallbackExpandedLabels(restType, restDeclaration))];
       } else if (!skipUnionExpanding && restType.flags & 1048576 /* Union */ && every(restType.types, isTupleType)) {
-        return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex, restName));
+        return map(restType.types, (t) => expandSignatureParametersWithTupleMembers(t, restIndex, restName, getFallbackExpandedLabels(t, restDeclaration)));
       }
     }
     return [sig.parameters];
-    function expandSignatureParametersWithTupleMembers(restType, restIndex, restName) {
+    function expandSignatureParametersWithTupleMembers(restType, restIndex, restName, fallbackLabels) {
       const elementTypes = getTypeArguments(restType);
-      const associatedNames = getUniqAssociatedNamesFromTupleType(restType, restName);
+      const associatedNames = getUniqAssociatedNamesFromTupleType(restType, restName, fallbackLabels);
       const restParams = map(elementTypes, (t, i) => {
         const name = associatedNames && associatedNames[i] ? associatedNames[i] : getParameterNameAtPosition(sig, restIndex + i, restType);
         const flags = restType.target.elementFlags[i];
@@ -59527,10 +59569,10 @@ function createTypeChecker(host) {
       });
       return concatenate(sig.parameters.slice(0, restIndex), restParams);
     }
-    function getUniqAssociatedNamesFromTupleType(type, restName) {
+    function getUniqAssociatedNamesFromTupleType(type, restName, fallbackLabels) {
       const associatedNamesMap = /* @__PURE__ */ new Map();
       return map(type.target.labeledElementDeclarations, (labeledElement, i) => {
-        const name = getTupleElementLabel(labeledElement, i, restName);
+        const name = getTupleElementLabel(labeledElement, i, restName, fallbackLabels == null ? void 0 : fallbackLabels[i]);
         const prevCounter = associatedNamesMap.get(name);
         if (prevCounter === void 0) {
           associatedNamesMap.set(name, 1);
@@ -66041,37 +66083,7 @@ function createTypeChecker(host) {
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
       const sourceType = i === restIndex ? getRestOrAnyTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
-      let targetType = i === restIndex ? getRestOrAnyTypeAtPosition(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);
-        });
-      }
+      const targetType = i === restIndex ? getRestOrAnyTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       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));
@@ -69342,11 +69354,8 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  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 isTupleTypeStructureMatching(t1, t2) {
+    return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && every(t1.target.elementFlags, (f, i) => (f & 12 /* Variable */) === (t2.target.elementFlags[i] & 12 /* Variable */));
   }
   function isZeroBigInt({ value }) {
     return value.base10Value === "0";
@@ -70587,7 +70596,7 @@ function createTypeChecker(host) {
             const targetArity = getTypeReferenceArity(target);
             const elementTypes = getTypeArguments(target);
             const elementFlags = target.target.elementFlags;
-            if (isTupleType(source) && isTupleTypeStructureMatching(source, target, 1 /* MatchFixed */)) {
+            if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) {
               for (let i = 0; i < targetArity; i++) {
                 inferFromTypes(getTypeArguments(source)[i], elementTypes[i]);
               }
@@ -76242,7 +76251,10 @@ function createTypeChecker(host) {
       if (indexInfo.isReadonly && (isAssignmentTarget(node) || isDeleteTarget(node))) {
         error2(node, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType));
       }
-      propType = compilerOptions.noUncheckedIndexedAccess && !isAssignmentTarget(node) ? getUnionType([indexInfo.type, missingType]) : indexInfo.type;
+      propType = indexInfo.type;
+      if (compilerOptions.noUncheckedIndexedAccess && getAssignmentTargetKind(node) !== 1 /* Definite */) {
+        propType = getUnionType([propType, missingType]);
+      }
       if (compilerOptions.noPropertyAccessFromIndexSignature && isPropertyAccessExpression(node)) {
         error2(right, Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, unescapeLeadingUnderscores(right.escapedText));
       }
@@ -76692,7 +76704,16 @@ function createTypeChecker(host) {
       return errorType;
     }
     const effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType;
-    const accessFlags = isAssignmentTarget(node) ? 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0) : 32 /* ExpressionPosition */;
+    const assignmentTargetKind = getAssignmentTargetKind(node);
+    let accessFlags;
+    if (assignmentTargetKind === 0 /* None */) {
+      accessFlags = 32 /* ExpressionPosition */;
+    } else {
+      accessFlags = 4 /* Writing */ | (isGenericObjectType(objectType) && !isThisTypeParameter(objectType) ? 2 /* NoIndexSignatures */ : 0);
+      if (assignmentTargetKind === 2 /* Compound */) {
+        accessFlags |= 32 /* ExpressionPosition */;
+      }
+    }
     const indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType;
     return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
   }
@@ -79015,9 +79036,9 @@ function createTypeChecker(host) {
       !!declaration && (hasInitializer(declaration) || isOptionalDeclaration(declaration))
     );
   }
-  function getTupleElementLabel(d, index, restParameterName = "arg") {
+  function getTupleElementLabel(d, index, restParameterName = "arg", fallbackLabel) {
     if (!d) {
-      return `${restParameterName}_${index}`;
+      return fallbackLabel ?? `${restParameterName}_${index}`;
     }
     Debug.assert(isIdentifier(d.name));
     return d.name.escapedText;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.5.0-pr-49218-53",
+  "version": "5.5.0-pr-57619-14",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -111,5 +111,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "a6705551c8511c14e60cf14599775f5c622468a5"
+  "gitHead": "4b37e9b71356111ad30c4c34385c9c8f29da5d9e"
 }