typescript 5.6.0-dev.20240729 → 5.6.0-dev.20240731

package/lib/typescript.js

@@ -2260,7 +2260,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240729`;
+var version = `${versionMajorMinor}.0-dev.20240731`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -83424,7 +83424,17 @@ function createTypeChecker(host) {
     if (!ok) {
       error2(node, Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query);
     }
-    if (getIsolatedModules(compilerOptions)) {
+    if (compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax && ok && !resolveName(
+      node,
+      getFirstIdentifier(node),
+      2097152 /* Alias */,
+      /*nameNotFoundMessage*/
+      void 0,
+      /*isUse*/
+      false,
+      /*excludeGlobals*/
+      true
+    )) {
       Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
       const constEnumDeclaration = type.symbol.valueDeclaration;
       const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(getSourceFileOfNode(constEnumDeclaration).resolvedPath);
@@ -84385,16 +84395,20 @@ function createTypeChecker(host) {
       const someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags;
       if (someButNotAllOverloadFlags !== 0) {
         const canonicalFlags = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck2);
-        forEach(overloads, (o) => {
-          const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
-          if (deviation & 32 /* Export */) {
-            error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
-          } else if (deviation & 128 /* Ambient */) {
-            error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
-          } else if (deviation & (2 /* Private */ | 4 /* Protected */)) {
-            error2(getNameOfDeclaration(o) || o, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
-          } else if (deviation & 64 /* Abstract */) {
-            error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
+        group(overloads, (o) => getSourceFileOfNode(o).fileName).forEach((overloadsInFile) => {
+          const canonicalFlagsForFile = getEffectiveDeclarationFlags(getCanonicalOverload(overloadsInFile, implementation), flagsToCheck2);
+          for (const o of overloadsInFile) {
+            const deviation = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlags;
+            const deviationInFile = getEffectiveDeclarationFlags(o, flagsToCheck2) ^ canonicalFlagsForFile;
+            if (deviationInFile & 32 /* Export */) {
+              error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported);
+            } else if (deviationInFile & 128 /* Ambient */) {
+              error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient);
+            } else if (deviation & (2 /* Private */ | 4 /* Protected */)) {
+              error2(getNameOfDeclaration(o) || o, Diagnostics.Overload_signatures_must_all_be_public_private_or_protected);
+            } else if (deviation & 64 /* Abstract */) {
+              error2(getNameOfDeclaration(o), Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract);
+            }
           }
         });
       }
@@ -85529,7 +85543,7 @@ function createTypeChecker(host) {
         if (!wrappingDeclaration.type) {
           addRelatedInfo(
             diagnostic,
-            createFileDiagnostic(getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 1, Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, declarationNameToString(node.propertyName))
+            createFileDiagnostic(getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 0, Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, declarationNameToString(node.propertyName))
           );
         }
         diagnostics.add(diagnostic);
@@ -88372,6 +88386,13 @@ function createTypeChecker(host) {
         } else if (moduleKind === 200 /* Preserve */ && node.kind !== 271 /* ImportEqualsDeclaration */ && node.kind !== 260 /* VariableDeclaration */ && host.getEmitModuleFormatOfFile(getSourceFileOfNode(node)) === 1 /* CommonJS */) {
           error2(node, Diagnostics.ESM_syntax_is_not_allowed_in_a_CommonJS_module_when_module_is_set_to_preserve);
         }
+        if (compilerOptions.verbatimModuleSyntax && !isTypeOnlyImportOrExportDeclaration(node) && !(node.flags & 33554432 /* Ambient */) && targetFlags & 128 /* ConstEnum */) {
+          const constEnumDeclaration = target.valueDeclaration;
+          const redirect = host.getRedirectReferenceForResolutionFromSourceOfProject(getSourceFileOfNode(constEnumDeclaration).resolvedPath);
+          if (constEnumDeclaration.flags & 33554432 /* Ambient */ && (!redirect || !shouldPreserveConstEnums(redirect.commandLine.options))) {
+            error2(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
+          }
+        }
       }
       if (isImportSpecifier(node)) {
         const targetSymbol = resolveAliasWithDeprecationCheck(symbol, node);
@@ -171192,6 +171213,14 @@ function provideInlayHints(context) {
     if (!signature) {
       return;
     }
+    const typePredicate = checker.getTypePredicateOfSignature(signature);
+    if (typePredicate == null ? void 0 : typePredicate.type) {
+      const hintParts2 = typePredicateToInlayHintParts(typePredicate);
+      if (hintParts2) {
+        addTypeHints(hintParts2, getTypeAnnotationPosition(decl));
+        return;
+      }
+    }
     const returnType = checker.getReturnTypeOfSignature(signature);
     if (isModuleReferenceType(returnType)) {
       return;
@@ -171260,6 +171289,26 @@ function provideInlayHints(context) {
       );
     });
   }
+  function printTypePredicateInSingleLine(typePredicate) {
+    const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
+    const printer = createPrinterWithRemoveComments();
+    return usingSingleLineStringWriter((writer) => {
+      const typePredicateNode = checker.typePredicateToTypePredicateNode(
+        typePredicate,
+        /*enclosingDeclaration*/
+        void 0,
+        flags
+      );
+      Debug.assertIsDefined(typePredicateNode, "should always get typePredicateNode");
+      printer.writeNode(
+        4 /* Unspecified */,
+        typePredicateNode,
+        /*sourceFile*/
+        file,
+        writer
+      );
+    });
+  }
   function typeToInlayHintParts(type) {
     if (!shouldUseInteractiveInlayHints(preferences)) {
       return printTypeInSingleLine(type);
@@ -171271,29 +171320,46 @@ function provideInlayHints(context) {
       void 0,
       flags
     );
+    Debug.assertIsDefined(typeNode, "should always get typeNode");
+    return getInlayHintDisplayParts(typeNode);
+  }
+  function typePredicateToInlayHintParts(typePredicate) {
+    if (!shouldUseInteractiveInlayHints(preferences)) {
+      return printTypePredicateInSingleLine(typePredicate);
+    }
+    const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
+    const typeNode = checker.typePredicateToTypePredicateNode(
+      typePredicate,
+      /*enclosingDeclaration*/
+      void 0,
+      flags
+    );
     Debug.assertIsDefined(typeNode, "should always get typenode");
+    return getInlayHintDisplayParts(typeNode);
+  }
+  function getInlayHintDisplayParts(node) {
     const parts = [];
-    visitForDisplayParts(typeNode);
+    visitForDisplayParts(node);
     return parts;
-    function visitForDisplayParts(node) {
+    function visitForDisplayParts(node2) {
       var _a, _b;
-      if (!node) {
+      if (!node2) {
         return;
       }
-      const tokenString = tokenToString(node.kind);
+      const tokenString = tokenToString(node2.kind);
       if (tokenString) {
         parts.push({ text: tokenString });
         return;
       }
-      if (isLiteralExpression(node)) {
-        parts.push({ text: getLiteralText2(node) });
+      if (isLiteralExpression(node2)) {
+        parts.push({ text: getLiteralText2(node2) });
         return;
       }
-      switch (node.kind) {
+      switch (node2.kind) {
         case 80 /* Identifier */:
-          Debug.assertNode(node, isIdentifier);
-          const identifierText = idText(node);
-          const name = node.symbol && node.symbol.declarations && node.symbol.declarations.length && getNameOfDeclaration(node.symbol.declarations[0]);
+          Debug.assertNode(node2, isIdentifier);
+          const identifierText = idText(node2);
+          const name = node2.symbol && node2.symbol.declarations && node2.symbol.declarations.length && getNameOfDeclaration(node2.symbol.declarations[0]);
           if (name) {
             parts.push(getNodeDisplayPart(identifierText, name));
           } else {
@@ -171301,331 +171367,331 @@ function provideInlayHints(context) {
           }
           break;
         case 166 /* QualifiedName */:
-          Debug.assertNode(node, isQualifiedName);
-          visitForDisplayParts(node.left);
+          Debug.assertNode(node2, isQualifiedName);
+          visitForDisplayParts(node2.left);
           parts.push({ text: "." });
-          visitForDisplayParts(node.right);
+          visitForDisplayParts(node2.right);
           break;
         case 182 /* TypePredicate */:
-          Debug.assertNode(node, isTypePredicateNode);
-          if (node.assertsModifier) {
+          Debug.assertNode(node2, isTypePredicateNode);
+          if (node2.assertsModifier) {
             parts.push({ text: "asserts " });
           }
-          visitForDisplayParts(node.parameterName);
-          if (node.type) {
+          visitForDisplayParts(node2.parameterName);
+          if (node2.type) {
             parts.push({ text: " is " });
-            visitForDisplayParts(node.type);
+            visitForDisplayParts(node2.type);
           }
           break;
         case 183 /* TypeReference */:
-          Debug.assertNode(node, isTypeReferenceNode);
-          visitForDisplayParts(node.typeName);
-          if (node.typeArguments) {
+          Debug.assertNode(node2, isTypeReferenceNode);
+          visitForDisplayParts(node2.typeName);
+          if (node2.typeArguments) {
             parts.push({ text: "<" });
-            visitDisplayPartList(node.typeArguments, ", ");
+            visitDisplayPartList(node2.typeArguments, ", ");
             parts.push({ text: ">" });
           }
           break;
         case 168 /* TypeParameter */:
-          Debug.assertNode(node, isTypeParameterDeclaration);
-          if (node.modifiers) {
-            visitDisplayPartList(node.modifiers, " ");
+          Debug.assertNode(node2, isTypeParameterDeclaration);
+          if (node2.modifiers) {
+            visitDisplayPartList(node2.modifiers, " ");
           }
-          visitForDisplayParts(node.name);
-          if (node.constraint) {
+          visitForDisplayParts(node2.name);
+          if (node2.constraint) {
             parts.push({ text: " extends " });
-            visitForDisplayParts(node.constraint);
+            visitForDisplayParts(node2.constraint);
           }
-          if (node.default) {
+          if (node2.default) {
             parts.push({ text: " = " });
-            visitForDisplayParts(node.default);
+            visitForDisplayParts(node2.default);
           }
           break;
         case 169 /* Parameter */:
-          Debug.assertNode(node, isParameter);
-          if (node.modifiers) {
-            visitDisplayPartList(node.modifiers, " ");
+          Debug.assertNode(node2, isParameter);
+          if (node2.modifiers) {
+            visitDisplayPartList(node2.modifiers, " ");
           }
-          if (node.dotDotDotToken) {
+          if (node2.dotDotDotToken) {
             parts.push({ text: "..." });
           }
-          visitForDisplayParts(node.name);
-          if (node.questionToken) {
+          visitForDisplayParts(node2.name);
+          if (node2.questionToken) {
             parts.push({ text: "?" });
           }
-          if (node.type) {
+          if (node2.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(node.type);
+            visitForDisplayParts(node2.type);
           }
           break;
         case 185 /* ConstructorType */:
-          Debug.assertNode(node, isConstructorTypeNode);
+          Debug.assertNode(node2, isConstructorTypeNode);
           parts.push({ text: "new " });
-          visitParametersAndTypeParameters(node);
+          visitParametersAndTypeParameters(node2);
           parts.push({ text: " => " });
-          visitForDisplayParts(node.type);
+          visitForDisplayParts(node2.type);
           break;
         case 186 /* TypeQuery */:
-          Debug.assertNode(node, isTypeQueryNode);
+          Debug.assertNode(node2, isTypeQueryNode);
           parts.push({ text: "typeof " });
-          visitForDisplayParts(node.exprName);
-          if (node.typeArguments) {
+          visitForDisplayParts(node2.exprName);
+          if (node2.typeArguments) {
             parts.push({ text: "<" });
-            visitDisplayPartList(node.typeArguments, ", ");
+            visitDisplayPartList(node2.typeArguments, ", ");
             parts.push({ text: ">" });
           }
           break;
         case 187 /* TypeLiteral */:
-          Debug.assertNode(node, isTypeLiteralNode);
+          Debug.assertNode(node2, isTypeLiteralNode);
           parts.push({ text: "{" });
-          if (node.members.length) {
+          if (node2.members.length) {
             parts.push({ text: " " });
-            visitDisplayPartList(node.members, "; ");
+            visitDisplayPartList(node2.members, "; ");
             parts.push({ text: " " });
           }
           parts.push({ text: "}" });
           break;
         case 188 /* ArrayType */:
-          Debug.assertNode(node, isArrayTypeNode);
-          visitForDisplayParts(node.elementType);
+          Debug.assertNode(node2, isArrayTypeNode);
+          visitForDisplayParts(node2.elementType);
           parts.push({ text: "[]" });
           break;
         case 189 /* TupleType */:
-          Debug.assertNode(node, isTupleTypeNode);
+          Debug.assertNode(node2, isTupleTypeNode);
           parts.push({ text: "[" });
-          visitDisplayPartList(node.elements, ", ");
+          visitDisplayPartList(node2.elements, ", ");
           parts.push({ text: "]" });
           break;
         case 202 /* NamedTupleMember */:
-          Debug.assertNode(node, isNamedTupleMember);
-          if (node.dotDotDotToken) {
+          Debug.assertNode(node2, isNamedTupleMember);
+          if (node2.dotDotDotToken) {
             parts.push({ text: "..." });
           }
-          visitForDisplayParts(node.name);
-          if (node.questionToken) {
+          visitForDisplayParts(node2.name);
+          if (node2.questionToken) {
             parts.push({ text: "?" });
           }
           parts.push({ text: ": " });
-          visitForDisplayParts(node.type);
+          visitForDisplayParts(node2.type);
           break;
         case 190 /* OptionalType */:
-          Debug.assertNode(node, isOptionalTypeNode);
-          visitForDisplayParts(node.type);
+          Debug.assertNode(node2, isOptionalTypeNode);
+          visitForDisplayParts(node2.type);
           parts.push({ text: "?" });
           break;
         case 191 /* RestType */:
-          Debug.assertNode(node, isRestTypeNode);
+          Debug.assertNode(node2, isRestTypeNode);
           parts.push({ text: "..." });
-          visitForDisplayParts(node.type);
+          visitForDisplayParts(node2.type);
           break;
         case 192 /* UnionType */:
-          Debug.assertNode(node, isUnionTypeNode);
-          visitDisplayPartList(node.types, " | ");
+          Debug.assertNode(node2, isUnionTypeNode);
+          visitDisplayPartList(node2.types, " | ");
           break;
         case 193 /* IntersectionType */:
-          Debug.assertNode(node, isIntersectionTypeNode);
-          visitDisplayPartList(node.types, " & ");
+          Debug.assertNode(node2, isIntersectionTypeNode);
+          visitDisplayPartList(node2.types, " & ");
           break;
         case 194 /* ConditionalType */:
-          Debug.assertNode(node, isConditionalTypeNode);
-          visitForDisplayParts(node.checkType);
+          Debug.assertNode(node2, isConditionalTypeNode);
+          visitForDisplayParts(node2.checkType);
           parts.push({ text: " extends " });
-          visitForDisplayParts(node.extendsType);
+          visitForDisplayParts(node2.extendsType);
           parts.push({ text: " ? " });
-          visitForDisplayParts(node.trueType);
+          visitForDisplayParts(node2.trueType);
           parts.push({ text: " : " });
-          visitForDisplayParts(node.falseType);
+          visitForDisplayParts(node2.falseType);
           break;
         case 195 /* InferType */:
-          Debug.assertNode(node, isInferTypeNode);
+          Debug.assertNode(node2, isInferTypeNode);
           parts.push({ text: "infer " });
-          visitForDisplayParts(node.typeParameter);
+          visitForDisplayParts(node2.typeParameter);
           break;
         case 196 /* ParenthesizedType */:
-          Debug.assertNode(node, isParenthesizedTypeNode);
+          Debug.assertNode(node2, isParenthesizedTypeNode);
           parts.push({ text: "(" });
-          visitForDisplayParts(node.type);
+          visitForDisplayParts(node2.type);
           parts.push({ text: ")" });
           break;
         case 198 /* TypeOperator */:
-          Debug.assertNode(node, isTypeOperatorNode);
-          parts.push({ text: `${tokenToString(node.operator)} ` });
-          visitForDisplayParts(node.type);
+          Debug.assertNode(node2, isTypeOperatorNode);
+          parts.push({ text: `${tokenToString(node2.operator)} ` });
+          visitForDisplayParts(node2.type);
           break;
         case 199 /* IndexedAccessType */:
-          Debug.assertNode(node, isIndexedAccessTypeNode);
-          visitForDisplayParts(node.objectType);
+          Debug.assertNode(node2, isIndexedAccessTypeNode);
+          visitForDisplayParts(node2.objectType);
           parts.push({ text: "[" });
-          visitForDisplayParts(node.indexType);
+          visitForDisplayParts(node2.indexType);
           parts.push({ text: "]" });
           break;
         case 200 /* MappedType */:
-          Debug.assertNode(node, isMappedTypeNode);
+          Debug.assertNode(node2, isMappedTypeNode);
           parts.push({ text: "{ " });
-          if (node.readonlyToken) {
-            if (node.readonlyToken.kind === 40 /* PlusToken */) {
+          if (node2.readonlyToken) {
+            if (node2.readonlyToken.kind === 40 /* PlusToken */) {
               parts.push({ text: "+" });
-            } else if (node.readonlyToken.kind === 41 /* MinusToken */) {
+            } else if (node2.readonlyToken.kind === 41 /* MinusToken */) {
               parts.push({ text: "-" });
             }
             parts.push({ text: "readonly " });
           }
           parts.push({ text: "[" });
-          visitForDisplayParts(node.typeParameter);
-          if (node.nameType) {
+          visitForDisplayParts(node2.typeParameter);
+          if (node2.nameType) {
             parts.push({ text: " as " });
-            visitForDisplayParts(node.nameType);
+            visitForDisplayParts(node2.nameType);
           }
           parts.push({ text: "]" });
-          if (node.questionToken) {
-            if (node.questionToken.kind === 40 /* PlusToken */) {
+          if (node2.questionToken) {
+            if (node2.questionToken.kind === 40 /* PlusToken */) {
               parts.push({ text: "+" });
-            } else if (node.questionToken.kind === 41 /* MinusToken */) {
+            } else if (node2.questionToken.kind === 41 /* MinusToken */) {
               parts.push({ text: "-" });
             }
             parts.push({ text: "?" });
           }
           parts.push({ text: ": " });
-          if (node.type) {
-            visitForDisplayParts(node.type);
+          if (node2.type) {
+            visitForDisplayParts(node2.type);
           }
           parts.push({ text: "; }" });
           break;
         case 201 /* LiteralType */:
-          Debug.assertNode(node, isLiteralTypeNode);
-          visitForDisplayParts(node.literal);
+          Debug.assertNode(node2, isLiteralTypeNode);
+          visitForDisplayParts(node2.literal);
           break;
         case 184 /* FunctionType */:
-          Debug.assertNode(node, isFunctionTypeNode);
-          visitParametersAndTypeParameters(node);
+          Debug.assertNode(node2, isFunctionTypeNode);
+          visitParametersAndTypeParameters(node2);
           parts.push({ text: " => " });
-          visitForDisplayParts(node.type);
+          visitForDisplayParts(node2.type);
           break;
         case 205 /* ImportType */:
-          Debug.assertNode(node, isImportTypeNode);
-          if (node.isTypeOf) {
+          Debug.assertNode(node2, isImportTypeNode);
+          if (node2.isTypeOf) {
             parts.push({ text: "typeof " });
           }
           parts.push({ text: "import(" });
-          visitForDisplayParts(node.argument);
-          if (node.assertions) {
+          visitForDisplayParts(node2.argument);
+          if (node2.assertions) {
             parts.push({ text: ", { assert: " });
-            visitDisplayPartList(node.assertions.assertClause.elements, ", ");
+            visitDisplayPartList(node2.assertions.assertClause.elements, ", ");
             parts.push({ text: " }" });
           }
           parts.push({ text: ")" });
-          if (node.qualifier) {
+          if (node2.qualifier) {
             parts.push({ text: "." });
-            visitForDisplayParts(node.qualifier);
+            visitForDisplayParts(node2.qualifier);
           }
-          if (node.typeArguments) {
+          if (node2.typeArguments) {
             parts.push({ text: "<" });
-            visitDisplayPartList(node.typeArguments, ", ");
+            visitDisplayPartList(node2.typeArguments, ", ");
             parts.push({ text: ">" });
           }
           break;
         case 171 /* PropertySignature */:
-          Debug.assertNode(node, isPropertySignature);
-          if ((_a = node.modifiers) == null ? void 0 : _a.length) {
-            visitDisplayPartList(node.modifiers, " ");
+          Debug.assertNode(node2, isPropertySignature);
+          if ((_a = node2.modifiers) == null ? void 0 : _a.length) {
+            visitDisplayPartList(node2.modifiers, " ");
             parts.push({ text: " " });
           }
-          visitForDisplayParts(node.name);
-          if (node.questionToken) {
+          visitForDisplayParts(node2.name);
+          if (node2.questionToken) {
             parts.push({ text: "?" });
           }
-          if (node.type) {
+          if (node2.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(node.type);
+            visitForDisplayParts(node2.type);
           }
           break;
         case 181 /* IndexSignature */:
-          Debug.assertNode(node, isIndexSignatureDeclaration);
+          Debug.assertNode(node2, isIndexSignatureDeclaration);
           parts.push({ text: "[" });
-          visitDisplayPartList(node.parameters, ", ");
+          visitDisplayPartList(node2.parameters, ", ");
           parts.push({ text: "]" });
-          if (node.type) {
+          if (node2.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(node.type);
+            visitForDisplayParts(node2.type);
           }
           break;
         case 173 /* MethodSignature */:
-          Debug.assertNode(node, isMethodSignature);
-          if ((_b = node.modifiers) == null ? void 0 : _b.length) {
-            visitDisplayPartList(node.modifiers, " ");
+          Debug.assertNode(node2, isMethodSignature);
+          if ((_b = node2.modifiers) == null ? void 0 : _b.length) {
+            visitDisplayPartList(node2.modifiers, " ");
             parts.push({ text: " " });
           }
-          visitForDisplayParts(node.name);
-          if (node.questionToken) {
+          visitForDisplayParts(node2.name);
+          if (node2.questionToken) {
             parts.push({ text: "?" });
           }
-          visitParametersAndTypeParameters(node);
-          if (node.type) {
+          visitParametersAndTypeParameters(node2);
+          if (node2.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(node.type);
+            visitForDisplayParts(node2.type);
           }
           break;
         case 179 /* CallSignature */:
-          Debug.assertNode(node, isCallSignatureDeclaration);
-          visitParametersAndTypeParameters(node);
-          if (node.type) {
+          Debug.assertNode(node2, isCallSignatureDeclaration);
+          visitParametersAndTypeParameters(node2);
+          if (node2.type) {
             parts.push({ text: ": " });
-            visitForDisplayParts(node.type);
+            visitForDisplayParts(node2.type);
           }
           break;
         case 207 /* ArrayBindingPattern */:
-          Debug.assertNode(node, isArrayBindingPattern);
+          Debug.assertNode(node2, isArrayBindingPattern);
           parts.push({ text: "[" });
-          visitDisplayPartList(node.elements, ", ");
+          visitDisplayPartList(node2.elements, ", ");
           parts.push({ text: "]" });
           break;
         case 206 /* ObjectBindingPattern */:
-          Debug.assertNode(node, isObjectBindingPattern);
+          Debug.assertNode(node2, isObjectBindingPattern);
           parts.push({ text: "{" });
-          if (node.elements.length) {
+          if (node2.elements.length) {
             parts.push({ text: " " });
-            visitDisplayPartList(node.elements, ", ");
+            visitDisplayPartList(node2.elements, ", ");
             parts.push({ text: " " });
           }
           parts.push({ text: "}" });
           break;
         case 208 /* BindingElement */:
-          Debug.assertNode(node, isBindingElement);
-          visitForDisplayParts(node.name);
+          Debug.assertNode(node2, isBindingElement);
+          visitForDisplayParts(node2.name);
           break;
         case 224 /* PrefixUnaryExpression */:
-          Debug.assertNode(node, isPrefixUnaryExpression);
-          parts.push({ text: tokenToString(node.operator) });
-          visitForDisplayParts(node.operand);
+          Debug.assertNode(node2, isPrefixUnaryExpression);
+          parts.push({ text: tokenToString(node2.operator) });
+          visitForDisplayParts(node2.operand);
           break;
         case 203 /* TemplateLiteralType */:
-          Debug.assertNode(node, isTemplateLiteralTypeNode);
-          visitForDisplayParts(node.head);
-          node.templateSpans.forEach(visitForDisplayParts);
+          Debug.assertNode(node2, isTemplateLiteralTypeNode);
+          visitForDisplayParts(node2.head);
+          node2.templateSpans.forEach(visitForDisplayParts);
           break;
         case 16 /* TemplateHead */:
-          Debug.assertNode(node, isTemplateHead);
-          parts.push({ text: getLiteralText2(node) });
+          Debug.assertNode(node2, isTemplateHead);
+          parts.push({ text: getLiteralText2(node2) });
           break;
         case 204 /* TemplateLiteralTypeSpan */:
-          Debug.assertNode(node, isTemplateLiteralTypeSpan);
-          visitForDisplayParts(node.type);
-          visitForDisplayParts(node.literal);
+          Debug.assertNode(node2, isTemplateLiteralTypeSpan);
+          visitForDisplayParts(node2.type);
+          visitForDisplayParts(node2.literal);
           break;
         case 17 /* TemplateMiddle */:
-          Debug.assertNode(node, isTemplateMiddle);
-          parts.push({ text: getLiteralText2(node) });
+          Debug.assertNode(node2, isTemplateMiddle);
+          parts.push({ text: getLiteralText2(node2) });
           break;
         case 18 /* TemplateTail */:
-          Debug.assertNode(node, isTemplateTail);
-          parts.push({ text: getLiteralText2(node) });
+          Debug.assertNode(node2, isTemplateTail);
+          parts.push({ text: getLiteralText2(node2) });
           break;
         case 197 /* ThisType */:
-          Debug.assertNode(node, isThisTypeNode);
+          Debug.assertNode(node2, isThisTypeNode);
           parts.push({ text: "this" });
           break;
         default:
-          Debug.failBadSyntaxKind(node);
+          Debug.failBadSyntaxKind(node2);
       }
     }
     function visitParametersAndTypeParameters(signatureDeclaration) {
@@ -171639,22 +171705,22 @@ function provideInlayHints(context) {
       parts.push({ text: ")" });
     }
     function visitDisplayPartList(nodes, separator) {
-      nodes.forEach((node, index) => {
+      nodes.forEach((node2, index) => {
         if (index > 0) {
           parts.push({ text: separator });
         }
-        visitForDisplayParts(node);
+        visitForDisplayParts(node2);
       });
     }
-    function getLiteralText2(node) {
-      switch (node.kind) {
+    function getLiteralText2(node2) {
+      switch (node2.kind) {
         case 11 /* StringLiteral */:
-          return quotePreference === 0 /* Single */ ? `'${escapeString(node.text, 39 /* singleQuote */)}'` : `"${escapeString(node.text, 34 /* doubleQuote */)}"`;
+          return quotePreference === 0 /* Single */ ? `'${escapeString(node2.text, 39 /* singleQuote */)}'` : `"${escapeString(node2.text, 34 /* doubleQuote */)}"`;
         case 16 /* TemplateHead */:
         case 17 /* TemplateMiddle */:
         case 18 /* TemplateTail */: {
-          const rawText = node.rawText ?? escapeTemplateSubstitution(escapeString(node.text, 96 /* backtick */));
-          switch (node.kind) {
+          const rawText = node2.rawText ?? escapeTemplateSubstitution(escapeString(node2.text, 96 /* backtick */));
+          switch (node2.kind) {
             case 16 /* TemplateHead */:
               return "`" + rawText + "${";
             case 17 /* TemplateMiddle */:
@@ -171664,7 +171730,7 @@ function provideInlayHints(context) {
           }
         }
       }
-      return node.text;
+      return node2.text;
     }
   }
   function isUndefined(name) {