typescript 5.1.0-dev.20230515 → 5.2.0-dev.20230517

package/lib/tsc.js

@@ -17,8 +17,8 @@ and limitations under the License.
 "use strict";
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230515`;
+var versionMajorMinor = "5.2";
+var version = `${versionMajorMinor}.0-dev.20230517`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -54156,7 +54156,35 @@ function createTypeChecker(host) {
     return emptyArray;
   }
   function getSignaturesOfType(type, kind) {
-    return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+    const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+    if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
+      if (type.arrayFallbackSignatures) {
+        return type.arrayFallbackSignatures;
+      }
+      let memberName;
+      if (everyType(type, (t) => {
+        var _a;
+        return !!((_a = t.symbol) == null ? void 0 : _a.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
+      })) {
+        const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
+        const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
+        return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
+      }
+      type.arrayFallbackSignatures = result;
+    }
+    return result;
+  }
+  function isArrayOrTupleSymbol(symbol) {
+    if (!symbol || !globalArrayType.symbol || !globalReadonlyArrayType.symbol) {
+      return false;
+    }
+    return !!getSymbolIfSameReference(symbol, globalArrayType.symbol) || !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
+  }
+  function isReadonlyArraySymbol(symbol) {
+    if (!symbol || !globalReadonlyArrayType.symbol) {
+      return false;
+    }
+    return !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
   }
   function findIndexInfo(indexInfos, keyType) {
     return find(indexInfos, (info) => info.keyType === keyType);
@@ -67010,6 +67038,7 @@ function createTypeChecker(host) {
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 15 /* NoSubstitutionTemplateLiteral */:
+      case 227 /* TemplateExpression */:
       case 112 /* TrueKeyword */:
       case 97 /* FalseKeyword */:
       case 106 /* NullKeyword */:
@@ -69676,8 +69705,9 @@ function createTypeChecker(host) {
       void 0,
       checkMode
     );
+    const checkAttributesType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(attributesType) : attributesType;
     return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(
-      attributesType,
+      checkAttributesType,
       paramType,
       relation,
       reportErrors2 ? node.tagName : void 0,
@@ -73811,11 +73841,15 @@ function createTypeChecker(host) {
       texts.push(span.literal.text);
       types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
     }
-    return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(
+    if (isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(
       node,
       /*contextFlags*/
       void 0
-    ) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+    ) || unknownType, isTemplateLiteralContextualType)) {
+      return getTemplateLiteralType(texts, types);
+    }
+    const evaluated = node.parent.kind !== 214 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+    return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
@@ -78793,11 +78827,11 @@ function createTypeChecker(host) {
           );
           if (symbol) {
             if (symbol.flags & 8 /* EnumMember */) {
-              return evaluateEnumMember(expr, symbol, location);
+              return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
             }
             if (isConstVariable(symbol)) {
               const declaration = symbol.valueDeclaration;
-              if (declaration && !declaration.type && declaration.initializer && declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
+              if (declaration && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
                 return evaluate(declaration.initializer, declaration);
               }
             }
@@ -78817,7 +78851,7 @@ function createTypeChecker(host) {
             const name = escapeLeadingUnderscores(expr.argumentExpression.text);
             const member = rootSymbol.exports.get(name);
             if (member) {
-              return evaluateEnumMember(expr, member, location);
+              return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
             }
           }
         }

package/lib/tsserver.js

@@ -2303,8 +2303,8 @@ __export(server_exports, {
 module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230515`;
