typescript 5.4.0-dev.20231128 → 5.4.0-dev.20231130

package/lib/tsserver.js

@@ -545,6 +545,7 @@ __export(server_exports, {
   escapeNonAsciiString: () => escapeNonAsciiString,
   escapeSnippetText: () => escapeSnippetText,
   escapeString: () => escapeString,
+  escapeTemplateSubstitution: () => escapeTemplateSubstitution,
   every: () => every,
   expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
   explainFiles: () => explainFiles,
@@ -2331,7 +2332,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231128`;
+var version = `${versionMajorMinor}.0-dev.20231130`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -37122,18 +37123,7 @@ var Parser;
         }
         nextTokenJSDoc();
         skipWhitespace();
-        const p2 = getNodePos();
-        let name = tokenIsIdentifierOrKeyword(token()) ? parseEntityName(
-          /*allowReservedWords*/
-          true
-        ) : void 0;
-        if (name) {
-          while (token() === 81 /* PrivateIdentifier */) {
-            reScanHashToken();
-            nextTokenJSDoc();
-            name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), p2);
-          }
-        }
+        const name = parseJSDocLinkName();
         const text = [];
         while (token() !== 20 /* CloseBraceToken */ && token() !== 4 /* NewLineTrivia */ && token() !== 1 /* EndOfFileToken */) {
           text.push(scanner2.getTokenText());
@@ -37142,6 +37132,26 @@ var Parser;
         const create = linkType === "link" ? factory2.createJSDocLink : linkType === "linkcode" ? factory2.createJSDocLinkCode : factory2.createJSDocLinkPlain;
         return finishNode(create(name, text.join("")), start3, scanner2.getTokenEnd());
       }
+      function parseJSDocLinkName() {
+        if (tokenIsIdentifierOrKeyword(token())) {
+          const pos = getNodePos();
+          let name = parseIdentifierName();
+          while (parseOptional(25 /* DotToken */)) {
+            name = finishNode(factory2.createQualifiedName(name, token() === 81 /* PrivateIdentifier */ ? createMissingNode(
+              80 /* Identifier */,
+              /*reportAtCurrentPosition*/
+              false
+            ) : parseIdentifier()), pos);
+          }
+          while (token() === 81 /* PrivateIdentifier */) {
+            reScanHashToken();
+            nextTokenJSDoc();
+            name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), pos);
+          }
+          return name;
+        }
+        return void 0;
+      }
       function parseJSDocLinkPrefix() {
         skipWhitespaceOrAsterisk();
         if (token() === 19 /* OpenBraceToken */ && nextTokenJSDoc() === 60 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc())) {
@@ -38314,7 +38324,7 @@ var libEntries = [
   ["esnext.disposable", "lib.esnext.disposable.d.ts"],
   ["esnext.bigint", "lib.es2020.bigint.d.ts"],
   ["esnext.string", "lib.es2022.string.d.ts"],
-  ["esnext.promise", "lib.es2021.promise.d.ts"],
+  ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
@@ -46457,7 +46467,7 @@ function createBinder() {
   }
   function bindSpecialPropertyAssignment(node) {
     var _a;
-    const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer);
+    const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer) || lookupSymbolForPropertyAccess(node.left.expression, container);
     if (!isInJSFile(node) && !isFunctionSymbol(parentSymbol)) {
       return;
     }
@@ -46555,7 +46565,7 @@ function createBinder() {
     return isBinaryExpression(propertyAccess.parent) ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 312 /* SourceFile */ : propertyAccess.parent.parent.kind === 312 /* SourceFile */;
   }
   function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
-    let namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer);
+    let namespaceSymbol = lookupSymbolForPropertyAccess(name, blockScopeContainer) || lookupSymbolForPropertyAccess(name, container);
     const isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
     namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
     bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
@@ -59188,7 +59198,12 @@ function createTypeChecker(host) {
       for (const current of type.types) {
         for (const prop of getPropertiesOfType(current)) {
           if (!members.has(prop.escapedName)) {
-            const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
+            const combinedProp = getPropertyOfUnionOrIntersectionType(
+              type,
+              prop.escapedName,
+              /*skipObjectFunctionPropertyAugment*/
+              !!(type.flags & 2097152 /* Intersection */)
+            );
             if (combinedProp) {
               members.set(prop.escapedName, combinedProp);
             }
@@ -59678,13 +59693,17 @@ function createTypeChecker(host) {
     return result;
   }
   function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
-    var _a, _b;
+    var _a, _b, _c;
     let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
     if (!property) {
       property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
       if (property) {
         const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
         properties.set(name, property);
+        if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+          const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
+          properties2.set(name, property);
+        }
       }
     }
     return property;
@@ -59794,7 +59813,22 @@ function createTypeChecker(host) {
       }
       return getPropertyOfObjectType(globalObjectType, name);
     }
-    if (type.flags & 3145728 /* UnionOrIntersection */) {
+    if (type.flags & 2097152 /* Intersection */) {
+      const prop = getPropertyOfUnionOrIntersectionType(
+        type,
+        name,
+        /*skipObjectFunctionPropertyAugment*/
+        true
+      );
+      if (prop) {
+        return prop;
+      }
+      if (!skipObjectFunctionPropertyAugment) {
+        return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
+      }
+      return void 0;
+    }
+    if (type.flags & 1048576 /* Union */) {
       return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
     }
     return void 0;
@@ -68647,12 +68681,12 @@ function createTypeChecker(host) {
     return false;
   }
   function isValidTypeForTemplateLiteralPlaceholder(source, target) {
-    if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
-      return true;
-    }
     if (target.flags & 2097152 /* Intersection */) {
       return every(target.types, (t) => t === emptyTypeLiteralType || isValidTypeForTemplateLiteralPlaceholder(source, t));
     }
+    if (target.flags & 4 /* String */ || isTypeAssignableTo(source, target)) {
+      return true;
+    }
     if (source.flags & 128 /* StringLiteral */) {
       const value = source.value;
       return !!(target.flags & 8 /* Number */ && isValidNumberString(
@@ -68669,7 +68703,7 @@ function createTypeChecker(host) {
       const texts = source.texts;
       return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo(source.types[0], target);
     }
-    return isTypeAssignableTo(source, target);
+    return false;
   }
   function inferTypesFromTemplateLiteralType(source, target) {
     return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
@@ -71627,14 +71661,15 @@ function createTypeChecker(host) {
     if (declaration) {
       if (isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
         const parent2 = declaration.parent.parent;
-        if (parent2.kind === 260 /* VariableDeclaration */ && getCombinedNodeFlagsCached(declaration) & 6 /* Constant */ || parent2.kind === 169 /* Parameter */) {
+        const rootDeclaration = getRootDeclaration(parent2);
+        if (rootDeclaration.kind === 260 /* VariableDeclaration */ && getCombinedNodeFlagsCached(rootDeclaration) & 6 /* Constant */ || rootDeclaration.kind === 169 /* Parameter */) {
           const links = getNodeLinks(parent2);
           if (!(links.flags & 4194304 /* InCheckIdentifier */)) {
             links.flags |= 4194304 /* InCheckIdentifier */;
             const parentType = getTypeForBindingElementParent(parent2, 0 /* Normal */);
             const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
             links.flags &= ~4194304 /* InCheckIdentifier */;
-            if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent2.kind === 169 /* Parameter */ && isSymbolAssigned(symbol))) {
+            if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(rootDeclaration.kind === 169 /* Parameter */ && isSymbolAssigned(symbol))) {
               const pattern = declaration.parent;
               const narrowedType = getFlowTypeOfReference(
                 pattern,
@@ -75807,19 +75842,9 @@ function createTypeChecker(host) {
         return Debug.fail();
     }
   }
-  function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
-    let start2;
-    let length2;
+  function getDiagnosticSpanForCallNode(node) {
     const sourceFile = getSourceFileOfNode(node);
-    if (isPropertyAccessExpression(node.expression)) {
-      const nameSpan = getErrorSpanForNode(sourceFile, node.expression.name);
-      start2 = nameSpan.start;
-      length2 = doNotIncludeArguments ? nameSpan.length : node.end - start2;
-    } else {
-      const expressionSpan = getErrorSpanForNode(sourceFile, node.expression);
-      start2 = expressionSpan.start;
-      length2 = doNotIncludeArguments ? expressionSpan.length : node.end - start2;
-    }
+    const { start: start2, length: length2 } = getErrorSpanForNode(sourceFile, isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
     return { start: start2, length: length2, sourceFile };
   }
   function getDiagnosticForCallNode(node, message, ...args) {
@@ -75836,6 +75861,18 @@ function createTypeChecker(host) {
       return createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, message);
     }
   }
+  function getErrorNodeForCallNode(callLike) {
+    if (isCallOrNewExpression(callLike)) {
+      return isPropertyAccessExpression(callLike.expression) ? callLike.expression.name : callLike.expression;
+    }
+    if (isTaggedTemplateExpression(callLike)) {
+      return isPropertyAccessExpression(callLike.tag) ? callLike.tag.name : callLike.tag;
+    }
+    if (isJsxOpeningLikeElement(callLike)) {
+      return callLike.tagName;
+    }
+    return callLike;
+  }
   function isPromiseResolveArityError(node) {
     if (!isCallExpression(node) || !isIdentifier(node.expression))
       return false;
@@ -76137,7 +76174,7 @@ function createTypeChecker(host) {
             const { file, start: start2, length: length2 } = diags[0];
             diag2 = { file, start: start2, length: length2, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related };
           } else {
-            diag2 = createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, chain, related);
+            diag2 = createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), getErrorNodeForCallNode(node), chain, related);
           }
           addImplementationSuccessElaboration(candidatesForArgumentError[0], diag2);
           diagnostics.add(diag2);
@@ -76665,11 +76702,7 @@ function createTypeChecker(host) {
       addRelatedInfo(diagnostic, createDiagnosticForNode(errorTarget, relatedInfo));
     }
     if (isCallExpression(errorTarget.parent)) {
-      const { start: start2, length: length2 } = getDiagnosticSpanForCallNode(
-        errorTarget.parent,
-        /*doNotIncludeArguments*/
-        true
-      );
+      const { start: start2, length: length2 } = getDiagnosticSpanForCallNode(errorTarget.parent);
       diagnostic.start = start2;
       diagnostic.length = length2;
     }
@@ -80039,16 +80072,19 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
+  function getNonGenericReturnTypeOfSingleCallSignature(funcType) {
     const signature = getSingleCallSignature(funcType);
-    if (signature && !signature.typeParameters) {
-      return getReturnTypeOfSignature(signature);
+    if (signature) {
+      const returnType = getReturnTypeOfSignature(signature);
+      if (!signature.typeParameters || !couldContainTypeVariables(returnType)) {
+        return returnType;
+      }
     }
   }
   function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
     const funcType = checkExpression(expr.expression);
     const nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
-    const returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
+    const returnType = getNonGenericReturnTypeOfSingleCallSignature(funcType);
     return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
   }
   function getTypeOfExpression(node) {
@@ -80093,7 +80129,7 @@ function createTypeChecker(host) {
       /*requireStringLiteralLikeArgument*/
       true
     ) && !isSymbolOrSymbolForCall(expr)) {
-      return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
+      return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getNonGenericReturnTypeOfSingleCallSignature(checkNonNullExpression(expr.expression));
     } else if (isAssertionExpression(expr) && !isConstTypeReference(expr.type)) {
       return getTypeFromTypeNode(expr.type);
     } else if (isLiteralExpression(node) || isBooleanLiteral(node)) {
@@ -165794,6 +165830,17 @@ function provideInlayHints(context) {
             visitForDisplayParts(node.type);
           }
           break;
+        case 181 /* IndexSignature */:
+          Debug.assertNode(node, isIndexSignatureDeclaration);
+          Debug.assertEqual(node.parameters.length, 1);
+          parts.push({ text: "[" });
+          visitForDisplayParts(node.parameters[0]);
+          parts.push({ text: "]" });
+          if (node.type) {
+            parts.push({ text: ": " });
+            visitForDisplayParts(node.type);
+          }
+          break;
         case 173 /* MethodSignature */:
           Debug.assertNode(node, isMethodSignature);
           if ((_b = node.modifiers) == null ? void 0 : _b.length) {
@@ -165843,6 +165890,28 @@ function provideInlayHints(context) {
           parts.push({ text: tokenToString(node.operator) });
           visitForDisplayParts(node.operand);
           break;
+        case 203 /* TemplateLiteralType */:
+          Debug.assertNode(node, isTemplateLiteralTypeNode);
+          visitForDisplayParts(node.head);
+          node.templateSpans.forEach(visitForDisplayParts);
+          break;
+        case 16 /* TemplateHead */:
+          Debug.assertNode(node, isTemplateHead);
+          parts.push({ text: getLiteralText2(node) });
+          break;
+        case 204 /* TemplateLiteralTypeSpan */:
+          Debug.assertNode(node, isTemplateLiteralTypeSpan);
+          visitForDisplayParts(node.type);
+          visitForDisplayParts(node.literal);
+          break;
+        case 17 /* TemplateMiddle */:
+          Debug.assertNode(node, isTemplateMiddle);
+          parts.push({ text: getLiteralText2(node) });
+          break;
+        case 18 /* TemplateTail */:
+          Debug.assertNode(node, isTemplateTail);
+          parts.push({ text: getLiteralText2(node) });
+          break;
         case 197 /* ThisType */:
           Debug.assertNode(node, isThisTypeNode);
           parts.push({ text: "this" });
@@ -165870,8 +165939,22 @@ function provideInlayHints(context) {
       });
     }
     function getLiteralText2(node) {
-      if (isStringLiteral(node)) {
-        return quotePreference === 0 /* Single */ ? `'${escapeString(node.text, 39 /* singleQuote */)}'` : `"${escapeString(node.text, 34 /* doubleQuote */)}"`;
+      switch (node.kind) {
+        case 11 /* StringLiteral */:
+          return quotePreference === 0 /* Single */ ? `'${escapeString(node.text, 39 /* singleQuote */)}'` : `"${escapeString(node.text, 34 /* doubleQuote */)}"`;
+        case 16 /* TemplateHead */:
+        case 17 /* TemplateMiddle */:
+        case 18 /* TemplateTail */: {
+          const rawText = node.rawText ?? escapeTemplateSubstitution(escapeString(node.text, 96 /* backtick */));
+          switch (node.kind) {
+            case 16 /* TemplateHead */:
+              return "`" + rawText + "${";
+            case 17 /* TemplateMiddle */:
+              return "}" + rawText + "${";
+            case 18 /* TemplateTail */:
+              return "}" + rawText + "`";
+          }
+        }
       }
       return node.text;
     }
@@ -173436,6 +173519,7 @@ __export(ts_exports2, {
   escapeNonAsciiString: () => escapeNonAsciiString,
   escapeSnippetText: () => escapeSnippetText,
   escapeString: () => escapeString,
+  escapeTemplateSubstitution: () => escapeTemplateSubstitution,
   every: () => every,
   expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
   explainFiles: () => explainFiles,
@@ -188227,6 +188311,7 @@ start(initializeNodeSystem(), require("os").platform());
   escapeNonAsciiString,
   escapeSnippetText,
   escapeString,
+  escapeTemplateSubstitution,
   every,
   expandPreOrPostfixIncrementOrDecrementExpression,
   explainFiles,