typescript 5.2.0-dev.20230719 → 5.2.0-dev.20230721

package/lib/tsserver.js

@@ -970,6 +970,7 @@ __export(server_exports, {
   getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
+  getPropertyNameFromType: () => getPropertyNameFromType,
   getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
   getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
   getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
@@ -1802,6 +1803,7 @@ __export(server_exports, {
   isTypeQueryNode: () => isTypeQueryNode,
   isTypeReferenceNode: () => isTypeReferenceNode,
   isTypeReferenceType: () => isTypeReferenceType,
+  isTypeUsableAsPropertyName: () => isTypeUsableAsPropertyName,
   isUMDExportSymbol: () => isUMDExportSymbol,
   isUnaryExpression: () => isUnaryExpression,
   isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,
@@ -2327,7 +2329,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-dev.20230719`;
+var version = `${versionMajorMinor}.0-dev.20230721`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -21601,6 +21603,18 @@ function getTextOfJsxNamespacedName(node) {
 function intrinsicTagNameToString(node) {
   return isIdentifier(node) ? idText(node) : getTextOfJsxNamespacedName(node);
 }
+function isTypeUsableAsPropertyName(type) {
+  return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
+}
+function getPropertyNameFromType(type) {
+  if (type.flags & 8192 /* UniqueESSymbol */) {
+    return type.escapedName;
+  }
+  if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
+    return escapeLeadingUnderscores("" + type.value);
+  }
+  return Debug.fail();
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -35109,10 +35123,14 @@ var Parser;
         case 124 /* ProtectedKeyword */:
         case 125 /* PublicKeyword */:
         case 148 /* ReadonlyKeyword */:
+          const previousToken = token();
           nextToken();
           if (scanner2.hasPrecedingLineBreak()) {
             return false;
           }
+          if (previousToken === 138 /* DeclareKeyword */ && token() === 156 /* TypeKeyword */) {
+            return true;
+          }
           continue;
         case 162 /* GlobalKeyword */:
           nextToken();
@@ -35477,14 +35495,14 @@ var Parser;
   function parseObjectBindingPattern() {
     const pos = getNodePos();
     parseExpected(19 /* OpenBraceToken */);
-    const elements = parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement);
+    const elements = allowInAnd(() => parseDelimitedList(9 /* ObjectBindingElements */, parseObjectBindingElement));
     parseExpected(20 /* CloseBraceToken */);
     return finishNode(factory2.createObjectBindingPattern(elements), pos);
   }
   function parseArrayBindingPattern() {
     const pos = getNodePos();
     parseExpected(23 /* OpenBracketToken */);
-    const elements = parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement);
+    const elements = allowInAnd(() => parseDelimitedList(10 /* ArrayBindingElements */, parseArrayBindingElement));
     parseExpected(24 /* CloseBracketToken */);
     return finishNode(factory2.createArrayBindingPattern(elements), pos);
   }
@@ -36002,6 +36020,9 @@ var Parser;
   }
   function parseTypeAliasDeclaration(pos, hasJSDoc, modifiers) {
     parseExpected(156 /* TypeKeyword */);
+    if (scanner2.hasPrecedingLineBreak()) {
+      parseErrorAtCurrentToken(Diagnostics.Line_break_not_permitted_here);
+    }
     const name = parseIdentifier();
     const typeParameters = parseTypeParameters();
     parseExpected(64 /* EqualsToken */);
@@ -47818,7 +47839,7 @@ function createTypeChecker(host) {
       return node ? getTypeFromTypeNode(node) : errorType;
     },
     getParameterType: getTypeAtPosition,
-    getParameterIdentifierNameAtPosition,
+    getParameterIdentifierInfoAtPosition,
     getPromisedTypeOfPromise,
     getAwaitedType: (type) => getAwaitedType(type),
     getReturnTypeOfSignature,
@@ -49259,7 +49280,7 @@ function createTypeChecker(host) {
         if (name === "const" && isConstAssertion(location)) {
           return void 0;
         }
-        if (isModuleDeclaration(location) && lastLocation && location.name === lastLocation) {
+        if (isModuleOrEnumDeclaration(location) && lastLocation && location.name === lastLocation) {
           lastLocation = location;
           location = location.parent;
         }
@@ -56281,7 +56302,7 @@ function createTypeChecker(host) {
       false,
       definedInMethod && !definedInConstructor
     ));
-    if (symbol.valueDeclaration && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
+    if (symbol.valueDeclaration && isInJSFile(symbol.valueDeclaration) && filterType(widened, (t) => !!(t.flags & ~98304 /* Nullable */)) === neverType) {
       reportImplicitAny(symbol.valueDeclaration, anyType);
       return anyType;
     }
@@ -57560,9 +57581,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function isTypeUsableAsPropertyName(type) {
-    return !!(type.flags & 8576 /* StringOrNumberLiteralOrUnique */);
-  }
   function isLateBindableName(node) {
     if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
       return false;
@@ -57583,15 +57601,6 @@ function createTypeChecker(host) {
   function isNonBindableDynamicName(node) {
     return isDynamicName(node) && !isLateBindableName(node);
   }
-  function getPropertyNameFromType(type) {
-    if (type.flags & 8192 /* UniqueESSymbol */) {
-      return type.escapedName;
-    }
-    if (type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */)) {
-      return escapeLeadingUnderscores("" + type.value);
-    }
-    return Debug.fail();
-  }
   function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) {
     Debug.assert(!!(getCheckFlags(symbol) & 4096 /* Late */), "Expected a late-bound symbol.");
     symbol.flags |= symbolFlags;
@@ -57641,6 +57650,7 @@ function createTypeChecker(host) {
     return links.resolvedSymbol;
   }
   function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
+    var _a, _b, _c;
     const links = getSymbolLinks(symbol);
     if (!links[resolutionKind]) {
       const isStatic2 = resolutionKind === "resolvedExports" /* resolvedExports */;
@@ -57659,7 +57669,7 @@ function createTypeChecker(host) {
           }
         }
       }
-      const assignments = symbol.assignmentDeclarationMembers;
+      const assignments = (((_a = symbol.valueDeclaration) == null ? void 0 : _a.kind) === 219 /* ArrowFunction */ || ((_b = symbol.valueDeclaration) == null ? void 0 : _b.kind) === 218 /* FunctionExpression */) && ((_c = getSymbolOfNode(symbol.valueDeclaration.parent)) == null ? void 0 : _c.assignmentDeclarationMembers) || symbol.assignmentDeclarationMembers;
       if (assignments) {
         const decls = arrayFrom(assignments.values());
         for (const member of decls) {
@@ -58237,20 +58247,17 @@ function createTypeChecker(host) {
       setStructuredTypeMembers(type, members2, callSignatures, constructSignatures, indexInfos2);
       return;
     }
-    let members = emptySymbols;
+    let members = getExportsOfSymbol(symbol);
     let indexInfos;
-    if (symbol.exports) {
-      members = getExportsOfSymbol(symbol);
-      if (symbol === globalThisSymbol) {
-        const varsOnly = /* @__PURE__ */ new Map();
-        members.forEach((p) => {
-          var _a;
-          if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a = p.declarations) == null ? void 0 : _a.length) && every(p.declarations, isAmbientModule))) {
-            varsOnly.set(p.escapedName, p);
-          }
-        });
-        members = varsOnly;
-      }
+    if (symbol === globalThisSymbol) {
+      const varsOnly = /* @__PURE__ */ new Map();
+      members.forEach((p) => {
+        var _a;
+        if (!(p.flags & 418 /* BlockScoped */) && !(p.flags & 512 /* ValueModule */ && ((_a = p.declarations) == null ? void 0 : _a.length) && every(p.declarations, isAmbientModule))) {
+          varsOnly.set(p.escapedName, p);
+        }
+      });
+      members = varsOnly;
     }
     let baseConstructorIndexInfo;
     setStructuredTypeMembers(type, members, emptyArray, emptyArray, emptyArray);
@@ -70343,12 +70350,15 @@ function createTypeChecker(host) {
             return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
           }
           const target = getReferenceCandidate(expr.right);
-          const leftType = getTypeOfExpression(expr.left);
-          if (leftType.flags & 8576 /* StringOrNumberLiteralOrUnique */) {
-            if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target) && getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
+          if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target)) {
+            const leftType = getTypeOfExpression(expr.left);
+            if (isTypeUsableAsPropertyName(leftType) && getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) {
               return getTypeWithFacts(type, assumeTrue ? 524288 /* NEUndefined */ : 65536 /* EQUndefined */);
             }
-            if (isMatchingReference(reference, target)) {
+          }
+          if (isMatchingReference(reference, target)) {
+            const leftType = getTypeOfExpression(expr.left);
+            if (isTypeUsableAsPropertyName(leftType)) {
               return narrowTypeByInKeyword(type, leftType, assumeTrue);
             }
           }
@@ -76759,7 +76769,7 @@ function createTypeChecker(host) {
     }
     return restParameter.escapedName;
   }
-  function getParameterIdentifierNameAtPosition(signature, pos) {
+  function getParameterIdentifierInfoAtPosition(signature, pos) {
     var _a;
     if (((_a = signature.declaration) == null ? void 0 : _a.kind) === 324 /* JSDocFunctionType */) {
       return void 0;
@@ -76767,10 +76777,16 @@ function createTypeChecker(host) {
     const paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0);
     if (pos < paramCount) {
       const param = signature.parameters[pos];
-      return isParameterDeclarationWithIdentifierName(param) ? [param.escapedName, false] : void 0;
+      const paramIdent = getParameterDeclarationIdentifier(param);
+      return paramIdent ? {
+        parameter: paramIdent,
+        parameterName: param.escapedName,
+        isRestParameter: false
+      } : void 0;
     }
     const restParameter = signature.parameters[paramCount] || unknownSymbol;
-    if (!isParameterDeclarationWithIdentifierName(restParameter)) {
+    const restIdent = getParameterDeclarationIdentifier(restParameter);
+    if (!restIdent) {
       return void 0;
     }
     const restType = getTypeOfSymbol(restParameter);
@@ -76779,18 +76795,19 @@ function createTypeChecker(host) {
       const index = pos - paramCount;
       const associatedName = associatedNames == null ? void 0 : associatedNames[index];
       const isRestTupleElement = !!(associatedName == null ? void 0 : associatedName.dotDotDotToken);
-      return associatedName ? [
-        getTupleElementLabel(associatedName),
-        isRestTupleElement
-      ] : void 0;
+      if (associatedName) {
+        Debug.assert(isIdentifier(associatedName.name));
+        return { parameter: associatedName.name, parameterName: associatedName.name.escapedText, isRestParameter: isRestTupleElement };
+      }
+      return void 0;
     }
     if (pos === paramCount) {
-      return [restParameter.escapedName, true];
+      return { parameter: restIdent, parameterName: restParameter.escapedName, isRestParameter: true };
     }
     return void 0;
   }
-  function isParameterDeclarationWithIdentifierName(symbol) {
-    return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name);
+  function getParameterDeclarationIdentifier(symbol) {
+    return symbol.valueDeclaration && isParameter(symbol.valueDeclaration) && isIdentifier(symbol.valueDeclaration.name) && symbol.valueDeclaration.name;
   }
   function isValidDeclarationForTupleLabel(d) {
     return d.kind === 202 /* NamedTupleMember */ || isParameter(d) && d.name && isIdentifier(d.name);
@@ -155118,15 +155135,11 @@ var PreserveOptionalFlags = /* @__PURE__ */ ((PreserveOptionalFlags2) => {
 })(PreserveOptionalFlags || {});
 function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional = 3 /* All */, isAmbient = false) {
   const declarations = symbol.getDeclarations();
-  const declaration = declarations == null ? void 0 : declarations[0];
+  const declaration = firstOrUndefined(declarations);
   const checker = context.program.getTypeChecker();
   const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
   const kind = (declaration == null ? void 0 : declaration.kind) ?? 171 /* PropertySignature */;
-  const declarationName = getSynthesizedDeepClone(
-    getNameOfDeclaration(declaration),
-    /*includeTrivia*/
-    false
-  );
+  const declarationName = createDeclarationName(symbol, declaration);
   const effectiveModifierFlags = declaration ? getEffectiveModifierFlags(declaration) : 0 /* None */;
   let modifierFlags = effectiveModifierFlags & 32 /* Static */;
   modifierFlags |= effectiveModifierFlags & 4 /* Public */ ? 4 /* Public */ : effectiveModifierFlags & 16 /* Protected */ ? 16 /* Protected */ : 0 /* None */;
@@ -155277,6 +155290,19 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
       false
     );
   }
+  function createDeclarationName(symbol2, declaration2) {
+    if (getCheckFlags(symbol2) & 262144 /* Mapped */) {
+      const nameType = symbol2.links.nameType;
+      if (nameType && isTypeUsableAsPropertyName(nameType)) {
+        return factory.createIdentifier(unescapeLeadingUnderscores(getPropertyNameFromType(nameType)));
+      }
+    }
+    return getSynthesizedDeepClone(
+      getNameOfDeclaration(declaration2),
+      /*includeTrivia*/
+      false
+    );
+  }
 }
 function createSignatureDeclarationFromSignature(kind, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder) {
   const program = context.program;
@@ -164494,7 +164520,7 @@ __export(ts_InlayHints_exports, {
 });
 
 // src/services/inlayHints.ts
-var maxHintsLength = 30;
+var maxTypeHintLength = 30;
 var leadingParameterNameCommentRegexFactory = (name) => {
   return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
 };
@@ -164504,6 +164530,9 @@ function shouldShowParameterNameHints(preferences) {
 function shouldShowLiteralParameterNameHintsOnly(preferences) {
   return preferences.includeInlayParameterNameHints === "literals";
 }
+function shouldUseInteractiveInlayHints(preferences) {
+  return preferences.interactiveInlayHints === true;
+}
 function provideInlayHints(context) {
   const { file, program, span, cancellationToken, preferences } = context;
   const sourceFileText = file.text;
@@ -164554,9 +164583,15 @@ function provideInlayHints(context) {
   function isSignatureSupportingReturnAnnotation(node) {
     return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
   }
-  function addParameterHints(text, position, isFirstVariadicArgument) {
+  function addParameterHints(text, parameter, position, isFirstVariadicArgument, sourceFile) {
+    let hintText = `${isFirstVariadicArgument ? "..." : ""}${text}`;
+    if (shouldUseInteractiveInlayHints(preferences)) {
+      hintText = [getNodeDisplayPart(hintText, parameter, sourceFile), { text: ":" }];
+    } else {
+      hintText += ":";
+    }
     result.push({
-      text: `${isFirstVariadicArgument ? "..." : ""}${truncation(text, maxHintsLength)}:`,
+      text: hintText,
       position,
       kind: "Parameter" /* Parameter */,
       whitespaceAfter: true
@@ -164564,7 +164599,7 @@ function provideInlayHints(context) {
   }
   function addTypeHints(text, position) {
     result.push({
-      text: `: ${truncation(text, maxHintsLength)}`,
+      text: `: ${text.length > maxTypeHintLength ? text.substr(0, maxTypeHintLength - "...".length) + "..." : text}`,
       position,
       kind: "Type" /* Type */,
       whitespaceBefore: true
@@ -164572,7 +164607,7 @@ function provideInlayHints(context) {
   }
   function addEnumMemberValueHints(text, position) {
     result.push({
-      text: `= ${truncation(text, maxHintsLength)}`,
+      text: `= ${text}`,
       position,
       kind: "Enum" /* Enum */,
       whitespaceBefore: true
@@ -164622,6 +164657,7 @@ function provideInlayHints(context) {
       return;
     }
     let signatureParamPos = 0;
+    const sourceFile = shouldUseInteractiveInlayHints(preferences) ? expr.getSourceFile() : void 0;
     for (const originalArg of args) {
       const arg = skipParentheses(originalArg);
       if (shouldShowLiteralParameterNameHintsOnly(preferences) && !isHintableLiteral(arg)) {
@@ -164642,10 +164678,10 @@ function provideInlayHints(context) {
           }
         }
       }
-      const identifierNameInfo = checker.getParameterIdentifierNameAtPosition(signature, signatureParamPos);
+      const identifierInfo = checker.getParameterIdentifierInfoAtPosition(signature, signatureParamPos);
       signatureParamPos = signatureParamPos + (spreadArgs || 1);
-      if (identifierNameInfo) {
-        const [parameterName, isFirstVariadicArgument] = identifierNameInfo;
+      if (identifierInfo) {
+        const { parameter, parameterName, isRestParameter: isFirstVariadicArgument } = identifierInfo;
         const isParameterNameNotSameAsArgument = preferences.includeInlayParameterNameHintsWhenArgumentMatchesName || !identifierOrAccessExpressionPostfixMatchesParameterName(arg, parameterName);
         if (!isParameterNameNotSameAsArgument && !isFirstVariadicArgument) {
           continue;
@@ -164654,7 +164690,7 @@ function provideInlayHints(context) {
         if (leadingCommentsContainsParameterName(arg, name)) {
           continue;
         }
-        addParameterHints(name, originalArg.getStart(), isFirstVariadicArgument);
+        addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument, sourceFile);
       }
     }
   }
@@ -164760,12 +164796,6 @@ function provideInlayHints(context) {
     }
     return printTypeInSingleLine(signatureParamType);
   }
-  function truncation(text, maxLength2) {
-    if (text.length > maxLength2) {
-      return text.substr(0, maxLength2 - "...".length) + "...";
-    }
-    return text;
-  }
   function printTypeInSingleLine(type) {
     const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
     const printer = createPrinterWithRemoveComments();
@@ -164796,6 +164826,13 @@ function provideInlayHints(context) {
     }
     return true;
   }
+  function getNodeDisplayPart(text, node, sourceFile) {
+    return {
+      text,
+      span: createTextSpanFromNode(node, sourceFile),
+      file: sourceFile.fileName
+    };
+  }
 }
 
 // src/services/_namespaces/ts.JsDoc.ts
@@ -167215,7 +167252,7 @@ function getSymbolModifiers(typeChecker, symbol) {
   }
   return modifiers.size > 0 ? arrayFrom(modifiers.values()).join(",") : "" /* none */;
 }
-function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
+function getSymbolDisplayPartsDocumentationAndSymbolKindWorker(typeChecker, symbol, sourceFile, enclosingDeclaration, location, type, semanticMeaning, alias) {
   var _a;
   const displayParts = [];
   let documentation = [];
@@ -167224,7 +167261,6 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
   let symbolKind = semanticMeaning & 1 /* Value */ ? getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) : "" /* unknown */;
   let hasAddedSymbolInfo = false;
   const isThisExpression = location.kind === 110 /* ThisKeyword */ && isInExpressionContext(location) || isThisInTypeQuery(location);
-  let type;
   let documentationFromAlias;
   let tagsFromAlias;
   let hasMultipleSignatures = false;
@@ -167253,7 +167289,7 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
       }
     }
     let signature;
-    type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location);
+    type ?? (type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location));
     if (location.parent && location.parent.kind === 211 /* PropertyAccessExpression */) {
       const right = location.parent.name;
       if (right === location || right && right.getFullWidth() === 0) {
@@ -167468,12 +167504,13 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
         if (declarationName && !hasAddedSymbolInfo) {
           const isExternalModuleDeclaration = isModuleWithStringLiteralName(resolvedNode) && hasSyntacticModifier(resolvedNode, 2 /* Ambient */);
           const shouldUseAliasName = symbol.name !== "default" && !isExternalModuleDeclaration;
-          const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKind(
+          const resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
             typeChecker,
             resolvedSymbol,
             getSourceFileOfNode(resolvedNode),
             resolvedNode,
             declarationName,
+            type,
             semanticMeaning,
             shouldUseAliasName ? symbol : resolvedSymbol
           );
@@ -167728,6 +167765,19 @@ function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, so
     addRange(displayParts, typeParameterParts);
   }
 }
+function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning = getMeaningFromLocation(location), alias) {
+  return getSymbolDisplayPartsDocumentationAndSymbolKindWorker(
+    typeChecker,
+    symbol,
+    sourceFile,
+    enclosingDeclaration,
+    location,
+    /*type*/
+    void 0,
+    semanticMeaning,
+    alias
+  );
+}
 function isLocalVariableOrFunction(symbol) {
   if (symbol.parent) {
     return false;
@@ -172737,6 +172787,7 @@ __export(ts_exports2, {
   getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
+  getPropertyNameFromType: () => getPropertyNameFromType,
   getPropertyNameOfBindingOrAssignmentElement: () => getPropertyNameOfBindingOrAssignmentElement,
   getPropertySymbolFromBindingElement: () => getPropertySymbolFromBindingElement,
   getPropertySymbolsFromContextualType: () => getPropertySymbolsFromContextualType,
@@ -173569,6 +173620,7 @@ __export(ts_exports2, {
   isTypeQueryNode: () => isTypeQueryNode,
   isTypeReferenceNode: () => isTypeReferenceNode,
   isTypeReferenceType: () => isTypeReferenceType,
+  isTypeUsableAsPropertyName: () => isTypeUsableAsPropertyName,
   isUMDExportSymbol: () => isUMDExportSymbol,
   isUnaryExpression: () => isUnaryExpression,
   isUnaryExpressionWithWrite: () => isUnaryExpressionWithWrite,
@@ -183427,10 +183479,22 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
     const { file, project } = this.getFileAndProject(args);
     const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file);
     const hints = project.getLanguageService().provideInlayHints(file, args, this.getPreferences(file));
-    return hints.map((hint) => ({
-      ...hint,
-      position: scriptInfo.positionToLineOffset(hint.position)
-    }));
+    return hints.map((hint) => {
+      const { text, position } = hint;
+      const hintText = typeof text === "string" ? text : text.map(({ text: text2, span, file: file2 }) => ({
+        text: text2,
+        span: span && {
+          start: scriptInfo.positionToLineOffset(span.start),
+          end: scriptInfo.positionToLineOffset(span.start + span.length),
+          file: file2
+        }
+      }));
+      return {
+        ...hint,
+        position: scriptInfo.positionToLineOffset(position),
+        text: hintText
+      };
+    });
   }
   setCompilerOptionsForInferredProjects(args) {
     this.projectService.setCompilerOptionsForInferredProjects(args.options, args.projectRootPath);
@@ -187251,6 +187315,7 @@ start(initializeNodeSystem(), require("os").platform());
   getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol,
+  getPropertyNameFromType,
   getPropertyNameOfBindingOrAssignmentElement,
   getPropertySymbolFromBindingElement,
   getPropertySymbolsFromContextualType,
@@ -188083,6 +188148,7 @@ start(initializeNodeSystem(), require("os").platform());
   isTypeQueryNode,
   isTypeReferenceNode,
   isTypeReferenceType,
+  isTypeUsableAsPropertyName,
   isUMDExportSymbol,
   isUnaryExpression,
   isUnaryExpressionWithWrite,

package/lib/tsserverlibrary.d.ts

@@ -2124,12 +2124,16 @@ declare namespace ts {
                 arguments: InlayHintsRequestArgs;
             }
             interface InlayHintItem {
-                text: string;
+                text: string | InlayHintItemDisplayPart[];
                 position: Location;
                 kind: InlayHintKind;
                 whitespaceBefore?: boolean;
                 whitespaceAfter?: boolean;
             }
+            interface InlayHintItemDisplayPart {
+                text: string;
+                span?: FileSpan;
+            }
             interface InlayHintsResponse extends Response {
                 body?: InlayHintItem[];
             }
@@ -2832,6 +2836,7 @@ declare namespace ts {
                 readonly includeInlayPropertyDeclarationTypeHints?: boolean;
                 readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
                 readonly includeInlayEnumMemberValueHints?: boolean;
+                readonly interactiveInlayHints?: boolean;
                 readonly autoImportFileExcludePatterns?: string[];
                 /**
                  * Indicates whether imports should be organized in a case-insensitive manner.
@@ -8400,6 +8405,7 @@ declare namespace ts {
         readonly includeInlayPropertyDeclarationTypeHints?: boolean;
         readonly includeInlayFunctionLikeReturnTypeHints?: boolean;
         readonly includeInlayEnumMemberValueHints?: boolean;
+        readonly interactiveInlayHints?: boolean;
         readonly allowRenameOfImportPath?: boolean;
         readonly autoImportFileExcludePatterns?: string[];
         readonly organizeImportsIgnoreCase?: "auto" | boolean;
@@ -10382,12 +10388,17 @@ declare namespace ts {
         Enum = "Enum"
     }
     interface InlayHint {
-        text: string;
+        text: string | InlayHintDisplayPart[];
         position: number;
         kind: InlayHintKind;
         whitespaceBefore?: boolean;
         whitespaceAfter?: boolean;
     }
+    interface InlayHintDisplayPart {
+        text: string;
+        span?: TextSpan;
+        file?: string;
+    }
     interface TodoCommentDescriptor {
         text: string;
         priority: number;