+var versionMajorMinor = "5.2";
+var version = `${versionMajorMinor}.0-dev.20230517`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -58807,7 +58807,35 @@ function createTypeChecker(host) {
     return emptyArray;
   }
   function getSignaturesOfType(type, kind) {
-    return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+    const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+    if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
+      if (type.arrayFallbackSignatures) {
+        return type.arrayFallbackSignatures;
+      }
+      let memberName;
+      if (everyType(type, (t) => {
+        var _a;
+        return !!((_a = t.symbol) == null ? void 0 : _a.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
+      })) {
+        const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
+        const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
+        return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
+      }
+      type.arrayFallbackSignatures = result;
+    }
+    return result;
+  }
+  function isArrayOrTupleSymbol(symbol) {
+    if (!symbol || !globalArrayType.symbol || !globalReadonlyArrayType.symbol) {
+      return false;
+    }
+    return !!getSymbolIfSameReference(symbol, globalArrayType.symbol) || !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
+  }
+  function isReadonlyArraySymbol(symbol) {
+    if (!symbol || !globalReadonlyArrayType.symbol) {
+      return false;
+    }
+    return !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
   }
   function findIndexInfo(indexInfos, keyType) {
     return find(indexInfos, (info) => info.keyType === keyType);
@@ -71661,6 +71689,7 @@ function createTypeChecker(host) {
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 15 /* NoSubstitutionTemplateLiteral */:
+      case 227 /* TemplateExpression */:
       case 112 /* TrueKeyword */:
       case 97 /* FalseKeyword */:
       case 106 /* NullKeyword */:
@@ -74327,8 +74356,9 @@ function createTypeChecker(host) {
       void 0,
       checkMode
     );
+    const checkAttributesType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(attributesType) : attributesType;
     return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(
-      attributesType,
+      checkAttributesType,
       paramType,
       relation,
       reportErrors2 ? node.tagName : void 0,
@@ -78462,11 +78492,15 @@ function createTypeChecker(host) {
       texts.push(span.literal.text);
       types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
     }
-    return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
+    if (isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
       node,
       /*contextFlags*/
       void 0
-    ) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+    ) || unknownType, isTemplateLiteralContextualType)) {
+      return getTemplateLiteralType(texts, types);
+    }
+    const evaluated = node.parent.kind !== 214 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+    return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
   }
   function isTemplateLiteralContextualType(type) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
@@ -83444,11 +83478,11 @@ function createTypeChecker(host) {
           );
           if (symbol) {
             if (symbol.flags & 8 /* EnumMember */) {
-              return evaluateEnumMember(expr, symbol, location);
+              return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
             }
             if (isConstVariable(symbol)) {
               const declaration = symbol.valueDeclaration;
-              if (declaration && !declaration.type && declaration.initializer && declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
+              if (declaration && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
                 return evaluate(declaration.initializer, declaration);
               }
             }
@@ -83468,7 +83502,7 @@ function createTypeChecker(host) {
             const name = escapeLeadingUnderscores(expr.argumentExpression.text);
             const member = rootSymbol.exports.get(name);
             if (member) {
-              return evaluateEnumMember(expr, member, location);
+              return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
             }
           }
         }
@@ -162069,6 +162103,76 @@ function getReferenceAtPosition(sourceFile, position, program) {
   }
   return void 0;
 }
