typescript 5.4.0-dev.20240111 → 5.4.0-dev.20240113

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-dev.20240111`;
+var version = `${versionMajorMinor}.0-dev.20240113`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4898,6 +4898,7 @@ var sys = (() => {
       resolvePath: (path) => _path.resolve(path),
       fileExists,
       directoryExists,
+      getAccessibleFileSystemEntries,
       createDirectory(directoryName) {
         if (!nodeSystem.directoryExists(directoryName)) {
           try {
@@ -11372,6 +11373,45 @@ function isRestParameter(node) {
   const type = isJSDocParameterTag(node) ? node.typeExpression && node.typeExpression.type : node.type;
   return node.dotDotDotToken !== void 0 || !!type && type.kind === 325 /* JSDocVariadicType */;
 }
+function hasInternalAnnotation(range, sourceFile) {
+  const comment = sourceFile.text.substring(range.pos, range.end);
+  return comment.includes("@internal");
+}
+function isInternalDeclaration(node, sourceFile) {
+  sourceFile ?? (sourceFile = getSourceFileOfNode(node));
+  const parseTreeNode = getParseTreeNode(node);
+  if (parseTreeNode && parseTreeNode.kind === 169 /* Parameter */) {
+    const paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
+    const previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : void 0;
+    const text = sourceFile.text;
+    const commentRanges = previousSibling ? concatenate(
+      // to handle
+      // ... parameters, /** @internal */
+      // public param: string
+      getTrailingCommentRanges(text, skipTrivia(
+        text,
+        previousSibling.end + 1,
+        /*stopAfterLineBreak*/
+        false,
+        /*stopAtComments*/
+        true
+      )),
+      getLeadingCommentRanges(text, node.pos)
+    ) : getTrailingCommentRanges(text, skipTrivia(
+      text,
+      node.pos,
+      /*stopAfterLineBreak*/
+      false,
+      /*stopAtComments*/
+      true
+    ));
+    return some(commentRanges) && hasInternalAnnotation(last(commentRanges), sourceFile);
+  }
+  const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, sourceFile);
+  return !!forEach(leadingCommentRanges, (range) => {
+    return hasInternalAnnotation(range, sourceFile);
+  });
+}
 
 // src/compiler/utilities.ts
 var resolvingEmptyArray = [];
@@ -34068,7 +34108,7 @@ var libEntries = [
   ["es2023.array", "lib.es2023.array.d.ts"],
   ["es2023.collection", "lib.es2023.collection.d.ts"],
   ["esnext.array", "lib.es2023.array.d.ts"],
-  ["esnext.collection", "lib.es2023.collection.d.ts"],
+  ["esnext.collection", "lib.esnext.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
   ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
   ["esnext.intl", "lib.esnext.intl.d.ts"],
@@ -34078,6 +34118,7 @@ var libEntries = [
   ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
+  ["esnext.object", "lib.esnext.object.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -43521,7 +43562,8 @@ var intrinsicTypeKinds = new Map(Object.entries({
   Uppercase: 0 /* Uppercase */,
   Lowercase: 1 /* Lowercase */,
   Capitalize: 2 /* Capitalize */,
-  Uncapitalize: 3 /* Uncapitalize */
+  Uncapitalize: 3 /* Uncapitalize */,
+  NoInfer: 4 /* NoInfer */
 }));
 var SymbolLinks = class {
 };
@@ -44606,7 +44648,12 @@ function createTypeChecker(host) {
   }
   function markAsSynthetic(node) {
     setTextRangePosEnd(node, -1, -1);
-    return visitEachChild(node, markAsSynthetic, nullTransformationContext);
+    return visitEachChild(
+      node,
+      markAsSynthetic,
+      /*context*/
+      void 0
+    );
   }
   function getEmitResolver(sourceFile, cancellationToken2) {
     getDiagnostics(sourceFile, cancellationToken2);
@@ -47882,16 +47929,12 @@ function createTypeChecker(host) {
   }
   function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
     let aliasesToMakeVisible;
-    let bindingElementToMakeVisible;
     if (!every(filter(symbol.declarations, (d) => d.kind !== 80 /* Identifier */), getIsDeclarationVisible)) {
       return void 0;
     }
-    return { accessibility: 0 /* Accessible */, aliasesToMakeVisible, bindingElementToMakeVisible };
+    return { accessibility: 0 /* Accessible */, aliasesToMakeVisible };
     function getIsDeclarationVisible(declaration) {
       var _a, _b;
-      if (isBindingElement(declaration) && findAncestor(declaration, isParameter)) {
-        bindingElementToMakeVisible = declaration;
-      }
       if (!isDeclarationVisible(declaration)) {
         const anyImportSyntax = getAnyImportSyntax(declaration);
         if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 32 /* Export */) && // import clause without export
@@ -48402,7 +48445,13 @@ function createTypeChecker(host) {
         return visitAndTransformType(type, (type2) => conditionalTypeToTypeNode(type2));
       }
       if (type.flags & 33554432 /* Substitution */) {
-        return typeToTypeNodeHelper(type.baseType, context);
+        const typeNode = typeToTypeNodeHelper(type.baseType, context);
+        const noInferSymbol = isNoInferType(type) && getGlobalTypeSymbol(
+          "NoInfer",
+          /*reportErrors*/
+          false
+        );
+        return noInferSymbol ? symbolToTypeNode(noInferSymbol, context, 788968 /* Type */, [typeNode]) : typeNode;
       }
       return Debug.fail("Should be unreachable.");
       function conditionalTypeToTypeNode(type2) {
@@ -48648,7 +48697,13 @@ function createTypeChecker(host) {
           if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
             return node;
           }
-          return setTextRange(factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, nullTransformationContext, deepCloneOrReuseNodes)), node);
+          return setTextRange(factory.cloneNode(visitEachChild(
+            node,
+            deepCloneOrReuseNode,
+            /*context*/
+            void 0,
+            deepCloneOrReuseNodes
+          )), node);
         }
         function deepCloneOrReuseNodes(nodes, visitor, test, start, count) {
           if (nodes && nodes.length === 0) {
@@ -49370,7 +49425,8 @@ function createTypeChecker(host) {
           let visited = visitEachChild(
             node2,
             elideInitializerAndSetEmitFlags,
-            nullTransformationContext,
+            /*context*/
+            void 0,
             /*nodesVisitor*/
             void 0,
             elideInitializerAndSetEmitFlags
@@ -50148,7 +50204,12 @@ function createTypeChecker(host) {
         if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
           setEmitFlags(node, 1 /* SingleLine */);
         }
-        return visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext);
+        return visitEachChild(
+          node,
+          visitExistingNodeTreeSymbols,
+          /*context*/
+          void 0
+        );
         function getEffectiveDotDotDotForParameter(p) {
           return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0);
         }
@@ -50248,7 +50309,7 @@ function createTypeChecker(host) {
       });
       let addingDeclare = !bundled;
       const exportEquals = symbolTable.get("export=" /* ExportEquals */);
-      if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152 /* Alias */) {
+      if (exportEquals && symbolTable.size > 1 && exportEquals.flags & (2097152 /* Alias */ | 1536 /* Module */)) {
         symbolTable = createSymbolTable();
         symbolTable.set("export=" /* ExportEquals */, exportEquals);
       }
@@ -50705,8 +50766,18 @@ function createTypeChecker(host) {
         );
       }
       function getNamespaceMembersForSerialization(symbol) {
-        const exports2 = getExportsOfSymbol(symbol);
-        return !exports2 ? [] : filter(arrayFrom(exports2.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
+        let exports2 = arrayFrom(getExportsOfSymbol(symbol).values());
+        const merged = getMergedSymbol(symbol);
+        if (merged !== symbol) {
+          const membersSet = new Set(exports2);
+          for (const exported of getExportsOfSymbol(merged).values()) {
+            if (!(getSymbolFlags(resolveSymbol(exported)) & 111551 /* Value */)) {
+              membersSet.add(exported);
+            }
+          }
+          exports2 = arrayFrom(membersSet);
+        }
+        return filter(exports2, (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
       }
       function isTypeOnlyNamespace(symbol) {
         return every(getNamespaceMembersForSerialization(symbol), (m) => !(getSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
@@ -56350,8 +56421,11 @@ function createTypeChecker(host) {
   }
   function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
     const type = getDeclaredTypeOfSymbol(symbol);
-    if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
-      return getStringMappingType(symbol, typeArguments[0]);
+    if (type === intrinsicMarkerType) {
+      const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
+      if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
+        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
+      }
     }
     const links = getSymbolLinks(symbol);
     const typeParameters = links.typeParameters;
@@ -56505,10 +56579,19 @@ function createTypeChecker(host) {
     }
     return links.resolvedJSDocType;
   }
+  function getNoInferType(type) {
+    return isNoInferTargetType(type) ? getOrCreateSubstitutionType(type, unknownType) : type;
+  }
+  function isNoInferTargetType(type) {
+    return !!(type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, isNoInferTargetType) || type.flags & 33554432 /* Substitution */ && !isNoInferType(type) && isNoInferTargetType(type.baseType) || type.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(type) || type.flags & (465829888 /* Instantiable */ & ~33554432 /* Substitution */) && !isPatternLiteralType(type));
+  }
+  function isNoInferType(type) {
+    return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
+  }
   function getSubstitutionType(baseType, constraint) {
-    if (constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */) {
-      return baseType;
-    }
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
+  }
+  function getOrCreateSubstitutionType(baseType, constraint) {
     const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
@@ -56521,7 +56604,7 @@ function createTypeChecker(host) {
     return result;
   }
   function getSubstitutionIntersection(substitutionType) {
-    return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
+    return isNoInferType(substitutionType) ? substitutionType.baseType : getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
   }
   function isUnaryTupleTypeNode(node) {
     return node.kind === 189 /* TupleType */ && node.elements.length === 1;
@@ -58050,7 +58133,7 @@ function createTypeChecker(host) {
   }
   function getIndexType(type, indexFlags = defaultIndexFlags) {
     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(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
+    return isNoInferType(type) ? getNoInferType(getIndexType(type.baseType, indexFlags)) : 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, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
   }
   function getExtractStringType(type) {
     if (keyofStringsOnly) {
@@ -59793,6 +59876,9 @@ function createTypeChecker(host) {
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
+      if (isNoInferType(type)) {
+        return getNoInferType(newBaseType);
+      }
       const newConstraint = instantiateType(type.constraint, mapper);
       if (newBaseType.flags & 8650752 /* TypeVariable */ && isGenericType(newConstraint)) {
         return getSubstitutionType(newBaseType, newConstraint);
@@ -64585,7 +64671,7 @@ function createTypeChecker(host) {
     let expandingFlags = 0 /* None */;
     inferFromTypes(originalSource, originalTarget);
     function inferFromTypes(source, target) {
-      if (!couldContainTypeVariables(target)) {
+      if (!couldContainTypeVariables(target) || isNoInferType(target)) {
         return;
       }
       if (source === wildcardType || source === blockedStringType) {
@@ -64634,6 +64720,9 @@ function createTypeChecker(host) {
         }
       }
       if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
+        if (isNoInferType(target)) {
+          return;
+        }
         target = getActualTypeVariable(target);
       }
       if (target.flags & 8650752 /* TypeVariable */) {
@@ -85645,7 +85734,7 @@ function visitCommaListElements(elements, visitor, discardVisitor = visitor) {
     return discarded ? discardVisitor(node) : visitor(node);
   }, isExpression);
 }
-function visitEachChild(node, visitor, context, nodesVisitor = visitNodes2, tokenVisitor, nodeVisitor = visitNode) {
+function visitEachChild(node, visitor, context = nullTransformationContext, nodesVisitor = visitNodes2, tokenVisitor, nodeVisitor = visitNode) {
   if (node === void 0) {
     return void 0;
   }
@@ -99948,12 +100037,22 @@ function transformES2015(context) {
       case 172 /* PropertyDeclaration */: {
         const named = node;
         if (isComputedPropertyName(named.name)) {
-          return factory2.replacePropertyName(named, visitEachChild(named.name, elideUnusedThisCaptureWorker, nullTransformationContext));
+          return factory2.replacePropertyName(named, visitEachChild(
+            named.name,
+            elideUnusedThisCaptureWorker,
+            /*context*/
+            void 0
+          ));
         }
         return node;
       }
     }
-    return visitEachChild(node, elideUnusedThisCaptureWorker, nullTransformationContext);
+    return visitEachChild(
+      node,
+      elideUnusedThisCaptureWorker,
+      /*context*/
+      void 0
+    );
   }
   function simplifyConstructorElideUnusedThisCapture(body, original) {
     if (original.transformFlags & 16384 /* ContainsLexicalThis */ || hierarchyFacts & 65536 /* LexicalThis */ || hierarchyFacts & 131072 /* CapturedLexicalThis */) {
@@ -99989,12 +100088,22 @@ function transformES2015(context) {
       case 172 /* PropertyDeclaration */: {
         const named = node;
         if (isComputedPropertyName(named.name)) {
-          return factory2.replacePropertyName(named, visitEachChild(named.name, injectSuperPresenceCheckWorker, nullTransformationContext));
+          return factory2.replacePropertyName(named, visitEachChild(
+            named.name,
+            injectSuperPresenceCheckWorker,
+            /*context*/
+            void 0
+          ));
         }
         return node;
       }
     }
-    return visitEachChild(node, injectSuperPresenceCheckWorker, nullTransformationContext);
+    return visitEachChild(
+      node,
+      injectSuperPresenceCheckWorker,
+      /*context*/
+      void 0
+    );
   }
   function complicateConstructorInjectSuperPresenceCheck(body) {
     return factory2.updateBlock(body, visitNodes2(body.statements, injectSuperPresenceCheckWorker, isStatement));
@@ -108392,44 +108501,6 @@ function getDeclarationDiagnostics(host, resolver, file) {
   );
   return result.diagnostics;
 }
-function hasInternalAnnotation(range, currentSourceFile) {
-  const comment = currentSourceFile.text.substring(range.pos, range.end);
-  return comment.includes("@internal");
-}
-function isInternalDeclaration(node, currentSourceFile) {
-  const parseTreeNode = getParseTreeNode(node);
-  if (parseTreeNode && parseTreeNode.kind === 169 /* Parameter */) {
-    const paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
-    const previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : void 0;
-    const text = currentSourceFile.text;
-    const commentRanges = previousSibling ? concatenate(
-      // to handle
-      // ... parameters, /** @internal */
-      // public param: string
-      getTrailingCommentRanges(text, skipTrivia(
-        text,
-        previousSibling.end + 1,
-        /*stopAfterLineBreak*/
-        false,
-        /*stopAtComments*/
-        true
-      )),
-      getLeadingCommentRanges(text, node.pos)
-    ) : getTrailingCommentRanges(text, skipTrivia(
-      text,
-      node.pos,
-      /*stopAfterLineBreak*/
-      false,
-      /*stopAtComments*/
-      true
-    ));
-    return commentRanges && commentRanges.length && hasInternalAnnotation(last(commentRanges), currentSourceFile);
-  }
-  const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile);
-  return !!forEach(leadingCommentRanges, (range) => {
-    return hasInternalAnnotation(range, currentSourceFile);
-  });
-}
 var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
@@ -108445,7 +108516,6 @@ function transformDeclarations(context) {
   let lateStatementReplacementMap;
   let suppressNewDiagnosticContexts;
   let exportedModulesFromDeclarationEmit;
-  const usedBindingElementAliases = /* @__PURE__ */ new Map();
   const { factory: factory2 } = context;
   const host = context.getEmitHost();
   const symbolTracker = {
@@ -108511,17 +108581,6 @@ function transformDeclarations(context) {
           }
         }
       }
-      if (symbolAccessibilityResult.bindingElementToMakeVisible) {
-        const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible;
-        const parameter = findAncestor(bindingElement, isParameter);
-        Debug.assert(parameter !== void 0);
-        const parent = getOriginalNode(parameter.parent);
-        let aliases = usedBindingElementAliases.get(parent);
-        if (!aliases) {
-          usedBindingElementAliases.set(parent, aliases = /* @__PURE__ */ new Map());
-        }
-        aliases.set(getOriginalNode(bindingElement), bindingElement.name);
-      }
     } else {
       const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
       if (errorInfo) {
@@ -108854,7 +108913,7 @@ function transformDeclarations(context) {
     });
     return ret;
   }
-  function filterBindingPatternInitializersAndRenamings(name) {
+  function filterBindingPatternInitializers(name) {
     if (name.kind === 80 /* Identifier */) {
       return name;
     } else {
@@ -108871,180 +108930,15 @@ function transformDeclarations(context) {
       if (elem.propertyName && isComputedPropertyName(elem.propertyName) && isEntityNameExpression(elem.propertyName.expression)) {
         checkEntityNameVisibility(elem.propertyName.expression, enclosingDeclaration);
       }
-      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !isIdentifierANonContextualKeyword(elem.propertyName)) {
-        return factory2.updateBindingElement(
-          elem,
-          elem.dotDotDotToken,
-          /*propertyName*/
-          void 0,
-          elem.propertyName,
-          shouldPrintWithInitializer(elem) ? elem.initializer : void 0
-        );
-      }
       return factory2.updateBindingElement(
         elem,
         elem.dotDotDotToken,
         elem.propertyName,
-        filterBindingPatternInitializersAndRenamings(elem.name),
+        filterBindingPatternInitializers(elem.name),
         shouldPrintWithInitializer(elem) ? elem.initializer : void 0
       );
     }
   }
-  function ensureBindingAliasesInParameterList(input, updatedNode) {
-    const original = getOriginalNode(input);
-    const params = updatedNode.parameters;
-    const aliases = usedBindingElementAliases.get(original);
-    if (!aliases) {
-      return updatedNode;
-    }
-    usedBindingElementAliases.delete(original);
-    const newParams = map(params, addUsedBindingPatternsToParameter);
-    const newParamsNodeArray = factory2.createNodeArray(newParams, params.hasTrailingComma);
-    switch (updatedNode.kind) {
-      case 174 /* MethodDeclaration */:
-        return factory2.updateMethodDeclaration(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.asteriskToken,
-          updatedNode.name,
-          updatedNode.questionToken,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type,
-          updatedNode.body
-        );
-      case 176 /* Constructor */:
-        return factory2.updateConstructorDeclaration(
-          updatedNode,
-          updatedNode.modifiers,
-          newParamsNodeArray,
-          updatedNode.body
-        );
-      case 177 /* GetAccessor */:
-        return factory2.updateGetAccessorDeclaration(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.name,
-          newParamsNodeArray,
-          updatedNode.type,
-          updatedNode.body
-        );
-      case 178 /* SetAccessor */:
-        return factory2.updateSetAccessorDeclaration(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.name,
-          newParamsNodeArray,
-          updatedNode.body
-        );
-      case 219 /* ArrowFunction */:
-        return factory2.updateArrowFunction(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type,
-          updatedNode.equalsGreaterThanToken,
-          updatedNode.body
-        );
-      case 262 /* FunctionDeclaration */:
-        return factory2.updateFunctionDeclaration(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.asteriskToken,
-          updatedNode.name,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type,
-          updatedNode.body
-        );
-      case 179 /* CallSignature */:
-        return factory2.updateCallSignature(
-          updatedNode,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type
-        );
-      case 173 /* MethodSignature */:
-        return factory2.updateMethodSignature(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.name,
-          updatedNode.questionToken,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type
-        );
-      case 180 /* ConstructSignature */:
-        return factory2.updateConstructSignature(
-          updatedNode,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type
-        );
-      case 184 /* FunctionType */:
-        return factory2.updateFunctionTypeNode(
-          updatedNode,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type
-        );
-      case 185 /* ConstructorType */:
-        return factory2.updateConstructorTypeNode(
-          updatedNode,
-          updatedNode.modifiers,
-          updatedNode.typeParameters,
-          newParamsNodeArray,
-          updatedNode.type
-        );
-      default:
-        Debug.assertNever(updatedNode);
-    }
-    function addUsedBindingPatternsToParameter(p) {
-      return factory2.updateParameterDeclaration(
-        p,
-        p.modifiers,
-        p.dotDotDotToken,
-        addUsedBindingPatternAliases(p.name),
-        p.questionToken,
-        p.type,
-        p.initializer
-      );
-    }
-    function addUsedBindingPatternAliases(name) {
-      if (name.kind === 80 /* Identifier */) {
-        return name;
-      } else {
-        if (name.kind === 207 /* ArrayBindingPattern */) {
-          return factory2.updateArrayBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isArrayBindingElement));
-        } else {
-          return factory2.updateObjectBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isBindingElement));
-        }
-      }
-      function visitBindingElement(elem) {
-        if (elem.kind === 232 /* OmittedExpression */) {
-          return elem;
-        }
-        const usedAlias = aliases.get(getOriginalNode(elem));
-        if (usedAlias && !elem.propertyName) {
-          return factory2.updateBindingElement(
-            elem,
-            elem.dotDotDotToken,
-            elem.name,
-            usedAlias,
-            elem.initializer
-          );
-        }
-        return factory2.updateBindingElement(
-          elem,
-          elem.dotDotDotToken,
-          elem.propertyName,
-          addUsedBindingPatternAliases(elem.name),
-          elem.initializer
-        );
-      }
-    }
-  }
   function ensureParameter(p, modifierMask, type) {
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
@@ -109055,7 +108949,7 @@ function transformDeclarations(context) {
       p,
       maskModifiers(factory2, p, modifierMask),
       p.dotDotDotToken,
-      filterBindingPatternInitializersAndRenamings(p.name),
+      filterBindingPatternInitializers(p.name),
       resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(58 /* QuestionToken */) : void 0,
       ensureType(
         p,
@@ -109431,25 +109325,19 @@ function transformDeclarations(context) {
           return cleanup(factory2.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
         }
         case 180 /* ConstructSignature */:
-          return cleanup(ensureBindingAliasesInParameterList(
+          return cleanup(factory2.updateConstructSignature(
             input,
-            factory2.updateConstructSignature(
-              input,
-              ensureTypeParams(input, input.typeParameters),
-              updateParamsList(input, input.parameters),
-              ensureType(input, input.type)
-            )
+            ensureTypeParams(input, input.typeParameters),
+            updateParamsList(input, input.parameters),
+            ensureType(input, input.type)
           ));
         case 176 /* Constructor */: {
-          const ctor = ensureBindingAliasesInParameterList(
-            input,
-            factory2.createConstructorDeclaration(
-              /*modifiers*/
-              ensureModifiers(input),
-              updateParamsList(input, input.parameters, 0 /* None */),
-              /*body*/
-              void 0
-            )
+          const ctor = factory2.createConstructorDeclaration(
+            /*modifiers*/
+            ensureModifiers(input),
+            updateParamsList(input, input.parameters, 0 /* None */),
+            /*body*/
+            void 0
           );
           return cleanup(ctor);
         }
@@ -109460,20 +109348,17 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const sig = ensureBindingAliasesInParameterList(
-            input,
-            factory2.createMethodDeclaration(
-              ensureModifiers(input),
-              /*asteriskToken*/
-              void 0,
-              input.name,
-              input.questionToken,
-              ensureTypeParams(input, input.typeParameters),
-              updateParamsList(input, input.parameters),
-              ensureType(input, input.type),
-              /*body*/
-              void 0
-            )
+          const sig = factory2.createMethodDeclaration(
+            ensureModifiers(input),
+            /*asteriskToken*/
+            void 0,
+            input.name,
+            input.questionToken,
+            ensureTypeParams(input, input.typeParameters),
+            updateParamsList(input, input.parameters),
+            ensureType(input, input.type),
+            /*body*/
+            void 0
           );
           return cleanup(sig);
         }
@@ -109485,17 +109370,14 @@ function transformDeclarations(context) {
             );
           }
           const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
-          return cleanup(ensureBindingAliasesInParameterList(
+          return cleanup(factory2.updateGetAccessorDeclaration(
             input,
-            factory2.updateGetAccessorDeclaration(
-              input,
-              ensureModifiers(input),
-              input.name,
-              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-              ensureType(input, accessorType),
-              /*body*/
-              void 0
-            )
+            ensureModifiers(input),
+            input.name,
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+            ensureType(input, accessorType),
+            /*body*/
+            void 0
           ));
         }
         case 178 /* SetAccessor */: {
@@ -109505,16 +109387,13 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          return cleanup(ensureBindingAliasesInParameterList(
+          return cleanup(factory2.updateSetAccessorDeclaration(
             input,
-            factory2.updateSetAccessorDeclaration(
-              input,
-              ensureModifiers(input),
-              input.name,
-              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-              /*body*/
-              void 0
-            )
+            ensureModifiers(input),
+            input.name,
+            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+            /*body*/
+            void 0
           ));
         }
         case 172 /* PropertyDeclaration */:
@@ -109553,29 +109432,25 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          return cleanup(ensureBindingAliasesInParameterList(
+          return cleanup(factory2.updateMethodSignature(
             input,
-            factory2.updateMethodSignature(
-              input,
-              ensureModifiers(input),
-              input.name,
-              input.questionToken,
-              ensureTypeParams(input, input.typeParameters),
-              updateParamsList(input, input.parameters),
-              ensureType(input, input.type)
-            )
+            ensureModifiers(input),
+            input.name,
+            input.questionToken,
+            ensureTypeParams(input, input.typeParameters),
+            updateParamsList(input, input.parameters),
+            ensureType(input, input.type)
           ));
         }
         case 179 /* CallSignature */: {
-          return cleanup(ensureBindingAliasesInParameterList(
-            input,
+          return cleanup(
             factory2.updateCallSignature(
               input,
               ensureTypeParams(input, input.typeParameters),
               updateParamsList(input, input.parameters),
               ensureType(input, input.type)
             )
-          ));
+          );
         }
         case 181 /* IndexSignature */: {
           return cleanup(factory2.updateIndexSignature(
@@ -109629,26 +109504,20 @@ function transformDeclarations(context) {
           return cleanup(factory2.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
         }
         case 184 /* FunctionType */: {
-          return cleanup(ensureBindingAliasesInParameterList(
+          return cleanup(factory2.updateFunctionTypeNode(
             input,
-            factory2.updateFunctionTypeNode(
-              input,
-              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
-              updateParamsList(input, input.parameters),
-              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
-            )
+            visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+            updateParamsList(input, input.parameters),
+            Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
           ));
         }
         case 185 /* ConstructorType */: {
-          return cleanup(ensureBindingAliasesInParameterList(
+          return cleanup(factory2.updateConstructorTypeNode(
             input,
-            factory2.updateConstructorTypeNode(
-              input,
-              ensureModifiers(input),
-              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
-              updateParamsList(input, input.parameters),
-              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
-            )
+            ensureModifiers(input),
+            visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+            updateParamsList(input, input.parameters),
+            Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
           ));
         }
         case 205 /* ImportType */: {
@@ -109834,20 +109703,17 @@ function transformDeclarations(context) {
         ));
       }
       case 262 /* FunctionDeclaration */: {
-        const clean2 = cleanup(ensureBindingAliasesInParameterList(
+        const clean2 = cleanup(factory2.updateFunctionDeclaration(
           input,
-          factory2.updateFunctionDeclaration(
-            input,
-            ensureModifiers(input),
-            /*asteriskToken*/
-            void 0,
-            input.name,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type),
-            /*body*/
-            void 0
-          )
+          ensureModifiers(input),
+          /*asteriskToken*/
+          void 0,
+          input.name,
+          ensureTypeParams(input, input.typeParameters),
+          updateParamsList(input, input.parameters),
+          ensureType(input, input.type),
+          /*body*/
+          void 0
         ));
         if (clean2 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
           const props = resolver.getPropertiesOfContainerFunction(input);