@typescript-deploys/pr-build 5.0.0-pr-52710-9 → 5.0.0-pr-52696-39

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230210`;
+var version = `${versionMajorMinor}.0-insiders.20230211`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -27092,13 +27092,8 @@ var Parser;
         return tokenIsIdentifierOrKeyword(token()) || token() === 18 /* OpenBraceToken */;
       case 14 /* JsxChildren */:
         return true;
-      case 25 /* StandaloneJSDoc */:
-        return true;
-      case 26 /* Count */:
-        return Debug.fail("ParsingContext.Count used as a context");
-      default:
-        Debug.assertNever(parsingContext2, "Non-exhaustive case in 'isListElement'.");
     }
+    return Debug.fail("Non-exhaustive case in 'isListElement'.");
   }
   function isValidHeritageClauseObjectLiteral() {
     Debug.assert(token() === 18 /* OpenBraceToken */);
@@ -27192,8 +27187,7 @@ var Parser;
     return false;
   }
   function isInSomeParsingContext() {
-    Debug.assert(parsingContext, "Missing parsing context");
-    for (let kind = 0; kind < 26 /* Count */; kind++) {
+    for (let kind = 0; kind < 25 /* Count */; kind++) {
       if (parsingContext & 1 << kind) {
         if (isListElement(
           kind,
@@ -27272,7 +27266,6 @@ var Parser;
       case 8 /* VariableDeclarations */:
       case 17 /* JSDocParameters */:
       case 16 /* Parameters */:
-      case 25 /* StandaloneJSDoc */:
         return true;
     }
     return false;
@@ -27453,9 +27446,7 @@ var Parser;
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
       case 24 /* AssertEntries */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
-      case 25 /* StandaloneJSDoc */:
-        return;
-      case 26 /* Count */:
+      case 25 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
       default:
         Debug.assertNever(context);
@@ -31555,8 +31546,7 @@ var Parser;
     ParsingContext2[ParsingContext2["HeritageClauses"] = 22] = "HeritageClauses";
     ParsingContext2[ParsingContext2["ImportOrExportSpecifiers"] = 23] = "ImportOrExportSpecifiers";
     ParsingContext2[ParsingContext2["AssertEntries"] = 24] = "AssertEntries";
-    ParsingContext2[ParsingContext2["StandaloneJSDoc"] = 25] = "StandaloneJSDoc";
-    ParsingContext2[ParsingContext2["Count"] = 26] = "Count";
+    ParsingContext2[ParsingContext2["Count"] = 25] = "Count";
   })(ParsingContext || (ParsingContext = {}));
   let Tristate;
   ((Tristate2) => {
@@ -31678,13 +31668,6 @@ var Parser;
       PropertyLikeParse2[PropertyLikeParse2["CallbackParameter"] = 4] = "CallbackParameter";
     })(PropertyLikeParse || (PropertyLikeParse = {}));
     function parseJSDocCommentWorker(start = 0, length2) {
-      const saveParsingContext = parsingContext;
-      parsingContext |= 1 << 25 /* StandaloneJSDoc */;
-      const jsdoc = parseJSDocCommentWorkerWorker(start, length2);
-      parsingContext = saveParsingContext;
-      return jsdoc;
-    }
-    function parseJSDocCommentWorkerWorker(start, length2) {
       const content = sourceText;
       const end = length2 === void 0 ? content.length : start + length2;
       length2 = end - start;
@@ -43312,6 +43295,7 @@ function createTypeChecker(host) {
   let flowTypeCache;
   const contextualTypeNodes = [];
   const contextualTypes = [];
+  const contextualIsCache = [];
   let contextualTypeCount = 0;
   const inferenceContextNodes = [];
   const inferenceContexts = [];
@@ -50482,6 +50466,8 @@ function createTypeChecker(host) {
         return !!target.baseTypesResolved;
       case 8 /* WriteType */:
         return !!getSymbolLinks(target).writeType;
+      case 9 /* ParameterInitializerContainsUndefined */:
+        return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
     }
     return Debug.assertNever(propertyName);
   }
@@ -58273,7 +58259,12 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-    pushContextualType(next, sourcePropType);
+    pushContextualType(
+      next,
+      sourcePropType,
+      /*isCache*/
+      false
+    );
     const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
     popContextualType();
     return result;
@@ -58581,7 +58572,12 @@ function createTypeChecker(host) {
     if (isTupleLikeType(source)) {
       return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
     }
-    pushContextualType(node, target);
+    pushContextualType(
+      node,
+      target,
+      /*isCache*/
+      false
+    );
     const tupleizedType = checkArrayLiteral(
       node,
       1 /* Contextual */,
@@ -65304,15 +65300,25 @@ function createTypeChecker(host) {
   function isConstVariable(symbol) {
     return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */) !== 0;
   }
-  function removeOptionalityFromDeclaredType(declaredType, declaration) {
-    if (pushTypeResolution(declaration.symbol, 2 /* DeclaredType */)) {
-      const annotationIncludesUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
-      popTypeResolution();
-      return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
-    } else {
-      reportCircularityError(declaration.symbol);
-      return declaredType;
+  function parameterInitializerContainsUndefined(declaration) {
+    const links = getNodeLinks(declaration);
+    if (links.parameterInitializerContainsUndefined === void 0) {
+      if (!pushTypeResolution(declaration, 9 /* ParameterInitializerContainsUndefined */)) {
+        reportCircularityError(declaration.symbol);
+        return true;
+      }
+      const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */);
+      if (!popTypeResolution()) {
+        reportCircularityError(declaration.symbol);
+        return true;
+      }
+      links.parameterInitializerContainsUndefined = containsUndefined;
     }
+    return links.parameterInitializerContainsUndefined;
+  }
+  function removeOptionalityFromDeclaredType(declaredType, declaration) {
+    const removeUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !parameterInitializerContainsUndefined(declaration);
+    return removeUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
   }
   function isConstraintPosition(type, node) {
     const parent = node.parent;
@@ -66630,11 +66636,13 @@ function createTypeChecker(host) {
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
-    const index = findContextualNode(node);
+    const index = findContextualNode(
+      node,
+      /*includeCaches*/
+      !contextFlags
+    );
     if (index >= 0) {
-      const cached = contextualTypes[index];
-      if (cached || !contextFlags)
-        return cached;
+      return contextualTypes[index];
     }
     const { parent } = node;
     switch (parent.kind) {
@@ -66705,17 +66713,30 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function pushContextualType(node, type) {
+  function pushCachedContextualType(node) {
+    pushContextualType(
+      node,
+      getContextualType(
+        node,
+        /*contextFlags*/
+        void 0
+      ),
+      /*isCache*/
+      true
+    );
+  }
+  function pushContextualType(node, type, isCache) {
     contextualTypeNodes[contextualTypeCount] = node;
     contextualTypes[contextualTypeCount] = type;
+    contextualIsCache[contextualTypeCount] = isCache;
     contextualTypeCount++;
   }
   function popContextualType() {
     contextualTypeCount--;
   }
-  function findContextualNode(node) {
+  function findContextualNode(node, includeCaches) {
     for (let i = contextualTypeCount - 1; i >= 0; i--) {
-      if (node === contextualTypeNodes[i]) {
+      if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
         return i;
       }
     }
@@ -66738,7 +66759,11 @@ function createTypeChecker(host) {
   }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-      const index = findContextualNode(node.parent);
+      const index = findContextualNode(
+        node.parent,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
         return contextualTypes[index];
       }
@@ -67009,11 +67034,7 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    pushContextualType(node, getContextualType(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const inDestructuringPattern = isAssignmentTarget(node);
     const inConstContext = isConstContext(node);
     const contextualType = getApparentTypeOfContextualType(
@@ -67176,11 +67197,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
-    pushContextualType(node, getContextualType(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const contextualType = getApparentTypeOfContextualType(
       node,
       /*contextFlags*/
@@ -73191,14 +73208,19 @@ function createTypeChecker(host) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
   }
   function getContextNode(node) {
-    if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+    if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
       return node.parent.parent;
     }
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
     const contextNode = getContextNode(node);
-    pushContextualType(contextNode, contextualType);
+    pushContextualType(
+      contextNode,
+      contextualType,
+      /*isCache*/
+      false
+    );
     pushInferenceContext(contextNode, inferenceContext);
     const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
     if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -73539,7 +73561,12 @@ function createTypeChecker(host) {
     if (links.contextFreeType) {
       return links.contextFreeType;
     }
-    pushContextualType(node, anyType);
+    pushContextualType(
+      node,
+      anyType,
+      /*isCache*/
+      false
+    );
     const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
     popContextualType();
     return type;

package/lib/tsserver.js

@@ -2287,7 +2287,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230210`;
+var version = `${versionMajorMinor}.0-insiders.20230211`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -31407,13 +31407,8 @@ var Parser;
         return tokenIsIdentifierOrKeyword(token()) || token() === 18 /* OpenBraceToken */;
       case 14 /* JsxChildren */:
         return true;
