typescript 5.4.0-dev.20240112 → 5.4.0-dev.20240114

package/lib/lib.es5.d.ts

@@ -1666,6 +1666,11 @@ type Capitalize<S extends string> = intrinsic;
  */
 type Uncapitalize<S extends string> = intrinsic;
 
+/**
+ * Marker for non-inference type position
+ */
+type NoInfer<T> = intrinsic;
+
 /**
  * Marker for contextual 'this' type
  */

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.20240112`;
+var version = `${versionMajorMinor}.0-dev.20240114`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -43562,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 {
 };
@@ -47928,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
@@ -48448,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) {
@@ -56418,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;
@@ -56573,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) {
@@ -56589,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;
@@ -58118,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) {
@@ -59861,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);
@@ -64653,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) {
@@ -64702,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 */) {
@@ -108495,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 = {
@@ -108561,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) {
@@ -108904,7 +108913,7 @@ function transformDeclarations(context) {
     });
     return ret;
   }
-  function filterBindingPatternInitializersAndRenamings(name) {
+  function filterBindingPatternInitializers(name) {
     if (name.kind === 80 /* Identifier */) {
       return name;
     } else {
@@ -108921,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) {
@@ -109105,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,
@@ -109481,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);
         }
@@ -109510,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);
         }
@@ -109535,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 */: {
@@ -109555,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 */:
@@ -109603,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(
@@ -109679,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 */: {
@@ -109884,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);