+var typesWithUnwrappedTypeArguments = /* @__PURE__ */ new Set([
+  "Array",
+  "ArrayLike",
+  "ReadonlyArray",
+  "Promise",
+  "PromiseLike",
+  "Iterable",
+  "IterableIterator",
+  "AsyncIterable",
+  "Set",
+  "WeakSet",
+  "ReadonlySet",
+  "Map",
+  "WeakMap",
+  "ReadonlyMap",
+  "Partial",
+  "Required",
+  "Readonly",
+  "Pick",
+  "Omit"
+]);
+function shouldUnwrapFirstTypeArgumentTypeDefinitionFromTypeReference(typeChecker, type) {
+  const referenceName = type.symbol.name;
+  if (!typesWithUnwrappedTypeArguments.has(referenceName)) {
+    return false;
+  }
+  const globalType = typeChecker.resolveName(
+    referenceName,
+    /*location*/
+    void 0,
+    788968 /* Type */,
+    /*excludeGlobals*/
+    false
+  );
+  return !!globalType && globalType === type.target.symbol;
+}
+function shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type) {
+  if (!type.aliasSymbol) {
+    return false;
+  }
+  const referenceName = type.aliasSymbol.name;
+  if (!typesWithUnwrappedTypeArguments.has(referenceName)) {
+    return false;
+  }
+  const globalType = typeChecker.resolveName(
+    referenceName,
+    /*location*/
+    void 0,
+    788968 /* Type */,
+    /*excludeGlobals*/
+    false
+  );
+  return !!globalType && globalType === type.aliasSymbol;
+}
+function getFirstTypeArgumentDefinitions(typeChecker, type, node, failedAliasResolution) {
+  var _a, _b;
+  if (!!(getObjectFlags(type) & 4 /* Reference */) && shouldUnwrapFirstTypeArgumentTypeDefinitionFromTypeReference(typeChecker, type)) {
+    return definitionFromType(typeChecker.getTypeArguments(type)[0], typeChecker, node, failedAliasResolution);
+  }
+  if (shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type) && type.aliasTypeArguments) {
+    return definitionFromType(type.aliasTypeArguments[0], typeChecker, node, failedAliasResolution);
+  }
+  if (getObjectFlags(type) & 32 /* Mapped */ && type.target && shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type.target)) {
+    const declaration = (_b = (_a = type.aliasSymbol) == null ? void 0 : _a.declarations) == null ? void 0 : _b[0];
+    if (declaration && isTypeAliasDeclaration(declaration) && isTypeReferenceNode(declaration.type) && declaration.type.typeArguments) {
+      return definitionFromType(typeChecker.getTypeAtLocation(declaration.type.typeArguments[0]), typeChecker, node, failedAliasResolution);
+    }
+  }
+  return [];
+}
 function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) {
   const node = getTouchingPropertyName(sourceFile, position);
   if (node === sourceFile) {
@@ -162094,8 +162198,8 @@ function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) {
   const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
   const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
   const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, failedAliasResolution);
-  const typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution);
-  return typeDefinitions.length ? typeDefinitions : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
+  const [resolvedType, typeDefinitions] = fromReturnType && fromReturnType.length !== 0 ? [returnType, fromReturnType] : [typeAtLocation, definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution)];
+  return typeDefinitions.length ? [...getFirstTypeArgumentDefinitions(typeChecker, resolvedType, node, failedAliasResolution), ...typeDefinitions] : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
 }
 function definitionFromType(type, checker, node, failedAliasResolution) {
   return flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], (t) => t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, failedAliasResolution));

package/lib/tsserverlibrary.d.ts

@@ -4061,7 +4061,7 @@ declare namespace ts {
             responseRequired?: boolean;
         }
     }
-    const versionMajorMinor = "5.1";
+    const versionMajorMinor = "5.2";
     /** The version of the TypeScript compiler release */
     const version: string;
     /**

package/lib/tsserverlibrary.js

@@ -34,8 +34,8 @@ var ts = (() => {
   var init_corePublic = __esm({
     "src/compiler/corePublic.ts"() {
       "use strict";
-      versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230515`;
+      versionMajorMinor = "5.2";
+      version = `${versionMajorMinor}.0-dev.20230517`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -56598,7 +56598,35 @@ ${lanes.join("\n")}
       return emptyArray;
     }
     function getSignaturesOfType(type, kind) {
-      return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+      const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+      if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
+        if (type.arrayFallbackSignatures) {
+          return type.arrayFallbackSignatures;
+        }
+        let memberName;
+        if (everyType(type, (t) => {
+          var _a;
+          return !!((_a = t.symbol) == null ? void 0 : _a.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
+        })) {
+          const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
+          const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
+          return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
+        }
+        type.arrayFallbackSignatures = result;
+      }
+      return result;
+    }
+    function isArrayOrTupleSymbol(symbol) {
+      if (!symbol || !globalArrayType.symbol || !globalReadonlyArrayType.symbol) {
+        return false;
+      }
+      return !!getSymbolIfSameReference(symbol, globalArrayType.symbol) || !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
+    }
+    function isReadonlyArraySymbol(symbol) {
+      if (!symbol || !globalReadonlyArrayType.symbol) {
+        return false;
+      }
+      return !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
     }
     function findIndexInfo(indexInfos, keyType) {
       return find(indexInfos, (info) => info.keyType === keyType);
@@ -69452,6 +69480,7 @@ ${lanes.join("\n")}
         case 9 /* NumericLiteral */:
         case 10 /* BigIntLiteral */:
         case 15 /* NoSubstitutionTemplateLiteral */:
