typescript 5.4.0-dev.20240112 → 5.4.0-dev.20240113

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20240112`;
+      version = `${versionMajorMinor}.0-dev.20240113`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -50422,16 +50422,12 @@ ${lanes.join("\n")}
     }
     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
@@ -50942,7 +50938,13 @@ ${lanes.join("\n")}
           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) {
@@ -58912,8 +58914,11 @@ ${lanes.join("\n")}
     }
     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;
@@ -59067,10 +59072,19 @@ ${lanes.join("\n")}
       }
       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) {
@@ -59083,7 +59097,7 @@ ${lanes.join("\n")}
       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;
@@ -60612,7 +60626,7 @@ ${lanes.join("\n")}
     }
     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) {
@@ -62355,6 +62369,9 @@ ${lanes.join("\n")}
       }
       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);
@@ -67147,7 +67164,7 @@ ${lanes.join("\n")}
       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) {
@@ -67196,6 +67213,9 @@ ${lanes.join("\n")}
           }
         }
         if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
+          if (isNoInferType(target)) {
+            return;
+          }
           target = getActualTypeVariable(target);
         }
         if (target.flags & 8650752 /* TypeVariable */) {
@@ -87971,7 +87991,8 @@ ${lanes.join("\n")}
         Uppercase: 0 /* Uppercase */,
         Lowercase: 1 /* Lowercase */,
         Capitalize: 2 /* Capitalize */,
-        Uncapitalize: 3 /* Uncapitalize */
+        Uncapitalize: 3 /* Uncapitalize */,
+        NoInfer: 4 /* NoInfer */
       }));
       SymbolLinks = class {
       };
@@ -111469,7 +111490,6 @@ ${lanes.join("\n")}
     let lateStatementReplacementMap;
     let suppressNewDiagnosticContexts;
     let exportedModulesFromDeclarationEmit;
-    const usedBindingElementAliases = /* @__PURE__ */ new Map();
     const { factory: factory2 } = context;
     const host = context.getEmitHost();
     const symbolTracker = {
@@ -111535,17 +111555,6 @@ ${lanes.join("\n")}
             }
           }
         }
-        if (symbolAccessibilityResult.bindingElementToMakeVisible) {
-          const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible;
-          const parameter = findAncestor(bindingElement, isParameter);
-          Debug.assert(parameter !== void 0);
-          const parent2 = getOriginalNode(parameter.parent);
-          let aliases = usedBindingElementAliases.get(parent2);
-          if (!aliases) {
-            usedBindingElementAliases.set(parent2, aliases = /* @__PURE__ */ new Map());
-          }
-          aliases.set(getOriginalNode(bindingElement), bindingElement.name);
-        }
       } else {
         const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
         if (errorInfo) {
@@ -111878,7 +111887,7 @@ ${lanes.join("\n")}
       });
       return ret;
     }
-    function filterBindingPatternInitializersAndRenamings(name) {
+    function filterBindingPatternInitializers(name) {
       if (name.kind === 80 /* Identifier */) {
         return name;
       } else {
@@ -111895,180 +111904,15 @@ ${lanes.join("\n")}
         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) {
@@ -112079,7 +111923,7 @@ ${lanes.join("\n")}
         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,
@@ -112455,25 +112299,19 @@ ${lanes.join("\n")}
             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);
           }
@@ -112484,20 +112322,17 @@ ${lanes.join("\n")}
                 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);
           }
@@ -112509,17 +112344,14 @@ ${lanes.join("\n")}
               );
             }
             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 */: {
@@ -112529,16 +112361,13 @@ ${lanes.join("\n")}
                 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 */:
@@ -112577,29 +112406,25 @@ ${lanes.join("\n")}
                 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(
@@ -112653,26 +112478,20 @@ ${lanes.join("\n")}
             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 */: {
@@ -112858,20 +112677,17 @@ ${lanes.join("\n")}
           ));
         }
         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);

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20240112`;
+var version = `${versionMajorMinor}.0-dev.20240113`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -29517,7 +29517,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 */
 }));
 function getNodeId(node) {
   if (!node.id) {

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.4.0-dev.20240112",
+    "version": "5.4.0-dev.20240113",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -113,5 +113,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "7f3e34b02203c3cf5d9fa14370f47d7dce4cac06"
+    "gitHead": "23faef92703556567ddbcb9afb893f4ba638fc20"
 }