@typescript-deploys/pr-build 5.1.0-pr-54216-5 → 5.2.0-pr-54290-7

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-insiders.20230512`;
+var versionMajorMinor = "5.2";
+var version = `${versionMajorMinor}.0-insiders.20230517`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -12194,7 +12194,7 @@ function isCommonJSContainingModuleKind(kind) {
   return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
 }
 function isEffectiveExternalModule(node, compilerOptions) {
-  return isExternalModule(node) || getIsolatedModules(compilerOptions) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
+  return isExternalModule(node) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
 }
 function isEffectiveStrictModeSourceFile(node, compilerOptions) {
   switch (node.scriptKind) {
@@ -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 */:
@@ -69642,7 +69671,7 @@ function createTypeChecker(host) {
         }
         const typeArgument = typeArgumentTypes[i];
         if (!checkTypeAssignableTo(
-          typeArgument,
+          getTypeWithThisArgument(typeArgument, typeArgument),
           getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument),
           reportErrors2 ? typeArgumentNodes[i] : void 0,
           typeArgumentHeadMessage,
@@ -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,
@@ -71417,6 +71447,8 @@ function createTypeChecker(host) {
       }
       return getRegularTypeOfLiteralType(exprType);
     }
+    const links = getNodeLinks(node);
+    links.assertionExpressionType = exprType;
     checkSourceElement(type);
     checkNodeDeferred(node);
     return getTypeFromTypeNode(type);
@@ -71438,9 +71470,11 @@ function createTypeChecker(host) {
     return { type, expression };
   }
   function checkAssertionDeferred(node) {
-    const { type, expression } = getAssertionTypeAndExpression(node);
+    const { type } = getAssertionTypeAndExpression(node);
     const errNode = isParenthesizedExpression(node) ? type : node;
-    const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(checkExpression(expression)));
+    const links = getNodeLinks(node);
+    Debug.assertIsDefined(links.assertionExpressionType);
+    const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(links.assertionExpressionType));
     const targetType = getTypeFromTypeNode(type);
     if (!isErrorType(targetType)) {
       addLazyDiagnostic(() => {
@@ -73807,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 */));
@@ -78789,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);
               }
             }
@@ -78813,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);
             }
           }
         }
@@ -113000,8 +113038,7 @@ function createCompilerHostWorker(options, setParentNodes, system = sys) {
     realpath,
     readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
     createDirectory: (d) => system.createDirectory(d),
-    createHash: maybeBind(system, system.createHash),
-    useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+    createHash: maybeBind(system, system.createHash)
   };
   return compilerHost;
 }
@@ -113773,7 +113810,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   let projectReferenceRedirects;
   let mapFromFileToProjectReferenceRedirects;
   let mapFromToProjectReferenceRedirectSource;
-  const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host, projectReferences)) && !options.disableSourceOfProjectReferenceRedirect;
+  const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
   const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
     compilerHost: host,
     getSymlinkCache,
@@ -120066,8 +120103,7 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
     getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
     createHash: maybeBind(host, host.createHash),
     readDirectory: maybeBind(host, host.readDirectory),
-    storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-    useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+    storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
   };
   return compilerHost;
 }
@@ -121206,9 +121242,6 @@ function createBuildOrder(state, roots) {
     const parsed = parseConfigFile(state, configFileName, projPath);
     if (parsed && parsed.projectReferences) {
       for (const ref of parsed.projectReferences) {
-        if (ref.circular) {
-          continue;
-        }
         const resolvedRefPath = resolveProjectName(state, ref.path);
         visit(resolvedRefPath, inCircularContext || ref.circular);
       }

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-insiders.20230512`;
+var versionMajorMinor = "5.2";
+var version = `${versionMajorMinor}.0-insiders.20230517`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -15958,7 +15958,7 @@ function isCommonJSContainingModuleKind(kind) {
   return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
 }
 function isEffectiveExternalModule(node, compilerOptions) {
-  return isExternalModule(node) || getIsolatedModules(compilerOptions) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
+  return isExternalModule(node) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
 }
 function isEffectiveStrictModeSourceFile(node, compilerOptions) {
   switch (node.scriptKind) {
@@ -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 */:
@@ -74293,7 +74322,7 @@ function createTypeChecker(host) {
         }
         const typeArgument = typeArgumentTypes[i];
         if (!checkTypeAssignableTo(
-          typeArgument,
+          getTypeWithThisArgument(typeArgument, typeArgument),
           getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument),
           reportErrors2 ? typeArgumentNodes[i] : void 0,
           typeArgumentHeadMessage,
@@ -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,
@@ -76068,6 +76098,8 @@ function createTypeChecker(host) {
       }
       return getRegularTypeOfLiteralType(exprType);
     }
+    const links = getNodeLinks(node);
+    links.assertionExpressionType = exprType;
     checkSourceElement(type);
     checkNodeDeferred(node);
     return getTypeFromTypeNode(type);
@@ -76089,9 +76121,11 @@ function createTypeChecker(host) {
     return { type, expression };
   }
   function checkAssertionDeferred(node) {
-    const { type, expression } = getAssertionTypeAndExpression(node);
+    const { type } = getAssertionTypeAndExpression(node);
     const errNode = isParenthesizedExpression(node) ? type : node;
-    const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(checkExpression(expression)));
+    const links = getNodeLinks(node);
+    Debug.assertIsDefined(links.assertionExpressionType);
+    const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(links.assertionExpressionType));
     const targetType = getTypeFromTypeNode(type);
     if (!isErrorType(targetType)) {
       addLazyDiagnostic(() => {
@@ -78458,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 */));
@@ -83440,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);
               }
             }