+        case 227 /* TemplateExpression */:
         case 112 /* TrueKeyword */:
         case 97 /* FalseKeyword */:
         case 106 /* NullKeyword */:
@@ -72118,8 +72147,9 @@ ${lanes.join("\n")}
         void 0,
         checkMode
       );
+      const checkAttributesType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(attributesType) : attributesType;
       return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(
-        attributesType,
+        checkAttributesType,
         paramType,
         relation,
         reportErrors2 ? node.tagName : void 0,
@@ -76253,11 +76283,15 @@ ${lanes.join("\n")}
         texts.push(span.literal.text);
         types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
       }
-      return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
+      if (isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
         node,
         /*contextFlags*/
         void 0
-      ) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+      ) || unknownType, isTemplateLiteralContextualType)) {
+        return getTemplateLiteralType(texts, types);
+      }
+      const evaluated = node.parent.kind !== 214 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+      return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
     }
     function isTemplateLiteralContextualType(type) {
       return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
@@ -81235,11 +81269,11 @@ ${lanes.join("\n")}
             );
             if (symbol) {
               if (symbol.flags & 8 /* EnumMember */) {
-                return evaluateEnumMember(expr, symbol, location);
+                return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
               }
               if (isConstVariable(symbol)) {
                 const declaration = symbol.valueDeclaration;
-                if (declaration && !declaration.type && declaration.initializer && declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
+                if (declaration && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
                   return evaluate(declaration.initializer, declaration);
                 }
               }
@@ -81259,7 +81293,7 @@ ${lanes.join("\n")}
               const name = escapeLeadingUnderscores(expr.argumentExpression.text);
               const member = rootSymbol.exports.get(name);
               if (member) {
-                return evaluateEnumMember(expr, member, location);
+                return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
               }
             }
           }
@@ -161406,6 +161440,55 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return void 0;
   }
+  function shouldUnwrapFirstTypeArgumentTypeDefinitionFromTypeReference(typeChecker, type) {
+    const referenceName = type.symbol.name;
+    if (!typesWithUnwrappedTypeArguments.has(referenceName)) {
+      return false;
+    }
+    const globalType = typeChecker.resolveName(
+      referenceName,
+      /*location*/
+      void 0,
+      788968 /* Type */,
+      /*excludeGlobals*/
+      false
+    );
+    return !!globalType && globalType === type.target.symbol;
+  }
+  function shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type) {
+    if (!type.aliasSymbol) {
+      return false;
+    }
+    const referenceName = type.aliasSymbol.name;
+    if (!typesWithUnwrappedTypeArguments.has(referenceName)) {
+      return false;
+    }
+    const globalType = typeChecker.resolveName(
+      referenceName,
+      /*location*/
+      void 0,
+      788968 /* Type */,
+      /*excludeGlobals*/
+      false
+    );
+    return !!globalType && globalType === type.aliasSymbol;
+  }
+  function getFirstTypeArgumentDefinitions(typeChecker, type, node, failedAliasResolution) {
+    var _a, _b;
+    if (!!(getObjectFlags(type) & 4 /* Reference */) && shouldUnwrapFirstTypeArgumentTypeDefinitionFromTypeReference(typeChecker, type)) {
+      return definitionFromType(typeChecker.getTypeArguments(type)[0], typeChecker, node, failedAliasResolution);
+    }
+    if (shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type) && type.aliasTypeArguments) {
+      return definitionFromType(type.aliasTypeArguments[0], typeChecker, node, failedAliasResolution);
+    }
+    if (getObjectFlags(type) & 32 /* Mapped */ && type.target && shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type.target)) {
+      const declaration = (_b = (_a = type.aliasSymbol) == null ? void 0 : _a.declarations) == null ? void 0 : _b[0];
+      if (declaration && isTypeAliasDeclaration(declaration) && isTypeReferenceNode(declaration.type) && declaration.type.typeArguments) {
+        return definitionFromType(typeChecker.getTypeAtLocation(declaration.type.typeArguments[0]), typeChecker, node, failedAliasResolution);
+      }
+    }
+    return [];
+  }
   function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) {
     const node = getTouchingPropertyName(sourceFile, position);
     if (node === sourceFile) {
@@ -161431,8 +161514,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
     const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
     const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, failedAliasResolution);
-    const typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution);
-    return typeDefinitions.length ? typeDefinitions : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
+    const [resolvedType, typeDefinitions] = fromReturnType && fromReturnType.length !== 0 ? [returnType, fromReturnType] : [typeAtLocation, definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution)];
+    return typeDefinitions.length ? [...getFirstTypeArgumentDefinitions(typeChecker, resolvedType, node, failedAliasResolution), ...typeDefinitions] : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
   }
   function definitionFromType(type, checker, node, failedAliasResolution) {
     return flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], (t) => t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, failedAliasResolution));