-      case 25 /* StandaloneJSDoc */:
-        return true;
-      case 26 /* Count */:
-        return Debug.fail("ParsingContext.Count used as a context");
-      default:
-        Debug.assertNever(parsingContext2, "Non-exhaustive case in 'isListElement'.");
     }
+    return Debug.fail("Non-exhaustive case in 'isListElement'.");
   }
   function isValidHeritageClauseObjectLiteral() {
     Debug.assert(token() === 18 /* OpenBraceToken */);
@@ -31507,8 +31502,7 @@ var Parser;
     return false;
   }
   function isInSomeParsingContext() {
-    Debug.assert(parsingContext, "Missing parsing context");
-    for (let kind = 0; kind < 26 /* Count */; kind++) {
+    for (let kind = 0; kind < 25 /* Count */; kind++) {
       if (parsingContext & 1 << kind) {
         if (isListElement2(
           kind,
@@ -31587,7 +31581,6 @@ var Parser;
       case 8 /* VariableDeclarations */:
       case 17 /* JSDocParameters */:
       case 16 /* Parameters */:
-      case 25 /* StandaloneJSDoc */:
         return true;
     }
     return false;
@@ -31768,9 +31761,7 @@ var Parser;
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
       case 24 /* AssertEntries */:
         return parseErrorAtCurrentToken(Diagnostics.Identifier_or_string_literal_expected);
-      case 25 /* StandaloneJSDoc */:
-        return;
-      case 26 /* Count */:
+      case 25 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
       default:
         Debug.assertNever(context);
@@ -35870,8 +35861,7 @@ var Parser;
     ParsingContext2[ParsingContext2["HeritageClauses"] = 22] = "HeritageClauses";
     ParsingContext2[ParsingContext2["ImportOrExportSpecifiers"] = 23] = "ImportOrExportSpecifiers";
     ParsingContext2[ParsingContext2["AssertEntries"] = 24] = "AssertEntries";
-    ParsingContext2[ParsingContext2["StandaloneJSDoc"] = 25] = "StandaloneJSDoc";
-    ParsingContext2[ParsingContext2["Count"] = 26] = "Count";
+    ParsingContext2[ParsingContext2["Count"] = 25] = "Count";
   })(ParsingContext || (ParsingContext = {}));
   let Tristate;
   ((Tristate2) => {
@@ -35993,13 +35983,6 @@ var Parser;
       PropertyLikeParse2[PropertyLikeParse2["CallbackParameter"] = 4] = "CallbackParameter";
     })(PropertyLikeParse || (PropertyLikeParse = {}));
     function parseJSDocCommentWorker(start2 = 0, length2) {
-      const saveParsingContext = parsingContext;
-      parsingContext |= 1 << 25 /* StandaloneJSDoc */;
-      const jsdoc = parseJSDocCommentWorkerWorker(start2, length2);
-      parsingContext = saveParsingContext;
-      return jsdoc;
-    }
-    function parseJSDocCommentWorkerWorker(start2, length2) {
       const content = sourceText;
       const end = length2 === void 0 ? content.length : start2 + length2;
       length2 = end - start2;
@@ -47888,6 +47871,7 @@ function createTypeChecker(host) {
   let flowTypeCache;
   const contextualTypeNodes = [];
   const contextualTypes = [];
+  const contextualIsCache = [];
   let contextualTypeCount = 0;
   const inferenceContextNodes = [];
   const inferenceContexts = [];
@@ -55058,6 +55042,8 @@ function createTypeChecker(host) {
         return !!target.baseTypesResolved;
       case 8 /* WriteType */:
         return !!getSymbolLinks(target).writeType;
+      case 9 /* ParameterInitializerContainsUndefined */:
+        return getNodeLinks(target).parameterInitializerContainsUndefined !== void 0;
     }
     return Debug.assertNever(propertyName);
   }
@@ -62849,7 +62835,12 @@ function createTypeChecker(host) {
     }
   }
   function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) {
-    pushContextualType(next, sourcePropType);
+    pushContextualType(
+      next,
+      sourcePropType,
+      /*isCache*/
+      false
+    );
     const result = checkExpressionForMutableLocation(next, 1 /* Contextual */);
     popContextualType();
     return result;
@@ -63157,7 +63148,12 @@ function createTypeChecker(host) {
     if (isTupleLikeType(source)) {
       return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer);
     }
-    pushContextualType(node, target);
+    pushContextualType(
+      node,
+      target,
+      /*isCache*/
+      false
+    );
     const tupleizedType = checkArrayLiteral(
       node,
       1 /* Contextual */,
@@ -69880,15 +69876,25 @@ function createTypeChecker(host) {
   function isConstVariable(symbol) {
     return symbol.flags & 3 /* Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* Const */) !== 0;
   }
-  function removeOptionalityFromDeclaredType(declaredType, declaration) {
-    if (pushTypeResolution(declaration.symbol, 2 /* DeclaredType */)) {
-      const annotationIncludesUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* IsUndefined */);
-      popTypeResolution();
-      return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
-    } else {
-      reportCircularityError(declaration.symbol);
-      return declaredType;
+  function parameterInitializerContainsUndefined(declaration) {
+    const links = getNodeLinks(declaration);
+    if (links.parameterInitializerContainsUndefined === void 0) {
+      if (!pushTypeResolution(declaration, 9 /* ParameterInitializerContainsUndefined */)) {
+        reportCircularityError(declaration.symbol);
+        return true;
+      }
+      const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */);
+      if (!popTypeResolution()) {
+        reportCircularityError(declaration.symbol);
+        return true;
+      }
+      links.parameterInitializerContainsUndefined = containsUndefined;
     }
+    return links.parameterInitializerContainsUndefined;
+  }
+  function removeOptionalityFromDeclaredType(declaredType, declaration) {
+    const removeUndefined = strictNullChecks && declaration.kind === 166 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !parameterInitializerContainsUndefined(declaration);
+    return removeUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
   }
   function isConstraintPosition(type, node) {
     const parent2 = node.parent;
@@ -71206,11 +71212,13 @@ function createTypeChecker(host) {
     if (node.flags & 33554432 /* InWithStatement */) {
       return void 0;
     }
-    const index = findContextualNode(node);
+    const index = findContextualNode(
+      node,
+      /*includeCaches*/
+      !contextFlags
+    );
     if (index >= 0) {
-      const cached = contextualTypes[index];
-      if (cached || !contextFlags)
-        return cached;
+      return contextualTypes[index];
     }
     const { parent: parent2 } = node;
     switch (parent2.kind) {
@@ -71281,17 +71289,30 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function pushContextualType(node, type) {
+  function pushCachedContextualType(node) {
+    pushContextualType(
+      node,
+      getContextualType2(
+        node,
+        /*contextFlags*/
+        void 0
+      ),
+      /*isCache*/
+      true
+    );
+  }
+  function pushContextualType(node, type, isCache) {
     contextualTypeNodes[contextualTypeCount] = node;
     contextualTypes[contextualTypeCount] = type;
+    contextualIsCache[contextualTypeCount] = isCache;
     contextualTypeCount++;
   }
   function popContextualType() {
     contextualTypeCount--;
   }
-  function findContextualNode(node) {
+  function findContextualNode(node, includeCaches) {
     for (let i = contextualTypeCount - 1; i >= 0; i--) {
-      if (node === contextualTypeNodes[i]) {
+      if (node === contextualTypeNodes[i] && (includeCaches || !contextualIsCache[i])) {
         return i;
       }
     }
@@ -71314,7 +71335,11 @@ function createTypeChecker(host) {
   }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
-      const index = findContextualNode(node.parent);
+      const index = findContextualNode(
+        node.parent,
+        /*includeCaches*/
+        !contextFlags
+      );
       if (index >= 0) {
         return contextualTypes[index];
       }
@@ -71585,11 +71610,7 @@ function createTypeChecker(host) {
     const elementCount = elements.length;
     const elementTypes = [];
     const elementFlags = [];
-    pushContextualType(node, getContextualType2(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const inDestructuringPattern = isAssignmentTarget(node);
     const inConstContext = isConstContext(node);
     const contextualType = getApparentTypeOfContextualType(
@@ -71752,11 +71773,7 @@ function createTypeChecker(host) {
     let propertiesTable = createSymbolTable();
     let propertiesArray = [];
     let spread = emptyObjectType;
-    pushContextualType(node, getContextualType2(
-      node,
-      /*contextFlags*/
-      void 0
-    ));
+    pushCachedContextualType(node);
     const contextualType = getApparentTypeOfContextualType(
       node,
       /*contextFlags*/
@@ -77767,14 +77784,19 @@ function createTypeChecker(host) {
     return !!(type.flags & (128 /* StringLiteral */ | 134217728 /* TemplateLiteral */) || type.flags & 58982400 /* InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* StringLike */));
   }
   function getContextNode2(node) {
-    if (node.kind === 289 /* JsxAttributes */ && !isJsxSelfClosingElement(node.parent)) {
+    if (isJsxAttributes(node) && !isJsxSelfClosingElement(node.parent)) {
       return node.parent.parent;
     }
     return node;
   }
   function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) {
     const contextNode = getContextNode2(node);
-    pushContextualType(contextNode, contextualType);
+    pushContextualType(
+      contextNode,
+      contextualType,
+      /*isCache*/
+      false
+    );
     pushInferenceContext(contextNode, inferenceContext);
     const type = checkExpression(node, checkMode | 1 /* Contextual */ | (inferenceContext ? 2 /* Inferential */ : 0));
     if (inferenceContext && inferenceContext.intraExpressionInferenceSites) {
@@ -78115,7 +78137,12 @@ function createTypeChecker(host) {
     if (links.contextFreeType) {
       return links.contextFreeType;
     }
-    pushContextualType(node, anyType);
+    pushContextualType(
+      node,
+      anyType,
+      /*isCache*/
+      false
+    );
     const type = links.contextFreeType = checkExpression(node, 4 /* SkipContextSensitive */);
     popContextualType();
     return type;
@@ -141248,6 +141275,7 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
       sourceFile,
       symbol,
       symbolName2,
+      moduleSymbol,
       /*isJsxTagName*/
       false,
       program,
@@ -141259,7 +141287,6 @@ function createImportAdderWorker(sourceFile, program, useAutoImportProvider, pre
     const fix = getImportFixForSymbol(
       sourceFile,
       Debug.checkDefined(exportInfo),
-      moduleSymbol,
       program,
       /*position*/
       void 0,
@@ -141437,13 +141464,19 @@ function createImportSpecifierResolver(importingFile, program, host, preferences
     return result && { ...result, computedWithoutCacheCount };
   }
 }
-function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
+function getImportCompletionAction(targetSymbol, moduleSymbol, exportMapKey, sourceFile, symbolName2, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) {
   const compilerOptions = program.getCompilerOptions();
-  const exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, isJsxTagName, program, host, preferences, cancellationToken);
-  Debug.assertIsDefined(exportInfos);
+  let exportInfos;
+  if (exportMapKey) {
+    exportInfos = getExportInfoMap(sourceFile, host, program, preferences, cancellationToken).get(sourceFile.path, exportMapKey);
+    Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified exportMapKey");
+  } else {
+    exportInfos = pathIsBareSpecifier(stripQuotes(moduleSymbol.name)) ? [getSingleExportInfoForSymbol(targetSymbol, symbolName2, moduleSymbol, program, host)] : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName2, moduleSymbol, isJsxTagName, program, host, preferences, cancellationToken);
+    Debug.assertIsDefined(exportInfos, "Some exportInfo should match the specified symbol / moduleSymbol");
+  }
   const useRequire = shouldUseRequire(sourceFile, program);
   const isValidTypeOnlyUseSite = isValidTypeOnlyAliasUseSite(getTokenAtPosition(sourceFile, position));
-  const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
+  const fix = Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences));
   return {
     moduleSpecifier: fix.moduleSpecifier,
     codeAction: codeFixActionToCodeAction(codeActionForFix(
@@ -141465,23 +141498,22 @@ function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, ho
   const includeSymbolNameInDescription = symbolName2 !== symbolToken.text;
   return fix && codeFixActionToCodeAction(codeActionForFix({ host, formatContext, preferences }, sourceFile, symbolName2, fix, includeSymbolNameInDescription, compilerOptions, preferences));
 }
-function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
-  Debug.assert(exportInfos.some((info) => info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol), "Some exportInfo should match the specified moduleSymbol");
+function getImportFixForSymbol(sourceFile, exportInfos, program, position, isValidTypeOnlyUseSite, useRequire, host, preferences) {
   const packageJsonImportFilter = createPackageJsonImportFilter(sourceFile, preferences, host);
   return getBestFix(getImportFixes(exportInfos, position, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host);
 }
 function codeFixActionToCodeAction({ description: description2, changes, commands }) {
   return { description: description2, changes, commands };
 }
-function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, preferCapitalized, program, host, preferences, cancellationToken) {
+function getAllExportInfoForSymbol(importingFile, symbol, symbolName2, moduleSymbol, preferCapitalized, program, host, preferences, cancellationToken) {
   const getChecker = createGetChecker(program, host);
   return getExportInfoMap(importingFile, host, program, preferences, cancellationToken).search(importingFile.path, preferCapitalized, (name) => name === symbolName2, (info) => {
-    if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) {
+    if (skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol && info.some((i) => i.moduleSymbol === moduleSymbol || i.symbol.parent === moduleSymbol)) {
       return info;
     }
   });
 }
-function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
+function getSingleExportInfoForSymbol(symbol, symbolName2, moduleSymbol, program, host) {
   var _a2, _b;
   const compilerOptions = program.getCompilerOptions();
   const mainProgramInfo = getInfoWithChecker(
@@ -141503,7 +141535,7 @@ function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) {
     if (defaultInfo && skipAlias(defaultInfo.symbol, checker) === symbol) {
       return { symbol: defaultInfo.symbol, moduleSymbol, moduleFileName: void 0, exportKind: defaultInfo.exportKind, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
-    const named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol);
+    const named = checker.tryGetMemberInModuleExportsAndProperties(symbolName2, moduleSymbol);
     if (named && skipAlias(named, checker) === symbol) {
       return { symbol: named, moduleSymbol, moduleFileName: void 0, exportKind: 0 /* Named */, targetFlags: skipAlias(symbol, checker).flags, isFromPackageJson };
     }
@@ -149162,6 +149194,7 @@ function originToCompletionEntryData(origin) {
   if (originIsResolvedExport(origin)) {
     const resolvedData = {
       exportName: origin.exportName,
+      exportMapKey: origin.exportMapKey,
       moduleSpecifier: origin.moduleSpecifier,
       ambientModuleName,
       fileName: origin.fileName,
@@ -149185,6 +149218,7 @@ function completionEntryDataToSymbolOriginInfo(data, completionName, moduleSymbo
     const resolvedOrigin = {
       kind: 32 /* ResolvedExport */,
       exportName: data.exportName,
+      exportMapKey: data.exportMapKey,
       moduleSpecifier: data.moduleSpecifier,
       symbolName: completionName,
       fileName: data.fileName,
@@ -149563,6 +149597,7 @@ function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextTo
   const { moduleSpecifier, codeAction } = ts_codefix_exports.getImportCompletionAction(
     targetSymbol,
     moduleSymbol,
+    data == null ? void 0 : data.exportMapKey,
     sourceFile,
     name,
     isJsxOpeningTagName,
@@ -150261,16 +150296,16 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
             if (detailsEntryId && !some(info, (i) => detailsEntryId.source === stripQuotes(i.moduleSymbol.name))) {
               return;
             }
-            const firstImportableExportInfo = find(info, isImportableExportInfo);
-            if (!firstImportableExportInfo) {
+            info = filter(info, isImportableExportInfo);
+            if (!info.length) {
               return;
             }
             const result = context.tryResolve(info, isFromAmbientModule) || {};
             if (result === "failed")
               return;
-            let exportInfo2 = firstImportableExportInfo, moduleSpecifier;
+            let exportInfo2 = info[0], moduleSpecifier;
             if (result !== "skipped") {
-              ({ exportInfo: exportInfo2 = firstImportableExportInfo, moduleSpecifier } = result);
+              ({ exportInfo: exportInfo2 = info[0], moduleSpecifier } = result);
             }
             const isDefaultExport = exportInfo2.exportKind === 1 /* Default */;
             const symbol = isDefaultExport && getLocalSymbolForExportDefault(exportInfo2.symbol) || exportInfo2.symbol;