typescript 5.3.0-dev.20230918 → 5.3.0-dev.20230920

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-dev.20230918`;
+var version = `${versionMajorMinor}.0-dev.20230920`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -16423,7 +16423,7 @@ function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) {
   return optionsHaveChanges(oldOptions, newOptions, affectsDeclarationPathOptionDeclarations);
 }
 function getCompilerOptionValue(options, option) {
-  return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
+  return option.strictFlag ? getStrictOptionValue(options, option.name) : option.allowJsFlag ? getAllowJSCompilerOption(options) : options[option.name];
 }
 function getJSXTransformEnabled(options) {
   const jsx = options.jsx;
@@ -34183,7 +34183,8 @@ var commandOptionsWithoutBuild = [
   {
     name: "allowJs",
     type: "boolean",
-    affectsModuleResolution: true,
+    allowJsFlag: true,
+    affectsBuildInfo: true,
     showInSimplifiedHelpView: true,
     category: Diagnostics.JavaScript_Support,
     description: Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files,
@@ -34193,6 +34194,8 @@ var commandOptionsWithoutBuild = [
     name: "checkJs",
     type: "boolean",
     affectsModuleResolution: true,
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
     showInSimplifiedHelpView: true,
     category: Diagnostics.JavaScript_Support,
     description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
@@ -34205,6 +34208,10 @@ var commandOptionsWithoutBuild = [
     affectsEmit: true,
     affectsBuildInfo: true,
     affectsModuleResolution: true,
+    // The checker emits an error when it sees JSX but this option is not set in compilerOptions.
+    // This is effectively a semantic error, so mark this option as affecting semantic diagnostics
+    // so we know to refresh errors when this option is changed.
+    affectsSemanticDiagnostics: true,
     paramType: Diagnostics.KIND,
     showInSimplifiedHelpView: true,
     category: Diagnostics.Language_and_Environment,
@@ -39922,7 +39929,7 @@ function createBinder() {
       case 36 /* ExclamationEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
       case 38 /* ExclamationEqualsEqualsToken */:
-        return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
+        return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right) || (isBooleanLiteral(expr.right) && isNarrowingExpression(expr.left) || isBooleanLiteral(expr.left) && isNarrowingExpression(expr.right));
       case 104 /* InstanceOfKeyword */:
         return isNarrowableOperand(expr.left);
       case 103 /* InKeyword */:
@@ -40242,7 +40249,7 @@ function createBinder() {
   }
   function bindCaseBlock(node) {
     const clauses = node.clauses;
-    const isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
+    const isNarrowingSwitch = node.parent.expression.kind === 112 /* TrueKeyword */ || isNarrowingExpression(node.parent.expression);
     let fallthroughFlow = unreachableFlow;
     for (let i = 0; i < clauses.length; i++) {
       const clauseStart = i;
@@ -54201,7 +54208,7 @@ function createTypeChecker(host) {
   }
   function isConstTypeVariable(type, depth = 0) {
     var _a;
-    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
+    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
   }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -65549,6 +65556,17 @@ function createTypeChecker(host) {
         type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
       } else if (expr.kind === 221 /* TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
         type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+      } else if (expr.kind === 112 /* TrueKeyword */) {
+        const clause = flow.switchStatement.caseBlock.clauses.find((_, index) => index === flow.clauseStart);
+        const clauseExpression = clause && clause.kind === 296 /* CaseClause */ ? clause.expression : void 0;
+        if (clauseExpression) {
+          type = narrowType(
+            type,
+            clauseExpression,
+            /*assumeTrue*/
+            true
+          );
+        }
       } else {
         if (strictNullChecks) {
           if (optionalChainContainsReference(expr, reference)) {
@@ -65796,6 +65814,10 @@ function createTypeChecker(host) {
       }
       return type;
     }
+    function narrowTypeByBooleanComparison(type, expr, bool, operator, assumeTrue) {
+      assumeTrue = assumeTrue !== (bool.kind === 112 /* TrueKeyword */) !== (operator !== 38 /* ExclamationEqualsEqualsToken */ && operator !== 36 /* ExclamationEqualsToken */);
+      return narrowType(type, expr, assumeTrue);
+    }
     function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
       switch (expr.operatorToken.kind) {
         case 64 /* EqualsToken */:
@@ -65843,6 +65865,12 @@ function createTypeChecker(host) {
           if (isMatchingConstructorReference(right)) {
             return narrowTypeByConstructor(type, operator, left, assumeTrue);
           }
+          if (isBooleanLiteral(right)) {
+            return narrowTypeByBooleanComparison(type, left, right, operator, assumeTrue);
+          }
+          if (isBooleanLiteral(left)) {
+            return narrowTypeByBooleanComparison(type, right, left, operator, assumeTrue);
+          }
           break;
         case 104 /* InstanceOfKeyword */:
           return narrowTypeByInstanceof(type, expr, assumeTrue);

package/lib/tsserver.js

@@ -2328,7 +2328,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-dev.20230918`;
+var version = `${versionMajorMinor}.0-dev.20230920`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -20572,7 +20572,7 @@ function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) {
   return optionsHaveChanges(oldOptions, newOptions, affectsDeclarationPathOptionDeclarations);
 }
 function getCompilerOptionValue(options, option) {
-  return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
+  return option.strictFlag ? getStrictOptionValue(options, option.name) : option.allowJsFlag ? getAllowJSCompilerOption(options) : options[option.name];
 }
 function getJSXTransformEnabled(options) {
   const jsx = options.jsx;
@@ -38577,7 +38577,8 @@ var commandOptionsWithoutBuild = [
   {
     name: "allowJs",
     type: "boolean",
-    affectsModuleResolution: true,
+    allowJsFlag: true,
+    affectsBuildInfo: true,
     showInSimplifiedHelpView: true,
     category: Diagnostics.JavaScript_Support,
     description: Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files,
@@ -38587,6 +38588,8 @@ var commandOptionsWithoutBuild = [
     name: "checkJs",
     type: "boolean",
     affectsModuleResolution: true,
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
     showInSimplifiedHelpView: true,
     category: Diagnostics.JavaScript_Support,
     description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
@@ -38599,6 +38602,10 @@ var commandOptionsWithoutBuild = [
     affectsEmit: true,
     affectsBuildInfo: true,
     affectsModuleResolution: true,
+    // The checker emits an error when it sees JSX but this option is not set in compilerOptions.
+    // This is effectively a semantic error, so mark this option as affecting semantic diagnostics
+    // so we know to refresh errors when this option is changed.
+    affectsSemanticDiagnostics: true,
     paramType: Diagnostics.KIND,
     showInSimplifiedHelpView: true,
     category: Diagnostics.Language_and_Environment,
@@ -44577,7 +44584,7 @@ function createBinder() {
       case 36 /* ExclamationEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
       case 38 /* ExclamationEqualsEqualsToken */:
-        return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
+        return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right) || (isBooleanLiteral(expr.right) && isNarrowingExpression(expr.left) || isBooleanLiteral(expr.left) && isNarrowingExpression(expr.right));
       case 104 /* InstanceOfKeyword */:
         return isNarrowableOperand(expr.left);
       case 103 /* InKeyword */:
@@ -44897,7 +44904,7 @@ function createBinder() {
   }
   function bindCaseBlock(node) {
     const clauses = node.clauses;
-    const isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
+    const isNarrowingSwitch = node.parent.expression.kind === 112 /* TrueKeyword */ || isNarrowingExpression(node.parent.expression);
     let fallthroughFlow = unreachableFlow;
     for (let i = 0; i < clauses.length; i++) {
       const clauseStart = i;
@@ -58901,7 +58908,7 @@ function createTypeChecker(host) {
   }
   function isConstTypeVariable(type, depth = 0) {
     var _a;
-    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
+    return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
   }
   function getConstraintOfIndexedAccess(type) {
     return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -70249,6 +70256,17 @@ function createTypeChecker(host) {
         type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
       } else if (expr.kind === 221 /* TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
         type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+      } else if (expr.kind === 112 /* TrueKeyword */) {
+        const clause = flow.switchStatement.caseBlock.clauses.find((_, index) => index === flow.clauseStart);
+        const clauseExpression = clause && clause.kind === 296 /* CaseClause */ ? clause.expression : void 0;
+        if (clauseExpression) {
+          type = narrowType(
+            type,
+            clauseExpression,
+            /*assumeTrue*/
+            true
+          );
+        }
       } else {
         if (strictNullChecks) {
           if (optionalChainContainsReference(expr, reference)) {
@@ -70496,6 +70514,10 @@ function createTypeChecker(host) {
       }
       return type;
     }
+    function narrowTypeByBooleanComparison(type, expr, bool, operator, assumeTrue) {
+      assumeTrue = assumeTrue !== (bool.kind === 112 /* TrueKeyword */) !== (operator !== 38 /* ExclamationEqualsEqualsToken */ && operator !== 36 /* ExclamationEqualsToken */);
+      return narrowType(type, expr, assumeTrue);
+    }
     function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
       switch (expr.operatorToken.kind) {
         case 64 /* EqualsToken */:
@@ -70543,6 +70565,12 @@ function createTypeChecker(host) {
           if (isMatchingConstructorReference(right)) {
             return narrowTypeByConstructor(type, operator, left, assumeTrue);
           }
+          if (isBooleanLiteral(right)) {
+            return narrowTypeByBooleanComparison(type, left, right, operator, assumeTrue);
+          }
+          if (isBooleanLiteral(left)) {
+            return narrowTypeByBooleanComparison(type, right, left, operator, assumeTrue);
+          }
           break;
         case 104 /* InstanceOfKeyword */:
           return narrowTypeByInstanceof(type, expr, assumeTrue);
@@ -151098,7 +151126,6 @@ function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceF
       if (aliasDeclaration.isTypeOnly) {
         const sortKind = ts_OrganizeImports_exports.detectImportSpecifierSorting(aliasDeclaration.parent.elements, preferences);
         if (aliasDeclaration.parent.elements.length > 1 && sortKind) {
-          changes.delete(sourceFile, aliasDeclaration);
           const newSpecifier = factory.updateImportSpecifier(
             aliasDeclaration,
             /*isTypeOnly*/
@@ -151108,10 +151135,13 @@ function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceF
           );
           const comparer = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, sortKind === 2 /* CaseInsensitive */);
           const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, comparer);
-          changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
-        } else {
-          changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
+          if (aliasDeclaration.parent.elements.indexOf(aliasDeclaration) !== insertionIndex) {
+            changes.delete(sourceFile, aliasDeclaration);
+            changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
+            return aliasDeclaration;
+          }
         }
+        changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
         return aliasDeclaration;
       } else {
         Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
@@ -164850,7 +164880,6 @@ __export(ts_InlayHints_exports, {
 });
 
 // src/services/inlayHints.ts
-var maxTypeHintLength = 30;
 var leadingParameterNameCommentRegexFactory = (name) => {
   return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
 };
@@ -164930,9 +164959,10 @@ function provideInlayHints(context) {
       displayParts
     });
   }
-  function addTypeHints(text, position) {
+  function addTypeHints(hintText, position) {
     result.push({
-      text: `: ${text.length > maxTypeHintLength ? text.substr(0, maxTypeHintLength - "...".length) + "..." : text}`,
+      text: typeof hintText === "string" ? `: ${hintText}` : "",
+      displayParts: typeof hintText === "string" ? void 0 : [{ text: ": " }, ...hintText],
       position,
       kind: "Type" /* Type */,
       whitespaceBefore: true
@@ -164970,13 +165000,14 @@ function provideInlayHints(context) {
     if (isModuleReferenceType(declarationType)) {
       return;
     }
-    const typeDisplayString = printTypeInSingleLine(declarationType);
-    if (typeDisplayString) {
-      const isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && equateStringsCaseInsensitive(decl.name.getText(), typeDisplayString);
+    const hints = typeToInlayHintParts(declarationType);
+    if (hints) {
+      const hintText = typeof hints === "string" ? hints : hints.map((part) => part.text).join("");
+      const isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && equateStringsCaseInsensitive(decl.name.getText(), hintText);
       if (isVariableNameMatchesType) {
         return;
       }
-      addTypeHints(typeDisplayString, decl.name.end);
+      addTypeHints(hints, decl.name.end);
     }
   }
   function visitCallOrNewExpression(expr) {
@@ -165084,11 +165115,10 @@ function provideInlayHints(context) {
     if (isModuleReferenceType(returnType)) {
       return;
     }
-    const typeDisplayString = printTypeInSingleLine(returnType);
-    if (!typeDisplayString) {
-      return;
+    const hint = typeToInlayHintParts(returnType);
+    if (hint) {
+      addTypeHints(hint, getTypeAnnotationPosition(decl));
     }
-    addTypeHints(typeDisplayString, getTypeAnnotationPosition(decl));
   }
   function getTypeAnnotationPosition(decl) {
     const closeParenToken = findChildOfKind(decl, 22 /* CloseParenToken */, file);
@@ -165149,6 +165179,303 @@ function provideInlayHints(context) {
       );
     });
   }
+  function typeToInlayHintParts(type) {
+    if (!shouldUseInteractiveInlayHints(preferences)) {
+      return printTypeInSingleLine(type);
+    }
+    const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
+    const typeNode = checker.typeToTypeNode(
+      type,
+      /*enclosingDeclaration*/
+      void 0,
+      flags
+    );
+    Debug.assertIsDefined(typeNode, "should always get typenode");
+    const parts = [];
+    visitForDisplayParts(typeNode);
+    return parts;
+    function visitForDisplayParts(node) {
+      if (!node) {
+        return;
+      }
+      const tokenString = tokenToString(node.kind);
+      if (tokenString) {
+        parts.push({ text: tokenString });
+        return;
+      }
+      switch (node.kind) {
+        case 80 /* Identifier */:
+          const identifier = node;
+          const identifierText = idText(identifier);
+          const name = identifier.symbol && identifier.symbol.declarations && identifier.symbol.declarations.length && getNameOfDeclaration(identifier.symbol.declarations[0]);
+          if (name) {
+            parts.push(getNodeDisplayPart(identifierText, name));
+          } else {
+            parts.push({ text: identifierText });
+          }
+          break;
+        case 9 /* NumericLiteral */:
+          parts.push({ text: node.text });
+          break;
+        case 11 /* StringLiteral */:
+          parts.push({ text: `"${node.text}"` });
+          break;
+        case 166 /* QualifiedName */:
+          const qualifiedName = node;
+          visitForDisplayParts(qualifiedName.left);
+          parts.push({ text: "." });
+          visitForDisplayParts(qualifiedName.right);
+          break;
+        case 182 /* TypePredicate */:
+          const predicate = node;
+          if (predicate.assertsModifier) {
+            parts.push({ text: "asserts " });
+          }
+          visitForDisplayParts(predicate.parameterName);
+          if (predicate.type) {
+            parts.push({ text: " is " });
+            visitForDisplayParts(predicate.type);
+          }
+          break;
+        case 183 /* TypeReference */:
+          const typeReference = node;
+          visitForDisplayParts(typeReference.typeName);
+          if (typeReference.typeArguments) {
+            parts.push({ text: "<" });
+            visitDisplayPartList(typeReference.typeArguments, ", ");
+            parts.push({ text: ">" });
+          }
+          break;
+        case 168 /* TypeParameter */:
+          const typeParameter = node;
+          if (typeParameter.modifiers) {
+            visitDisplayPartList(typeParameter.modifiers, " ");
+          }
+          visitForDisplayParts(typeParameter.name);
+          if (typeParameter.constraint) {
+            parts.push({ text: " extends " });
+            visitForDisplayParts(typeParameter.constraint);
+          }
+          if (typeParameter.default) {
+            parts.push({ text: " = " });
+            visitForDisplayParts(typeParameter.default);
+          }
+          break;
+        case 169 /* Parameter */:
+          const parameter = node;
+          if (parameter.modifiers) {
+            visitDisplayPartList(parameter.modifiers, " ");
+          }
+          if (parameter.dotDotDotToken) {
+            parts.push({ text: "..." });
+          }
+          visitForDisplayParts(parameter.name);
+          if (parameter.questionToken) {
+            parts.push({ text: "?" });
+          }
+          if (parameter.type) {
+            parts.push({ text: ": " });
+            visitForDisplayParts(parameter.type);
+          }
+          break;
+        case 185 /* ConstructorType */:
+          const constructorType = node;
+          parts.push({ text: "new " });
+          if (constructorType.typeParameters) {
+            parts.push({ text: "<" });
+            visitDisplayPartList(constructorType.typeParameters, ", ");
+            parts.push({ text: ">" });
+          }
+          parts.push({ text: "(" });
+          visitDisplayPartList(constructorType.parameters, ", ");
+          parts.push({ text: ")" });
+          parts.push({ text: " => " });
+          visitForDisplayParts(constructorType.type);
+          break;
+        case 186 /* TypeQuery */:
+          const typeQuery = node;
+          parts.push({ text: "typeof " });
+          visitForDisplayParts(typeQuery.exprName);
+          if (typeQuery.typeArguments) {
+            parts.push({ text: "<" });
+            visitDisplayPartList(typeQuery.typeArguments, ", ");
+            parts.push({ text: ">" });
+          }
+          break;
+        case 187 /* TypeLiteral */:
+          const typeLiteral = node;
+          parts.push({ text: "{" });
+          if (typeLiteral.members.length) {
+            parts.push({ text: " " });
+            visitDisplayPartList(typeLiteral.members, "; ");
+            parts.push({ text: " " });
+          }
+          parts.push({ text: "}" });
+          break;
+        case 188 /* ArrayType */:
+          visitForDisplayParts(node.elementType);
+          parts.push({ text: "[]" });
+          break;
+        case 189 /* TupleType */:
+          parts.push({ text: "[" });
+          visitDisplayPartList(node.elements, ", ");
+          parts.push({ text: "]" });
+          break;
+        case 202 /* NamedTupleMember */:
+          const member = node;
+          if (member.dotDotDotToken) {
+            parts.push({ text: "..." });
+          }
+          visitForDisplayParts(member.name);
+          if (member.questionToken) {
+            parts.push({ text: "?" });
+          }
+          parts.push({ text: ": " });
+          visitForDisplayParts(member.type);
+          break;
+        case 190 /* OptionalType */:
+          visitForDisplayParts(node.type);
+          parts.push({ text: "?" });
+          break;
+        case 191 /* RestType */:
+          parts.push({ text: "..." });
+          visitForDisplayParts(node.type);
+          break;
+        case 192 /* UnionType */:
+          visitDisplayPartList(node.types, " | ");
+          break;
+        case 193 /* IntersectionType */:
+          visitDisplayPartList(node.types, " & ");
+          break;
+        case 194 /* ConditionalType */:
+          const conditionalType = node;
+          visitForDisplayParts(conditionalType.checkType);
+          parts.push({ text: " extends " });
+          visitForDisplayParts(conditionalType.extendsType);
+          parts.push({ text: " ? " });
+          visitForDisplayParts(conditionalType.trueType);
+          parts.push({ text: " : " });
+          visitForDisplayParts(conditionalType.falseType);
+          break;
+        case 195 /* InferType */:
+          parts.push({ text: "infer " });
+          visitForDisplayParts(node.typeParameter);
+          break;
+        case 196 /* ParenthesizedType */:
+          parts.push({ text: "(" });
+          visitForDisplayParts(node.type);
+          parts.push({ text: ")" });
+          break;
+        case 198 /* TypeOperator */:
+          const typeOperator = node;
+          parts.push({ text: `${tokenToString(typeOperator.operator)} ` });
+          visitForDisplayParts(typeOperator.type);
+          break;
+        case 199 /* IndexedAccessType */:
+          const indexedAccess = node;
+          visitForDisplayParts(indexedAccess.objectType);
+          parts.push({ text: "[" });
+          visitForDisplayParts(indexedAccess.indexType);
+          parts.push({ text: "]" });
+          break;
+        case 200 /* MappedType */:
+          const mappedType = node;
+          parts.push({ text: "{ " });
+          if (mappedType.readonlyToken) {
+            if (mappedType.readonlyToken.kind === 40 /* PlusToken */) {
+              parts.push({ text: "+" });
+            } else if (mappedType.readonlyToken.kind === 41 /* MinusToken */) {
+              parts.push({ text: "-" });
+            }
+            parts.push({ text: "readonly " });
+          }
+          parts.push({ text: "[" });
+          visitForDisplayParts(mappedType.typeParameter);
+          if (mappedType.nameType) {
+            parts.push({ text: " as " });
+            visitForDisplayParts(mappedType.nameType);
+          }
+          parts.push({ text: "]" });
+          if (mappedType.questionToken) {
+            if (mappedType.questionToken.kind === 40 /* PlusToken */) {
+              parts.push({ text: "+" });
+            } else if (mappedType.questionToken.kind === 41 /* MinusToken */) {
+              parts.push({ text: "-" });
+            }
+            parts.push({ text: "?" });
+          }
+          parts.push({ text: ": " });
+          if (mappedType.type) {
+            visitForDisplayParts(mappedType.type);
+          }
+          parts.push({ text: "; }" });
+          break;
+        case 201 /* LiteralType */:
+          visitForDisplayParts(node.literal);
+          break;
+        case 184 /* FunctionType */:
+          const functionType = node;
+          if (functionType.typeParameters) {
+            parts.push({ text: "<" });
+            visitDisplayPartList(functionType.typeParameters, ", ");
+            parts.push({ text: ">" });
+          }
+          parts.push({ text: "(" });
+          visitDisplayPartList(functionType.parameters, ", ");
+          parts.push({ text: ")" });
+          parts.push({ text: " => " });
+          visitForDisplayParts(functionType.type);
+          break;
+        case 205 /* ImportType */:
+          const importType = node;
+          if (importType.isTypeOf) {
+            parts.push({ text: "typeof " });
+          }
+          parts.push({ text: "import(" });
+          visitForDisplayParts(importType.argument);
+          if (importType.assertions) {
+            parts.push({ text: ", { assert: " });
+            visitDisplayPartList(importType.assertions.assertClause.elements, ", ");
+            parts.push({ text: " }" });
+          }
+          parts.push({ text: ")" });
+          if (importType.qualifier) {
+            parts.push({ text: "." });
+            visitForDisplayParts(importType.qualifier);
+          }
+          if (importType.typeArguments) {
+            parts.push({ text: "<" });
+            visitDisplayPartList(importType.typeArguments, ", ");
+            parts.push({ text: ">" });
+          }
+          break;
+        case 171 /* PropertySignature */:
+          const propertySignature = node;
+          if (propertySignature.modifiers) {
+            visitDisplayPartList(propertySignature.modifiers, " ");
+          }
+          visitForDisplayParts(propertySignature.name);
+          if (propertySignature.questionToken) {
+            parts.push({ text: "?" });
+          }
+          if (propertySignature.type) {
+            parts.push({ text: ": " });
+            visitForDisplayParts(propertySignature.type);
+          }
+          break;
+        default:
+          Debug.failBadSyntaxKind(node);
+      }
+    }
+    function visitDisplayPartList(nodes, separator) {
+      nodes.forEach((node, index) => {
+        if (index > 0) {
+          parts.push({ text: separator });
+        }
+        visitForDisplayParts(node);
+      });
+    }
+  }
   function isUndefined(name) {
     return name === "undefined";
   }
@@ -165314,6 +165641,11 @@ function getJsDocTagsFromDeclarations(declarations, checker) {
     }
     for (const tag of tags) {
       infos.push({ name: tag.tagName.text, text: getCommentDisplayParts(tag, checker) });
+      if (isJSDocPropertyLikeTag(tag) && tag.isNameFirst && tag.typeExpression && isJSDocTypeLiteral(tag.typeExpression.type)) {
+        forEach(tag.typeExpression.type.jsDocPropertyTags, (propTag) => {
+          infos.push({ name: propTag.tagName.text, text: getCommentDisplayParts(propTag, checker) });
+        });
+      }
     }
   });
   return infos;

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-dev.20230918`;
+      version = `${versionMajorMinor}.0-dev.20230920`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -17860,7 +17860,7 @@ ${lanes.join("\n")}
     return optionsHaveChanges(oldOptions, newOptions, affectsDeclarationPathOptionDeclarations);
   }
   function getCompilerOptionValue(options, option) {
-    return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name];
+    return option.strictFlag ? getStrictOptionValue(options, option.name) : option.allowJsFlag ? getAllowJSCompilerOption(options) : options[option.name];
   }
   function getJSXTransformEnabled(options) {
     const jsx = options.jsx;
@@ -38060,7 +38060,8 @@ ${lanes.join("\n")}
         {
           name: "allowJs",
           type: "boolean",
-          affectsModuleResolution: true,
+          allowJsFlag: true,
+          affectsBuildInfo: true,
           showInSimplifiedHelpView: true,
           category: Diagnostics.JavaScript_Support,
           description: Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files,
@@ -38070,6 +38071,8 @@ ${lanes.join("\n")}
           name: "checkJs",
           type: "boolean",
           affectsModuleResolution: true,
+          affectsSemanticDiagnostics: true,
+          affectsBuildInfo: true,
           showInSimplifiedHelpView: true,
           category: Diagnostics.JavaScript_Support,
           description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
@@ -38082,6 +38085,10 @@ ${lanes.join("\n")}
           affectsEmit: true,
           affectsBuildInfo: true,
           affectsModuleResolution: true,
+          // The checker emits an error when it sees JSX but this option is not set in compilerOptions.
+          // This is effectively a semantic error, so mark this option as affecting semantic diagnostics
+          // so we know to refresh errors when this option is changed.
+          affectsSemanticDiagnostics: true,
           paramType: Diagnostics.KIND,
           showInSimplifiedHelpView: true,
           category: Diagnostics.Language_and_Environment,
@@ -42424,7 +42431,7 @@ ${lanes.join("\n")}
         case 36 /* ExclamationEqualsToken */:
         case 37 /* EqualsEqualsEqualsToken */:
         case 38 /* ExclamationEqualsEqualsToken */:
-          return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right);
+          return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right) || (isBooleanLiteral(expr.right) && isNarrowingExpression(expr.left) || isBooleanLiteral(expr.left) && isNarrowingExpression(expr.right));
         case 104 /* InstanceOfKeyword */:
           return isNarrowableOperand(expr.left);
         case 103 /* InKeyword */:
@@ -42744,7 +42751,7 @@ ${lanes.join("\n")}
     }
     function bindCaseBlock(node) {
       const clauses = node.clauses;
-      const isNarrowingSwitch = isNarrowingExpression(node.parent.expression);
+      const isNarrowingSwitch = node.parent.expression.kind === 112 /* TrueKeyword */ || isNarrowingExpression(node.parent.expression);
       let fallthroughFlow = unreachableFlow;
       for (let i = 0; i < clauses.length; i++) {
         const clauseStart = i;
@@ -56667,7 +56674,7 @@ ${lanes.join("\n")}
     }
     function isConstTypeVariable(type, depth = 0) {
       var _a;
-      return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 1048576 /* Union */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
+      return depth < 5 && !!(type && (type.flags & 262144 /* TypeParameter */ && some((_a = type.symbol) == null ? void 0 : _a.declarations, (d) => hasSyntacticModifier(d, 2048 /* Const */)) || type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, (t) => isConstTypeVariable(t, depth)) || type.flags & 8388608 /* IndexedAccess */ && isConstTypeVariable(type.objectType, depth + 1) || type.flags & 16777216 /* Conditional */ && isConstTypeVariable(getConstraintOfConditionalType(type), depth + 1) || type.flags & 33554432 /* Substitution */ && isConstTypeVariable(type.baseType, depth) || isGenericTupleType(type) && findIndex(getElementTypes(type), (t, i) => !!(type.target.elementFlags[i] & 8 /* Variadic */) && isConstTypeVariable(t, depth)) >= 0));
     }
     function getConstraintOfIndexedAccess(type) {
       return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : void 0;
@@ -68015,6 +68022,17 @@ ${lanes.join("\n")}
           type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
         } else if (expr.kind === 221 /* TypeOfExpression */ && isMatchingReference(reference, expr.expression)) {
           type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd);
+        } else if (expr.kind === 112 /* TrueKeyword */) {
+          const clause = flow.switchStatement.caseBlock.clauses.find((_, index) => index === flow.clauseStart);
+          const clauseExpression = clause && clause.kind === 296 /* CaseClause */ ? clause.expression : void 0;
+          if (clauseExpression) {
+            type = narrowType(
+              type,
+              clauseExpression,
+              /*assumeTrue*/
+              true
+            );
+          }
         } else {
           if (strictNullChecks) {
             if (optionalChainContainsReference(expr, reference)) {
@@ -68262,6 +68280,10 @@ ${lanes.join("\n")}
         }
         return type;
       }
+      function narrowTypeByBooleanComparison(type, expr, bool, operator, assumeTrue) {
+        assumeTrue = assumeTrue !== (bool.kind === 112 /* TrueKeyword */) !== (operator !== 38 /* ExclamationEqualsEqualsToken */ && operator !== 36 /* ExclamationEqualsToken */);
+        return narrowType(type, expr, assumeTrue);
+      }
       function narrowTypeByBinaryExpression(type, expr, assumeTrue) {
         switch (expr.operatorToken.kind) {
           case 64 /* EqualsToken */:
@@ -68309,6 +68331,12 @@ ${lanes.join("\n")}
             if (isMatchingConstructorReference(right)) {
               return narrowTypeByConstructor(type, operator, left, assumeTrue);
             }
+            if (isBooleanLiteral(right)) {
+              return narrowTypeByBooleanComparison(type, left, right, operator, assumeTrue);
+            }
+            if (isBooleanLiteral(left)) {
+              return narrowTypeByBooleanComparison(type, right, left, operator, assumeTrue);
+            }
             break;
           case 104 /* InstanceOfKeyword */:
             return narrowTypeByInstanceof(type, expr, assumeTrue);
@@ -149825,7 +149853,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (aliasDeclaration.isTypeOnly) {
           const sortKind = ts_OrganizeImports_exports.detectImportSpecifierSorting(aliasDeclaration.parent.elements, preferences);
           if (aliasDeclaration.parent.elements.length > 1 && sortKind) {
-            changes.delete(sourceFile, aliasDeclaration);
             const newSpecifier = factory.updateImportSpecifier(
               aliasDeclaration,
               /*isTypeOnly*/
@@ -149835,10 +149862,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             );
             const comparer = ts_OrganizeImports_exports.getOrganizeImportsComparer(preferences, sortKind === 2 /* CaseInsensitive */);
             const insertionIndex = ts_OrganizeImports_exports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier, comparer);
-            changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
-          } else {
-            changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
+            if (aliasDeclaration.parent.elements.indexOf(aliasDeclaration) !== insertionIndex) {
+              changes.delete(sourceFile, aliasDeclaration);
+              changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex);
+              return aliasDeclaration;
+            }
           }
+          changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken());
           return aliasDeclaration;
         } else {
           Debug.assert(aliasDeclaration.parent.parent.isTypeOnly);
@@ -164281,9 +164311,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         displayParts
       });
     }
-    function addTypeHints(text, position) {
+    function addTypeHints(hintText, position) {
       result.push({
-        text: `: ${text.length > maxTypeHintLength ? text.substr(0, maxTypeHintLength - "...".length) + "..." : text}`,
+        text: typeof hintText === "string" ? `: ${hintText}` : "",
+        displayParts: typeof hintText === "string" ? void 0 : [{ text: ": " }, ...hintText],
         position,
         kind: "Type" /* Type */,
         whitespaceBefore: true
@@ -164321,13 +164352,14 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       if (isModuleReferenceType(declarationType)) {
         return;
       }
-      const typeDisplayString = printTypeInSingleLine(declarationType);
-      if (typeDisplayString) {
-        const isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && equateStringsCaseInsensitive(decl.name.getText(), typeDisplayString);
+      const hints = typeToInlayHintParts(declarationType);
+      if (hints) {
+        const hintText = typeof hints === "string" ? hints : hints.map((part) => part.text).join("");
+        const isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && equateStringsCaseInsensitive(decl.name.getText(), hintText);
         if (isVariableNameMatchesType) {
           return;
         }
-        addTypeHints(typeDisplayString, decl.name.end);
+        addTypeHints(hints, decl.name.end);
       }
     }
     function visitCallOrNewExpression(expr) {
@@ -164435,11 +164467,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       if (isModuleReferenceType(returnType)) {
         return;
       }
-      const typeDisplayString = printTypeInSingleLine(returnType);
-      if (!typeDisplayString) {
-        return;
+      const hint = typeToInlayHintParts(returnType);
+      if (hint) {
+        addTypeHints(hint, getTypeAnnotationPosition(decl));
       }
-      addTypeHints(typeDisplayString, getTypeAnnotationPosition(decl));
     }
     function getTypeAnnotationPosition(decl) {
       const closeParenToken = findChildOfKind(decl, 22 /* CloseParenToken */, file);
@@ -164500,6 +164531,303 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         );
       });
     }
+    function typeToInlayHintParts(type) {
+      if (!shouldUseInteractiveInlayHints(preferences)) {
+        return printTypeInSingleLine(type);
+      }
+      const flags = 70221824 /* IgnoreErrors */ | 1048576 /* AllowUniqueESSymbolType */ | 16384 /* UseAliasDefinedOutsideCurrentScope */;
+      const typeNode = checker.typeToTypeNode(
+        type,
+        /*enclosingDeclaration*/
+        void 0,
+        flags
+      );
+      Debug.assertIsDefined(typeNode, "should always get typenode");
+      const parts = [];
+      visitForDisplayParts(typeNode);
+      return parts;
+      function visitForDisplayParts(node) {
+        if (!node) {
+          return;
+        }
+        const tokenString = tokenToString(node.kind);
+        if (tokenString) {
+          parts.push({ text: tokenString });
+          return;
+        }
+        switch (node.kind) {
+          case 80 /* Identifier */:
+            const identifier = node;
+            const identifierText = idText(identifier);
+            const name = identifier.symbol && identifier.symbol.declarations && identifier.symbol.declarations.length && getNameOfDeclaration(identifier.symbol.declarations[0]);
+            if (name) {
+              parts.push(getNodeDisplayPart(identifierText, name));
+            } else {
+              parts.push({ text: identifierText });
+            }
+            break;
+          case 9 /* NumericLiteral */:
+            parts.push({ text: node.text });
+            break;
+          case 11 /* StringLiteral */:
+            parts.push({ text: `"${node.text}"` });
+            break;
+          case 166 /* QualifiedName */:
+            const qualifiedName = node;
+            visitForDisplayParts(qualifiedName.left);
+            parts.push({ text: "." });
+            visitForDisplayParts(qualifiedName.right);
+            break;
+          case 182 /* TypePredicate */:
+            const predicate = node;
+            if (predicate.assertsModifier) {
+              parts.push({ text: "asserts " });
+            }
+            visitForDisplayParts(predicate.parameterName);
+            if (predicate.type) {
+              parts.push({ text: " is " });
+              visitForDisplayParts(predicate.type);
+            }
+            break;
+          case 183 /* TypeReference */:
+            const typeReference = node;
+            visitForDisplayParts(typeReference.typeName);
+            if (typeReference.typeArguments) {
+              parts.push({ text: "<" });
+              visitDisplayPartList(typeReference.typeArguments, ", ");
+              parts.push({ text: ">" });
+            }
+            break;
+          case 168 /* TypeParameter */:
+            const typeParameter = node;
+            if (typeParameter.modifiers) {
+              visitDisplayPartList(typeParameter.modifiers, " ");
+            }
+            visitForDisplayParts(typeParameter.name);
+            if (typeParameter.constraint) {
+              parts.push({ text: " extends " });
+              visitForDisplayParts(typeParameter.constraint);
+            }
+            if (typeParameter.default) {
+              parts.push({ text: " = " });
+              visitForDisplayParts(typeParameter.default);
+            }
+            break;
+          case 169 /* Parameter */:
+            const parameter = node;
+            if (parameter.modifiers) {
+              visitDisplayPartList(parameter.modifiers, " ");
+            }
+            if (parameter.dotDotDotToken) {
+              parts.push({ text: "..." });
+            }
+            visitForDisplayParts(parameter.name);
+            if (parameter.questionToken) {
+              parts.push({ text: "?" });
+            }
+            if (parameter.type) {
+              parts.push({ text: ": " });
+              visitForDisplayParts(parameter.type);
+            }
+            break;
+          case 185 /* ConstructorType */:
+            const constructorType = node;
+            parts.push({ text: "new " });
+            if (constructorType.typeParameters) {
+              parts.push({ text: "<" });
+              visitDisplayPartList(constructorType.typeParameters, ", ");
+              parts.push({ text: ">" });
+            }
+            parts.push({ text: "(" });
+            visitDisplayPartList(constructorType.parameters, ", ");
+            parts.push({ text: ")" });
+            parts.push({ text: " => " });
+            visitForDisplayParts(constructorType.type);
+            break;
+          case 186 /* TypeQuery */:
+            const typeQuery = node;
+            parts.push({ text: "typeof " });
+            visitForDisplayParts(typeQuery.exprName);
+            if (typeQuery.typeArguments) {
+              parts.push({ text: "<" });
+              visitDisplayPartList(typeQuery.typeArguments, ", ");
+              parts.push({ text: ">" });
+            }
+            break;
+          case 187 /* TypeLiteral */:
+            const typeLiteral = node;
+            parts.push({ text: "{" });
+            if (typeLiteral.members.length) {
+              parts.push({ text: " " });
+              visitDisplayPartList(typeLiteral.members, "; ");
+              parts.push({ text: " " });
+            }
+            parts.push({ text: "}" });
+            break;
+          case 188 /* ArrayType */:
+            visitForDisplayParts(node.elementType);
+            parts.push({ text: "[]" });
+            break;
+          case 189 /* TupleType */:
+            parts.push({ text: "[" });
+            visitDisplayPartList(node.elements, ", ");
+            parts.push({ text: "]" });
+            break;
+          case 202 /* NamedTupleMember */:
+            const member = node;
+            if (member.dotDotDotToken) {
+              parts.push({ text: "..." });
+            }
+            visitForDisplayParts(member.name);
+            if (member.questionToken) {
+              parts.push({ text: "?" });
+            }
+            parts.push({ text: ": " });
+            visitForDisplayParts(member.type);
+            break;
+          case 190 /* OptionalType */:
+            visitForDisplayParts(node.type);
+            parts.push({ text: "?" });
+            break;
+          case 191 /* RestType */:
+            parts.push({ text: "..." });
+            visitForDisplayParts(node.type);
+            break;
+          case 192 /* UnionType */:
+            visitDisplayPartList(node.types, " | ");
+            break;
+          case 193 /* IntersectionType */:
+            visitDisplayPartList(node.types, " & ");
+            break;
+          case 194 /* ConditionalType */:
+            const conditionalType = node;
+            visitForDisplayParts(conditionalType.checkType);
+            parts.push({ text: " extends " });
+            visitForDisplayParts(conditionalType.extendsType);
+            parts.push({ text: " ? " });
+            visitForDisplayParts(conditionalType.trueType);
+            parts.push({ text: " : " });
+            visitForDisplayParts(conditionalType.falseType);
+            break;
+          case 195 /* InferType */:
+            parts.push({ text: "infer " });
+            visitForDisplayParts(node.typeParameter);
+            break;
+          case 196 /* ParenthesizedType */:
+            parts.push({ text: "(" });
+            visitForDisplayParts(node.type);
+            parts.push({ text: ")" });
+            break;
+          case 198 /* TypeOperator */:
+            const typeOperator = node;
+            parts.push({ text: `${tokenToString(typeOperator.operator)} ` });
+            visitForDisplayParts(typeOperator.type);
+            break;
+          case 199 /* IndexedAccessType */:
+            const indexedAccess = node;
+            visitForDisplayParts(indexedAccess.objectType);
+            parts.push({ text: "[" });
+            visitForDisplayParts(indexedAccess.indexType);
+            parts.push({ text: "]" });
+            break;
+          case 200 /* MappedType */:
+            const mappedType = node;
+            parts.push({ text: "{ " });
+            if (mappedType.readonlyToken) {
+              if (mappedType.readonlyToken.kind === 40 /* PlusToken */) {
+                parts.push({ text: "+" });
+              } else if (mappedType.readonlyToken.kind === 41 /* MinusToken */) {
+                parts.push({ text: "-" });
+              }
+              parts.push({ text: "readonly " });
+            }
+            parts.push({ text: "[" });
+            visitForDisplayParts(mappedType.typeParameter);
+            if (mappedType.nameType) {
+              parts.push({ text: " as " });
+              visitForDisplayParts(mappedType.nameType);
+            }
+            parts.push({ text: "]" });
+            if (mappedType.questionToken) {
+              if (mappedType.questionToken.kind === 40 /* PlusToken */) {
+                parts.push({ text: "+" });
+              } else if (mappedType.questionToken.kind === 41 /* MinusToken */) {
+                parts.push({ text: "-" });
+              }
+              parts.push({ text: "?" });
+            }
+            parts.push({ text: ": " });
+            if (mappedType.type) {
+              visitForDisplayParts(mappedType.type);
+            }
+            parts.push({ text: "; }" });
+            break;
+          case 201 /* LiteralType */:
+            visitForDisplayParts(node.literal);
+            break;
+          case 184 /* FunctionType */:
+            const functionType = node;
+            if (functionType.typeParameters) {
+              parts.push({ text: "<" });
+              visitDisplayPartList(functionType.typeParameters, ", ");
+              parts.push({ text: ">" });
+            }
+            parts.push({ text: "(" });
+            visitDisplayPartList(functionType.parameters, ", ");
+            parts.push({ text: ")" });
+            parts.push({ text: " => " });
+            visitForDisplayParts(functionType.type);
+            break;
+          case 205 /* ImportType */:
+            const importType = node;
+            if (importType.isTypeOf) {
+              parts.push({ text: "typeof " });
+            }
+            parts.push({ text: "import(" });
+            visitForDisplayParts(importType.argument);
+            if (importType.assertions) {
+              parts.push({ text: ", { assert: " });
+              visitDisplayPartList(importType.assertions.assertClause.elements, ", ");
+              parts.push({ text: " }" });
+            }
+            parts.push({ text: ")" });
+            if (importType.qualifier) {
+              parts.push({ text: "." });
+              visitForDisplayParts(importType.qualifier);
+            }
+            if (importType.typeArguments) {
+              parts.push({ text: "<" });
+              visitDisplayPartList(importType.typeArguments, ", ");
+              parts.push({ text: ">" });
+            }
+            break;
+          case 171 /* PropertySignature */:
+            const propertySignature = node;
+            if (propertySignature.modifiers) {
+              visitDisplayPartList(propertySignature.modifiers, " ");
+            }
+            visitForDisplayParts(propertySignature.name);
+            if (propertySignature.questionToken) {
+              parts.push({ text: "?" });
+            }
+            if (propertySignature.type) {
+              parts.push({ text: ": " });
+              visitForDisplayParts(propertySignature.type);
+            }
+            break;
+          default:
+            Debug.failBadSyntaxKind(node);
+        }
+      }
+      function visitDisplayPartList(nodes, separator) {
+        nodes.forEach((node, index) => {
+          if (index > 0) {
+            parts.push({ text: separator });
+          }
+          visitForDisplayParts(node);
+        });
+      }
+    }
     function isUndefined(name) {
       return name === "undefined";
     }
@@ -164519,12 +164847,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       };
     }
   }
-  var maxTypeHintLength, leadingParameterNameCommentRegexFactory;
+  var leadingParameterNameCommentRegexFactory;
   var init_inlayHints = __esm({
     "src/services/inlayHints.ts"() {
       "use strict";
       init_ts4();
-      maxTypeHintLength = 30;
       leadingParameterNameCommentRegexFactory = (name) => {
         return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
       };
@@ -164587,6 +164914,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       for (const tag of tags) {
         infos.push({ name: tag.tagName.text, text: getCommentDisplayParts(tag, checker) });
+        if (isJSDocPropertyLikeTag(tag) && tag.isNameFirst && tag.typeExpression && isJSDocTypeLiteral(tag.typeExpression.type)) {
+          forEach(tag.typeExpression.type.jsDocPropertyTags, (propTag) => {
+            infos.push({ name: propTag.tagName.text, text: getCommentDisplayParts(propTag, checker) });
+          });
+        }
       }
     });
     return infos;

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.3";
-var version = `${versionMajorMinor}.0-dev.20230918`;
+var version = `${versionMajorMinor}.0-dev.20230920`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -26005,7 +26005,8 @@ var commandOptionsWithoutBuild = [
   {
     name: "allowJs",
     type: "boolean",
-    affectsModuleResolution: true,
+    allowJsFlag: true,
+    affectsBuildInfo: true,
     showInSimplifiedHelpView: true,
     category: Diagnostics.JavaScript_Support,
     description: Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files,
@@ -26015,6 +26016,8 @@ var commandOptionsWithoutBuild = [
     name: "checkJs",
     type: "boolean",
     affectsModuleResolution: true,
+    affectsSemanticDiagnostics: true,
+    affectsBuildInfo: true,
     showInSimplifiedHelpView: true,
     category: Diagnostics.JavaScript_Support,
     description: Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files,
@@ -26027,6 +26030,10 @@ var commandOptionsWithoutBuild = [
     affectsEmit: true,
     affectsBuildInfo: true,
     affectsModuleResolution: true,
+    // The checker emits an error when it sees JSX but this option is not set in compilerOptions.
+    // This is effectively a semantic error, so mark this option as affecting semantic diagnostics
+    // so we know to refresh errors when this option is changed.
+    affectsSemanticDiagnostics: true,
     paramType: Diagnostics.KIND,
     showInSimplifiedHelpView: true,
     category: Diagnostics.Language_and_Environment,

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.3.0-dev.20230918",
+    "version": "5.3.0-dev.20230920",
     "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": "686cb1b63c82e5eee4cd9f8bbdbcf657a4815ff7"
+    "gitHead": "2738fbf1e05b9429d03b5956ba0413d92f5b993c"
 }