@@ -161649,10 +161732,32 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return false;
     }
   }
+  var typesWithUnwrappedTypeArguments;
   var init_goToDefinition = __esm({
     "src/services/goToDefinition.ts"() {
       "use strict";
       init_ts4();
+      typesWithUnwrappedTypeArguments = /* @__PURE__ */ new Set([
+        "Array",
+        "ArrayLike",
+        "ReadonlyArray",
+        "Promise",
+        "PromiseLike",
+        "Iterable",
+        "IterableIterator",
+        "AsyncIterable",
+        "Set",
+        "WeakSet",
+        "ReadonlySet",
+        "Map",
+        "WeakMap",
+        "ReadonlyMap",
+        "Partial",
+        "Required",
+        "Readonly",
+        "Pick",
+        "Omit"
+      ]);
     }
   });
 

package/lib/typescript.d.ts

@@ -14,7 +14,7 @@ and limitations under the License.
 ***************************************************************************** */
 
 declare namespace ts {
-    const versionMajorMinor = "5.1";
+    const versionMajorMinor = "5.2";
     /** The version of the TypeScript compiler release */
     const version: string;
     /**

package/lib/typescript.js

@@ -34,8 +34,8 @@ var ts = (() => {
   var init_corePublic = __esm({
     "src/compiler/corePublic.ts"() {
       "use strict";
-      versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230515`;
+      versionMajorMinor = "5.2";
+      version = `${versionMajorMinor}.0-dev.20230517`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -56598,7 +56598,35 @@ ${lanes.join("\n")}
       return emptyArray;
     }
     function getSignaturesOfType(type, kind) {
-      return getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+      const result = getSignaturesOfStructuredType(getReducedApparentType(type), kind);
+      if (kind === 0 /* Call */ && !length(result) && type.flags & 1048576 /* Union */) {
+        if (type.arrayFallbackSignatures) {
+          return type.arrayFallbackSignatures;
+        }
+        let memberName;
+        if (everyType(type, (t) => {
+          var _a;
+          return !!((_a = t.symbol) == null ? void 0 : _a.parent) && isArrayOrTupleSymbol(t.symbol.parent) && (!memberName ? (memberName = t.symbol.escapedName, true) : memberName === t.symbol.escapedName);
+        })) {
+          const arrayArg = mapType(type, (t) => getMappedType((isReadonlyArraySymbol(t.symbol.parent) ? globalReadonlyArrayType : globalArrayType).typeParameters[0], t.mapper));
+          const arrayType = createArrayType(arrayArg, someType(type, (t) => isReadonlyArraySymbol(t.symbol.parent)));
+          return type.arrayFallbackSignatures = getSignaturesOfType(getTypeOfPropertyOfType(arrayType, memberName), kind);
+        }
+        type.arrayFallbackSignatures = result;
+      }
+      return result;
+    }
+    function isArrayOrTupleSymbol(symbol) {
+      if (!symbol || !globalArrayType.symbol || !globalReadonlyArrayType.symbol) {
+        return false;
+      }
+      return !!getSymbolIfSameReference(symbol, globalArrayType.symbol) || !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
+    }
+    function isReadonlyArraySymbol(symbol) {
+      if (!symbol || !globalReadonlyArrayType.symbol) {
+        return false;
+      }
+      return !!getSymbolIfSameReference(symbol, globalReadonlyArrayType.symbol);
     }
     function findIndexInfo(indexInfos, keyType) {
       return find(indexInfos, (info) => info.keyType === keyType);
@@ -69452,6 +69480,7 @@ ${lanes.join("\n")}
         case 9 /* NumericLiteral */:
         case 10 /* BigIntLiteral */:
         case 15 /* NoSubstitutionTemplateLiteral */:
+        case 227 /* TemplateExpression */:
         case 112 /* TrueKeyword */:
         case 97 /* FalseKeyword */:
         case 106 /* NullKeyword */:
@@ -72118,8 +72147,9 @@ ${lanes.join("\n")}
         void 0,
         checkMode
       );