@@ -83464,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);
             }
           }
         }
@@ -117856,8 +117894,7 @@ function createCompilerHostWorker(options, setParentNodes, system = sys) {
     realpath,
     readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
     createDirectory: (d) => system.createDirectory(d),
-    createHash: maybeBind(system, system.createHash),
-    useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+    createHash: maybeBind(system, system.createHash)
   };
   return compilerHost;
 }
@@ -118660,7 +118697,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
   let projectReferenceRedirects;
   let mapFromFileToProjectReferenceRedirects;
   let mapFromToProjectReferenceRedirectSource;
-  const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host, projectReferences)) && !options.disableSourceOfProjectReferenceRedirect;
+  const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
   const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
     compilerHost: host,
     getSymlinkCache,
@@ -124988,8 +125025,7 @@ function createCompilerHostFromProgramHost(host, getCompilerOptions, directorySt
     getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
     createHash: maybeBind(host, host.createHash),
     readDirectory: maybeBind(host, host.readDirectory),
-    storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-    useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+    storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
   };
   return compilerHost;
 }
@@ -126174,9 +126210,6 @@ function createBuildOrder(state, roots) {
     const parsed = parseConfigFile(state, configFileName, projPath);
     if (parsed && parsed.projectReferences) {
       for (const ref of parsed.projectReferences) {
-        if (ref.circular) {
-          continue;
-        }
         const resolvedRefPath = resolveProjectName(state, ref.path);
         visit(resolvedRefPath, inCircularContext || ref.circular);
       }
@@ -162070,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) {
@@ -162095,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-insiders.20230512`;
+      versionMajorMinor = "5.2";
+      version = `${versionMajorMinor}.0-insiders.20230517`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -13767,7 +13767,7 @@ ${lanes.join("\n")}
     return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
   }
   function isEffectiveExternalModule(node, compilerOptions) {
-    return isExternalModule(node) || getIsolatedModules(compilerOptions) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
+    return isExternalModule(node) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
   }
   function isEffectiveStrictModeSourceFile(node, compilerOptions) {
     switch (node.scriptKind) {
@@ -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 */:
@@ -72084,7 +72113,7 @@ ${lanes.join("\n")}
           }
           const typeArgument = typeArgumentTypes[i];
           if (!checkTypeAssignableTo(
-            typeArgument,
+            getTypeWithThisArgument(typeArgument, typeArgument),
             getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument),
             reportErrors2 ? typeArgumentNodes[i] : void 0,
             typeArgumentHeadMessage,
@@ -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,
@@ -73859,6 +73889,8 @@ ${lanes.join("\n")}
         }
         return getRegularTypeOfLiteralType(exprType);
       }
+      const links = getNodeLinks(node);
+      links.assertionExpressionType = exprType;
       checkSourceElement(type);
       checkNodeDeferred(node);
       return getTypeFromTypeNode(type);
@@ -73880,9 +73912,11 @@ ${lanes.join("\n")}
       return { type, expression };
     }
     function checkAssertionDeferred(node) {
-      const { type, expression } = getAssertionTypeAndExpression(node);
+      const { type } = getAssertionTypeAndExpression(node);
       const errNode = isParenthesizedExpression(node) ? type : node;
-      const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(checkExpression(expression)));
+      const links = getNodeLinks(node);
+      Debug.assertIsDefined(links.assertionExpressionType);
+      const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(links.assertionExpressionType));
       const targetType = getTypeFromTypeNode(type);
       if (!isErrorType(targetType)) {
         addLazyDiagnostic(() => {
@@ -76249,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 */));
@@ -81231,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);
                 }
               }
@@ -81255,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);
               }
             }
           }
@@ -115976,8 +116014,7 @@ ${lanes.join("\n")}
       realpath,
       readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
       createDirectory: (d) => system.createDirectory(d),
-      createHash: maybeBind(system, system.createHash),
-      useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+      createHash: maybeBind(system, system.createHash)
     };
     return compilerHost;
   }
@@ -116659,7 +116696,7 @@ ${lanes.join("\n")}
     let projectReferenceRedirects;
     let mapFromFileToProjectReferenceRedirects;
     let mapFromToProjectReferenceRedirectSource;
-    const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host, projectReferences)) && !options.disableSourceOfProjectReferenceRedirect;
+    const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
     const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
       compilerHost: host,
       getSymlinkCache,
@@ -123114,8 +123151,7 @@ ${lanes.join("\n")}
       getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
       createHash: maybeBind(host, host.createHash),
       readDirectory: maybeBind(host, host.readDirectory),
-      storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-      useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+      storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
     };
     return compilerHost;
   }
@@ -124352,9 +124388,6 @@ ${lanes.join("\n")}
       const parsed = parseConfigFile(state, configFileName, projPath);
       if (parsed && parsed.projectReferences) {
         for (const ref of parsed.projectReferences) {
-          if (ref.circular) {
-            continue;
-          }
           const resolvedRefPath = resolveProjectName(state, ref.path);
           visit(resolvedRefPath, inCircularContext || ref.circular);
         }
@@ -161407,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) {
@@ -161432,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));
@@ -161650,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-insiders.20230512`;
+      versionMajorMinor = "5.2";
+      version = `${versionMajorMinor}.0-insiders.20230517`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -13767,7 +13767,7 @@ ${lanes.join("\n")}
     return kind === 1 /* CommonJS */ || kind === 100 /* Node16 */ || kind === 199 /* NodeNext */;
   }
   function isEffectiveExternalModule(node, compilerOptions) {
-    return isExternalModule(node) || getIsolatedModules(compilerOptions) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
+    return isExternalModule(node) || isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator;
   }
   function isEffectiveStrictModeSourceFile(node, compilerOptions) {
     switch (node.scriptKind) {
@@ -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 */:
@@ -72084,7 +72113,7 @@ ${lanes.join("\n")}
           }
           const typeArgument = typeArgumentTypes[i];
           if (!checkTypeAssignableTo(
-            typeArgument,
+            getTypeWithThisArgument(typeArgument, typeArgument),
             getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument),
             reportErrors2 ? typeArgumentNodes[i] : void 0,
             typeArgumentHeadMessage,
@@ -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,
@@ -73859,6 +73889,8 @@ ${lanes.join("\n")}
         }
         return getRegularTypeOfLiteralType(exprType);
       }
+      const links = getNodeLinks(node);
+      links.assertionExpressionType = exprType;
       checkSourceElement(type);
       checkNodeDeferred(node);
       return getTypeFromTypeNode(type);
@@ -73880,9 +73912,11 @@ ${lanes.join("\n")}
       return { type, expression };
     }
     function checkAssertionDeferred(node) {
-      const { type, expression } = getAssertionTypeAndExpression(node);
+      const { type } = getAssertionTypeAndExpression(node);
       const errNode = isParenthesizedExpression(node) ? type : node;
-      const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(checkExpression(expression)));
+      const links = getNodeLinks(node);
+      Debug.assertIsDefined(links.assertionExpressionType);
+      const exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(links.assertionExpressionType));
       const targetType = getTypeFromTypeNode(type);
       if (!isErrorType(targetType)) {
         addLazyDiagnostic(() => {
@@ -76249,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 */));
@@ -81231,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);
                 }
               }
