@typescript-deploys/pr-build 5.3.0-pr-55779-6 → 5.3.0-pr-52972-6

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-insiders.20230919`;
+var version = `${versionMajorMinor}.0-insiders.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 */:
@@ -64053,10 +64060,13 @@ function createTypeChecker(host) {
         if (sourceNameType && targetNameType)
           inferFromTypes(sourceNameType, targetNameType);
       }
-      if (getObjectFlags(target) & 32 /* Mapped */ && !target.declaration.nameType) {
-        const constraintType = getConstraintTypeFromMappedType(target);
-        if (inferToMappedType(source, target, constraintType)) {
-          return;
+      if (getObjectFlags(target) & 32 /* Mapped */) {
+        const mappedType = target;
+        if (!getNameTypeFromMappedType(mappedType) || isFilteringMappedType(mappedType)) {
+          const constraintType = getConstraintTypeFromMappedType(mappedType);
+          if (inferToMappedType(source, mappedType, constraintType)) {
+            return;
+          }
         }
       }
       if (!typesDefinitelyUnrelated(source, target)) {
@@ -65807,6 +65817,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 */:
@@ -65854,6 +65868,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-insiders.20230919`;
+var version = `${versionMajorMinor}.0-insiders.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 */:
@@ -68753,10 +68760,13 @@ function createTypeChecker(host) {
         if (sourceNameType && targetNameType)
           inferFromTypes(sourceNameType, targetNameType);
       }
-      if (getObjectFlags(target) & 32 /* Mapped */ && !target.declaration.nameType) {
-        const constraintType = getConstraintTypeFromMappedType(target);
-        if (inferToMappedType(source, target, constraintType)) {
-          return;
+      if (getObjectFlags(target) & 32 /* Mapped */) {
+        const mappedType = target;
+        if (!getNameTypeFromMappedType(mappedType) || isFilteringMappedType(mappedType)) {
+          const constraintType = getConstraintTypeFromMappedType(mappedType);
+          if (inferToMappedType(source, mappedType, constraintType)) {
+            return;
+          }
         }
       }
       if (!typesDefinitelyUnrelated(source, target)) {
@@ -70507,6 +70517,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 */:
@@ -70554,6 +70568,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);
@@ -164863,7 +164883,6 @@ __export(ts_InlayHints_exports, {
 });
 
 // src/services/inlayHints.ts
-var maxTypeHintLength = 30;
 var leadingParameterNameCommentRegexFactory = (name) => {
   return new RegExp(`^\\s?/\\*\\*?\\s?${name}\\s?\\*\\/\\s?$`);
 };
@@ -164943,9 +164962,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
@@ -164983,13 +165003,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) {
@@ -165097,11 +165118,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);
@@ -165162,6 +165182,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";
   }
@@ -165327,6 +165644,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-insiders.20230919`;
+      version = `${versionMajorMinor}.0-insiders.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 */:
@@ -66519,10 +66526,13 @@ ${lanes.join("\n")}
           if (sourceNameType && targetNameType)
             inferFromTypes(sourceNameType, targetNameType);
         }
-        if (getObjectFlags(target) & 32 /* Mapped */ && !target.declaration.nameType) {
-          const constraintType = getConstraintTypeFromMappedType(target);
-          if (inferToMappedType(source, target, constraintType)) {
-            return;
+        if (getObjectFlags(target) & 32 /* Mapped */) {
+          const mappedType = target;
+          if (!getNameTypeFromMappedType(mappedType) || isFilteringMappedType(mappedType)) {
+            const constraintType = getConstraintTypeFromMappedType(mappedType);
+            if (inferToMappedType(source, mappedType, constraintType)) {
+              return;
+            }
           }
         }
         if (!typesDefinitelyUnrelated(source, target)) {
@@ -68273,6 +68283,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 */:
@@ -68320,6 +68334,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);
@@ -164294,9 +164314,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
@@ -164334,13 +164355,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) {
@@ -164448,11 +164470,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);
@@ -164513,6 +164534,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";
     }
@@ -164532,12 +164850,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?$`);
       };
@@ -164600,6 +164917,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-insiders.20230919`;
+var version = `${versionMajorMinor}.0-insiders.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-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.3.0-pr-55779-6",
+  "version": "5.3.0-pr-52972-6",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -114,5 +114,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "1bd6193dd17b73a073ca88599548ec08e4db3f2f"
+  "gitHead": "3be6be6c3b7f564f8a49926c47ce91e7db814b91"
 }