+      const checkAttributesType = checkMode & 4 /* SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(attributesType) : attributesType;
       return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(
-        attributesType,
+        checkAttributesType,
         paramType,
         relation,
         reportErrors2 ? node.tagName : void 0,
@@ -76253,11 +76283,15 @@ ${lanes.join("\n")}
         texts.push(span.literal.text);
         types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType);
       }
-      return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
+      if (isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType2(
         node,
         /*contextFlags*/
         void 0
-      ) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType;
+      ) || unknownType, isTemplateLiteralContextualType)) {
+        return getTemplateLiteralType(texts, types);
+      }
+      const evaluated = node.parent.kind !== 214 /* TaggedTemplateExpression */ && evaluateTemplateExpression(node);
+      return evaluated ? getFreshTypeOfLiteralType(getStringLiteralType(evaluated)) : stringType;
     }
     function isTemplateLiteralContextualType(type) {
       return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
@@ -81235,11 +81269,11 @@ ${lanes.join("\n")}
             );
             if (symbol) {
               if (symbol.flags & 8 /* EnumMember */) {
-                return evaluateEnumMember(expr, symbol, location);
+                return location ? evaluateEnumMember(expr, symbol, location) : getEnumMemberValue(symbol.valueDeclaration);
               }
               if (isConstVariable(symbol)) {
                 const declaration = symbol.valueDeclaration;
-                if (declaration && !declaration.type && declaration.initializer && declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location)) {
+                if (declaration && !declaration.type && declaration.initializer && (!location || declaration !== location && isBlockScopedNameDeclaredBeforeUse(declaration, location))) {
                   return evaluate(declaration.initializer, declaration);
                 }
               }
@@ -81259,7 +81293,7 @@ ${lanes.join("\n")}
               const name = escapeLeadingUnderscores(expr.argumentExpression.text);
               const member = rootSymbol.exports.get(name);
               if (member) {
-                return evaluateEnumMember(expr, member, location);
+                return location ? evaluateEnumMember(expr, member, location) : getEnumMemberValue(member.valueDeclaration);
               }
             }
           }
@@ -161421,6 +161455,55 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
     return void 0;
   }