@@ -81255,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);
               }
             }
           }
@@ -115976,8 +116014,7 @@ ${lanes.join("\n")}
       realpath,
       readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),
       createDirectory: (d) => system.createDirectory(d),
-      createHash: maybeBind(system, system.createHash),
-      useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+      createHash: maybeBind(system, system.createHash)
     };
     return compilerHost;
   }
@@ -116659,7 +116696,7 @@ ${lanes.join("\n")}
     let projectReferenceRedirects;
     let mapFromFileToProjectReferenceRedirects;
     let mapFromToProjectReferenceRedirectSource;
-    const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host, projectReferences)) && !options.disableSourceOfProjectReferenceRedirect;
+    const useSourceOfProjectReferenceRedirect = !!((_d = host.useSourceOfProjectReferenceRedirect) == null ? void 0 : _d.call(host)) && !options.disableSourceOfProjectReferenceRedirect;
     const { onProgramCreateComplete, fileExists, directoryExists } = updateHostForUseSourceOfProjectReferenceRedirect({
       compilerHost: host,
       getSymlinkCache,
@@ -123114,8 +123151,7 @@ ${lanes.join("\n")}
       getEnvironmentVariable: maybeBind(host, host.getEnvironmentVariable) || (() => ""),
       createHash: maybeBind(host, host.createHash),
       readDirectory: maybeBind(host, host.readDirectory),
-      storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-      useSourceOfProjectReferenceRedirect: (projectReferences) => (projectReferences == null ? void 0 : projectReferences.some((x) => x.circular)) || false
+      storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit
     };
     return compilerHost;
   }