+  function shouldUnwrapFirstTypeArgumentTypeDefinitionFromTypeReference(typeChecker, type) {
+    const referenceName = type.symbol.name;
+    if (!typesWithUnwrappedTypeArguments.has(referenceName)) {
+      return false;
+    }
+    const globalType = typeChecker.resolveName(
+      referenceName,
+      /*location*/
+      void 0,
+      788968 /* Type */,
+      /*excludeGlobals*/
+      false
+    );
+    return !!globalType && globalType === type.target.symbol;
+  }
+  function shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type) {
+    if (!type.aliasSymbol) {
+      return false;
+    }
+    const referenceName = type.aliasSymbol.name;
+    if (!typesWithUnwrappedTypeArguments.has(referenceName)) {
+      return false;
+    }
+    const globalType = typeChecker.resolveName(
+      referenceName,
+      /*location*/
+      void 0,
+      788968 /* Type */,
+      /*excludeGlobals*/
+      false
+    );
+    return !!globalType && globalType === type.aliasSymbol;
+  }
+  function getFirstTypeArgumentDefinitions(typeChecker, type, node, failedAliasResolution) {
+    var _a, _b;
+    if (!!(getObjectFlags(type) & 4 /* Reference */) && shouldUnwrapFirstTypeArgumentTypeDefinitionFromTypeReference(typeChecker, type)) {
+      return definitionFromType(typeChecker.getTypeArguments(type)[0], typeChecker, node, failedAliasResolution);
+    }
+    if (shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type) && type.aliasTypeArguments) {
+      return definitionFromType(type.aliasTypeArguments[0], typeChecker, node, failedAliasResolution);
+    }
+    if (getObjectFlags(type) & 32 /* Mapped */ && type.target && shouldUnwrapFirstTypeArgumentTypeDefinitionFromAlias(typeChecker, type.target)) {
+      const declaration = (_b = (_a = type.aliasSymbol) == null ? void 0 : _a.declarations) == null ? void 0 : _b[0];
+      if (declaration && isTypeAliasDeclaration(declaration) && isTypeReferenceNode(declaration.type) && declaration.type.typeArguments) {
+        return definitionFromType(typeChecker.getTypeAtLocation(declaration.type.typeArguments[0]), typeChecker, node, failedAliasResolution);
+      }
+    }
+    return [];
+  }
   function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) {
     const node = getTouchingPropertyName(sourceFile, position);
     if (node === sourceFile) {
@@ -161446,8 +161529,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node);
     const returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker);
     const fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, failedAliasResolution);
-    const typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution);
-    return typeDefinitions.length ? typeDefinitions : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
+    const [resolvedType, typeDefinitions] = fromReturnType && fromReturnType.length !== 0 ? [returnType, fromReturnType] : [typeAtLocation, definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution)];
+    return typeDefinitions.length ? [...getFirstTypeArgumentDefinitions(typeChecker, resolvedType, node, failedAliasResolution), ...typeDefinitions] : !(symbol.flags & 111551 /* Value */) && symbol.flags & 788968 /* Type */ ? getDefinitionFromSymbol(typeChecker, skipAlias(symbol, typeChecker), node, failedAliasResolution) : void 0;
   }
   function definitionFromType(type, checker, node, failedAliasResolution) {
     return flatMap(type.isUnion() && !(type.flags & 32 /* Enum */) ? type.types : [type], (t) => t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, failedAliasResolution));
@@ -161664,10 +161747,32 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return false;
     }
   }
+  var typesWithUnwrappedTypeArguments;
   var init_goToDefinition = __esm({
     "src/services/goToDefinition.ts"() {
       "use strict";
       init_ts4();
+      typesWithUnwrappedTypeArguments = /* @__PURE__ */ new Set([
+        "Array",
+        "ArrayLike",
+        "ReadonlyArray",
+        "Promise",
+        "PromiseLike",
+        "Iterable",
+        "IterableIterator",
+        "AsyncIterable",
+        "Set",
+        "WeakSet",
+        "ReadonlySet",
+        "Map",
+        "WeakMap",
+        "ReadonlyMap",
+        "Partial",
+        "Required",
+        "Readonly",
+        "Pick",
+        "Omit"
+      ]);
     }
   });
 

package/lib/typingsInstaller.js

@@ -53,8 +53,8 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230515`;
+var versionMajorMinor = "5.2";
+var version = `${versionMajorMinor}.0-dev.20230517`;
 
 // src/compiler/core.ts
 var emptyArray = [];

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.1.0-dev.20230515",
+    "version": "5.2.0-dev.20230517",
     "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": "8fae437660ba89353fc7104beae8c6856528e5b6"
+    "gitHead": "dddd0667f012c51582c2ac92c08b8e57f2456587"
 }