@@ -124352,9 +124388,6 @@ ${lanes.join("\n")}
       const parsed = parseConfigFile(state, configFileName, projPath);
       if (parsed && parsed.projectReferences) {
         for (const ref of parsed.projectReferences) {
-          if (ref.circular) {
-            continue;
-          }
           const resolvedRefPath = resolveProjectName(state, ref.path);
           visit(resolvedRefPath, inCircularContext || ref.circular);
         }
@@ -161422,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) {
@@ -161447,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));
@@ -161665,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-insiders.20230512`;
+var versionMajorMinor = "5.2";
+var version = `${versionMajorMinor}.0-insiders.20230517`;
 
 // src/compiler/core.ts
 var emptyArray = [];

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "5.1.0-pr-54216-5",
+  "version": "5.2.0-pr-54290-7",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [
@@ -83,9 +83,7 @@
     "which": "^2.0.2"
   },
   "overrides": {
-    "typescript@*": "$typescript",
-    "@octokit/types": "9.0.0",
-    "@octokit/openapi-types": "16.0.0"
+    "typescript@*": "$typescript"
   },
   "scripts": {
     "test": "hereby runtests-parallel --light=false",
@@ -116,5 +114,5 @@
     "node": "20.1.0",
     "npm": "8.19.4"
   },
-  "gitHead": "736886c63a6325c0a17354c8952a2e1810f0c7c6"
+  "gitHead": "3c09ef8d3d79da4855445a72635bedf36080857b"
 }