typescript 5.6.0-dev.20240819 → 5.7.0-dev.20240820

package/lib/typescript.d.ts

@@ -3595,7 +3595,7 @@ declare namespace ts {
             readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[] | undefined, depth?: number): string[];
         }
     }
-    const versionMajorMinor = "5.6";
+    const versionMajorMinor = "5.7";
     /** The version of the TypeScript compiler release */
     const version: string;
     /**
@@ -6121,6 +6121,27 @@ declare namespace ts {
         getBaseTypes(type: InterfaceType): BaseType[];
         getBaseTypeOfLiteralType(type: Type): Type;
         getWidenedType(type: Type): Type;
+        /**
+         * Gets the "awaited type" of a type.
+         *
+         * If an expression has a Promise-like type, the "awaited type" of the expression is
+         * derived from the type of the first argument of the fulfillment callback for that
+         * Promise's `then` method. If the "awaited type" is itself a Promise-like, it is
+         * recursively unwrapped in the same manner until a non-promise type is found.
+         *
+         * If an expression does not have a Promise-like type, its "awaited type" is the type
+         * of the expression.
+         *
+         * If the resulting "awaited type" is a generic object type, then it is wrapped in
+         * an `Awaited<T>`.
+         *
+         * In the event the "awaited type" circularly references itself, or is a non-Promise
+         * object-type with a callable `then()` method, an "awaited type" cannot be determined
+         * and the value `undefined` will be returned.
+         *
+         * This is used to reflect the runtime behavior of the `await` keyword.
+         */
+        getAwaitedType(type: Type): Type | undefined;
         getReturnTypeOfSignature(signature: Signature): Type;
         getNullableType(type: Type, flags: TypeFlags): Type;
         getNonNullableType(type: Type): Type;

package/lib/typescript.js

@@ -2262,8 +2262,8 @@ __export(typescript_exports, {
 module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240819`;
+var versionMajorMinor = "5.7";
+var version = `${versionMajorMinor}.0-dev.20240820`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -75990,46 +75990,108 @@ function createTypeChecker(host) {
   function isCircularMappedProperty(symbol) {
     return !!(getCheckFlags(symbol) & 262144 /* Mapped */ && !symbol.links.type && findResolutionCycleStartIndex(symbol, 0 /* Type */) >= 0);
   }
+  function isExcludedMappedPropertyName(constraint, propertyNameType) {
+    if (constraint.flags & 16777216 /* Conditional */) {
+      const type = constraint;
+      return !!(getReducedType(getTrueTypeFromConditionalType(type)).flags & 131072 /* Never */) && getActualTypeVariable(getFalseTypeFromConditionalType(type)) === getActualTypeVariable(type.checkType) && isTypeAssignableTo(propertyNameType, type.extendsType);
+    }
+    if (constraint.flags & 2097152 /* Intersection */) {
+      return some(constraint.types, (t) => isExcludedMappedPropertyName(t, propertyNameType));
+    }
+    return false;
+  }
   function getTypeOfPropertyOfContextualType(type, name, nameType) {
     return mapType(
       type,
       (t) => {
-        var _a;
-        if (isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */) {
-          const constraint = getConstraintTypeFromMappedType(t);
-          const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
-          const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
-          if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
-            return substituteIndexedMappedType(t, propertyNameType);
-          }
-        } else if (t.flags & 3670016 /* StructuredType */) {
-          const prop = getPropertyOfType(t, name);
-          if (prop) {
-            return isCircularMappedProperty(prop) ? void 0 : removeMissingType(getTypeOfSymbol(prop), !!(prop.flags & 16777216 /* Optional */));
+        if (t.flags & 2097152 /* Intersection */) {
+          let types;
+          let indexInfoCandidates;
+          let ignoreIndexInfos = false;
+          for (const constituentType of t.types) {
+            if (!(constituentType.flags & 524288 /* Object */)) {
+              continue;
+            }
+            if (isGenericMappedType(constituentType) && getMappedTypeNameTypeKind(constituentType) !== 2 /* Remapping */) {
+              const substitutedType = getIndexedMappedTypeSubstitutedTypeOfContextualType(constituentType, name, nameType);
+              types = appendContextualPropertyTypeConstituent(types, substitutedType);
+              continue;
+            }
+            const propertyType = getTypeOfConcretePropertyOfContextualType(constituentType, name);
+            if (!propertyType) {
+              if (!ignoreIndexInfos) {
+                indexInfoCandidates = append(indexInfoCandidates, constituentType);
+              }
+              continue;
+            }
+            ignoreIndexInfos = true;
+            indexInfoCandidates = void 0;
+            types = appendContextualPropertyTypeConstituent(types, propertyType);
           }
-          if (isTupleType(t) && isNumericLiteralName(name) && +name >= 0) {
-            const restType = getElementTypeOfSliceOfTupleType(
-              t,
-              t.target.fixedLength,
-              /*endSkipCount*/
-              0,
-              /*writing*/
-              false,
-              /*noReductions*/
-              true
-            );
-            if (restType) {
-              return restType;
+          if (indexInfoCandidates) {
+            for (const candidate of indexInfoCandidates) {
+              const indexInfoType = getTypeFromIndexInfosOfContextualType(candidate, name, nameType);
+              types = appendContextualPropertyTypeConstituent(types, indexInfoType);
             }
           }
-          return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+          if (!types) {
+            return;
+          }
+          if (types.length === 1) {
+            return types[0];
+          }
+          return getIntersectionType(types);
         }
-        return void 0;
+        if (!(t.flags & 524288 /* Object */)) {
+          return;
+        }
+        return isGenericMappedType(t) && getMappedTypeNameTypeKind(t) !== 2 /* Remapping */ ? getIndexedMappedTypeSubstitutedTypeOfContextualType(t, name, nameType) : getTypeOfConcretePropertyOfContextualType(t, name) ?? getTypeFromIndexInfosOfContextualType(t, name, nameType);
       },
       /*noReductions*/
       true
     );
   }
+  function appendContextualPropertyTypeConstituent(types, type) {
+    return type ? append(types, type.flags & 1 /* Any */ ? unknownType : type) : types;
+  }
+  function getIndexedMappedTypeSubstitutedTypeOfContextualType(type, name, nameType) {
+    const propertyNameType = nameType || getStringLiteralType(unescapeLeadingUnderscores(name));
+    const constraint = getConstraintTypeFromMappedType(type);
+    if (type.nameType && isExcludedMappedPropertyName(type.nameType, propertyNameType) || isExcludedMappedPropertyName(constraint, propertyNameType)) {
+      return;
+    }
+    const constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint;
+    if (!isTypeAssignableTo(propertyNameType, constraintOfConstraint)) {
+      return;
+    }
+    return substituteIndexedMappedType(type, propertyNameType);
+  }
+  function getTypeOfConcretePropertyOfContextualType(type, name) {
+    const prop = getPropertyOfType(type, name);
+    if (!prop || isCircularMappedProperty(prop)) {
+      return;
+    }
+    return removeMissingType(getTypeOfSymbol(prop), !!(prop.flags & 16777216 /* Optional */));
+  }
+  function getTypeFromIndexInfosOfContextualType(type, name, nameType) {
+    var _a;
+    if (isTupleType(type) && isNumericLiteralName(name) && +name >= 0) {
+      const restType = getElementTypeOfSliceOfTupleType(
+        type,
+        type.target.fixedLength,
+        /*endSkipCount*/
+        0,
+        /*writing*/
+        false,
+        /*noReductions*/
+        true
+      );
+      if (restType) {
+        return restType;
+      }
+    }
+    return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(type), nameType || getStringLiteralType(unescapeLeadingUnderscores(name)))) == null ? void 0 : _a.type;
+  }
   function getContextualTypeForObjectLiteralMethod(node, contextFlags) {
     Debug.assert(isObjectLiteralMethod(node));
     if (node.flags & 67108864 /* InWithStatement */) {
@@ -163481,6 +163543,8 @@ var SortText = {
     return sortText + "1";
   }
 };
+var allCommitCharacters = [".", ",", ";"];
+var noCommaCommitCharacters = [".", ";"];
 var CompletionSource = /* @__PURE__ */ ((CompletionSource2) => {
   CompletionSource2["ThisProperty"] = "ThisProperty/";
   CompletionSource2["ClassMemberSnippet"] = "ClassMemberSnippet/";
@@ -163587,7 +163651,7 @@ function getDefaultCommitCharacters(isNewIdentifierLocation) {
   if (isNewIdentifierLocation) {
     return [];
   }
-  return [".", ",", ";"];
+  return allCommitCharacters;
 }
 function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext, includeSymbol = false) {
   var _a;
@@ -164085,7 +164149,8 @@ function completionInfoFromData(sourceFile, host, program, compilerOptions, log,
     importStatementCompletion,
     insideJsDocTagTypeExpression,
     symbolToSortTextMap,
-    hasUnresolvedAutoImports
+    hasUnresolvedAutoImports,
+    defaultCommitCharacters
   } = completionData;
   let literals = completionData.literals;
   const checker = program.getTypeChecker();
@@ -164203,7 +164268,7 @@ function completionInfoFromData(sourceFile, host, program, compilerOptions, log,
     isNewIdentifierLocation,
     optionalReplacementSpan: getOptionalReplacementSpan(location),
     entries,
-    defaultCommitCharacters: getDefaultCommitCharacters(isNewIdentifierLocation)
+    defaultCommitCharacters: defaultCommitCharacters ?? getDefaultCommitCharacters(isNewIdentifierLocation)
   };
 }
 function isCheckedFile(sourceFile, compilerOptions) {
@@ -165602,6 +165667,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   let keywordFilters = 0 /* None */;
   let isNewIdentifierLocation = false;
   let flags = 0 /* None */;
+  let defaultCommitCharacters;
   if (contextToken) {
     const importStatementCompletionInfo = getImportStatementCompletionInfo(contextToken, sourceFile);
     if (importStatementCompletionInfo.keywordCompletion) {
@@ -165621,7 +165687,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     }
     if (!importStatementCompletionInfo.replacementSpan && isCompletionListBlocker(contextToken)) {
       log("Returning an empty list because completion was requested in an invalid position.");
-      return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierDefinitionLocation()) : void 0;
+      return keywordFilters ? keywordCompletionData(keywordFilters, isJsOnlyLocation, computeCommitCharactersAndIsNewIdentifier().isNewIdentifierLocation) : void 0;
     }
     let parent2 = contextToken.parent;
     if (contextToken.kind === 25 /* DotToken */ || contextToken.kind === 29 /* QuestionDotToken */) {
@@ -165780,7 +165846,8 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     isRightOfDotOrQuestionDot: isRightOfDot || isRightOfQuestionDot,
     importStatementCompletion,
     hasUnresolvedAutoImports,
-    flags
+    flags,
+    defaultCommitCharacters
   };
   function isTagWithTypeExpression(tag) {
     switch (tag.kind) {
@@ -165815,7 +165882,10 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     const isRhsOfImportDeclaration = isInRightSideOfInternalImportEqualsDeclaration(node);
     if (isEntityName(node) || isImportType || isPropertyAccessExpression(node)) {
       const isNamespaceName = isModuleDeclaration(node.parent);
-      if (isNamespaceName) isNewIdentifierLocation = true;
+      if (isNamespaceName) {
+        isNewIdentifierLocation = true;
+        defaultCommitCharacters = [];
+      }
       let symbol = typeChecker.getSymbolAtLocation(node);
       if (symbol) {
         symbol = skipAlias(symbol, typeChecker);
@@ -165885,9 +165955,13 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     }
   }
   function addTypeProperties(type, insertAwait, insertQuestionDot) {
-    isNewIdentifierLocation = !!type.getStringIndexType();
+    if (type.getStringIndexType()) {
+      isNewIdentifierLocation = true;
+      defaultCommitCharacters = [];
+    }
     if (isRightOfQuestionDot && some(type.getCallSignatures())) {
       isNewIdentifierLocation = true;
+      defaultCommitCharacters ?? (defaultCommitCharacters = allCommitCharacters);
     }
     const propertyAccess = node.kind === 205 /* ImportType */ ? node : node.parent;
     if (inCheckedFile) {
@@ -166026,7 +166100,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   function getGlobalCompletions() {
     keywordFilters = tryGetFunctionLikeBodyCompletionContainer(contextToken) ? 5 /* FunctionLikeBodyKeywords */ : 1 /* All */;
     completionKind = 1 /* Global */;
-    isNewIdentifierLocation = isNewIdentifierDefinitionLocation();
+    ({ isNewIdentifierLocation, defaultCommitCharacters } = computeCommitCharactersAndIsNewIdentifier());
     if (previousToken !== contextToken) {
       Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'.");
     }
@@ -166292,41 +166366,109 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
     }
     return false;
   }
-  function isNewIdentifierDefinitionLocation() {
+  function computeCommitCharactersAndIsNewIdentifier() {
     if (contextToken) {
       const containingNodeKind = contextToken.parent.kind;
       const tokenKind = keywordForNode(contextToken);
       switch (tokenKind) {
         case 28 /* CommaToken */:
-          return containingNodeKind === 213 /* CallExpression */ || containingNodeKind === 176 /* Constructor */ || containingNodeKind === 214 /* NewExpression */ || containingNodeKind === 209 /* ArrayLiteralExpression */ || containingNodeKind === 226 /* BinaryExpression */ || containingNodeKind === 184 /* FunctionType */ || containingNodeKind === 210 /* ObjectLiteralExpression */;
+          switch (containingNodeKind) {
+            case 213 /* CallExpression */:
+            case 214 /* NewExpression */: {
+              const expression = contextToken.parent.expression;
+              if (getLineAndCharacterOfPosition(sourceFile, expression.end).line !== getLineAndCharacterOfPosition(sourceFile, position).line) {
+                return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true };
+              }
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
+            }
+            case 226 /* BinaryExpression */:
+              return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true };
+            case 176 /* Constructor */:
+            case 184 /* FunctionType */:
+            case 210 /* ObjectLiteralExpression */:
+              return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
+            case 209 /* ArrayLiteralExpression */:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
+            default:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
+          }
         case 21 /* OpenParenToken */:
-          return containingNodeKind === 213 /* CallExpression */ || containingNodeKind === 176 /* Constructor */ || containingNodeKind === 214 /* NewExpression */ || containingNodeKind === 217 /* ParenthesizedExpression */ || containingNodeKind === 196 /* ParenthesizedType */;
+          switch (containingNodeKind) {
+            case 213 /* CallExpression */:
+            case 214 /* NewExpression */: {
+              const expression = contextToken.parent.expression;
+              if (getLineAndCharacterOfPosition(sourceFile, expression.end).line !== getLineAndCharacterOfPosition(sourceFile, position).line) {
+                return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true };
+              }
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
+            }
+            case 217 /* ParenthesizedExpression */:
+              return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true };
+            case 176 /* Constructor */:
+            case 196 /* ParenthesizedType */:
+              return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
+            default:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
+          }
         case 23 /* OpenBracketToken */:
-          return containingNodeKind === 209 /* ArrayLiteralExpression */ || containingNodeKind === 181 /* IndexSignature */ || containingNodeKind === 167 /* ComputedPropertyName */;
+          switch (containingNodeKind) {
+            case 209 /* ArrayLiteralExpression */:
+            case 181 /* IndexSignature */:
+            case 189 /* TupleType */:
+            case 167 /* ComputedPropertyName */:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
+            default:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
+          }
         case 144 /* ModuleKeyword */:
         case 145 /* NamespaceKeyword */:
         case 102 /* ImportKeyword */:
-          return true;
+          return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
         case 25 /* DotToken */:
-          return containingNodeKind === 267 /* ModuleDeclaration */;
+          switch (containingNodeKind) {
+            case 267 /* ModuleDeclaration */:
+              return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
+            default:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
+          }
         case 19 /* OpenBraceToken */:
-          return containingNodeKind === 263 /* ClassDeclaration */ || containingNodeKind === 210 /* ObjectLiteralExpression */;
+          switch (containingNodeKind) {
+            case 263 /* ClassDeclaration */:
+            case 210 /* ObjectLiteralExpression */:
+              return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
+            default:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
+          }
         case 64 /* EqualsToken */:
-          return containingNodeKind === 260 /* VariableDeclaration */ || containingNodeKind === 226 /* BinaryExpression */;
+          switch (containingNodeKind) {
+            case 260 /* VariableDeclaration */:
+            case 226 /* BinaryExpression */:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
+            default:
+              return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
+          }
         case 16 /* TemplateHead */:
-          return containingNodeKind === 228 /* TemplateExpression */;
+          return {
+            defaultCommitCharacters: allCommitCharacters,
+            isNewIdentifierLocation: containingNodeKind === 228 /* TemplateExpression */
+            // `aa ${|
+          };
         case 17 /* TemplateMiddle */:
-          return containingNodeKind === 239 /* TemplateSpan */;
+          return {
+            defaultCommitCharacters: allCommitCharacters,
+            isNewIdentifierLocation: containingNodeKind === 239 /* TemplateSpan */
+            // `aa ${10} dd ${|
+          };
         case 134 /* AsyncKeyword */:
-          return containingNodeKind === 174 /* MethodDeclaration */ || containingNodeKind === 304 /* ShorthandPropertyAssignment */;
+          return containingNodeKind === 174 /* MethodDeclaration */ || containingNodeKind === 304 /* ShorthandPropertyAssignment */ ? { defaultCommitCharacters: [], isNewIdentifierLocation: true } : { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
         case 42 /* AsteriskToken */:
-          return containingNodeKind === 174 /* MethodDeclaration */;
+          return containingNodeKind === 174 /* MethodDeclaration */ ? { defaultCommitCharacters: [], isNewIdentifierLocation: true } : { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
       }
       if (isClassMemberCompletionKeyword(tokenKind)) {
-        return true;
+        return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
       }
     }
-    return false;
+    return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
   }
   function isInStringOrRegularExpressionOrTemplateLiteral(contextToken2) {
     return (isRegularExpressionLiteral(contextToken2) || isStringTextContainingNode(contextToken2)) && (rangeContainsPositionExclusive(contextToken2, position) || position === contextToken2.end && (!!contextToken2.isUnterminated || isRegularExpressionLiteral(contextToken2)));
@@ -179399,13 +179541,13 @@ function pasteEditsProvider(targetFile, pastedText, pasteLocations, copiedFrom,
 function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, preferences, formatContext, cancellationToken, changes) {
   let actualPastedText;
   if (pastedText.length !== pasteLocations.length) {
-    actualPastedText = pastedText.length === 1 ? pastedText : [pastedText.join("\n")];
+    actualPastedText = pastedText.length === 1 ? pastedText[0] : pastedText.join(getNewLineOrDefaultFromHost(formatContext.host, formatContext.options));
   }
   const statements = [];
   let newText = targetFile.text;
   for (let i = pasteLocations.length - 1; i >= 0; i--) {
     const { pos, end } = pasteLocations[i];
-    newText = actualPastedText ? newText.slice(0, pos) + actualPastedText[0] + newText.slice(end) : newText.slice(0, pos) + pastedText[i] + newText.slice(end);
+    newText = actualPastedText ? newText.slice(0, pos) + actualPastedText + newText.slice(end) : newText.slice(0, pos) + pastedText[i] + newText.slice(end);
   }
   let importAdder;
   Debug.checkDefined(host.runWithTemporaryFileUpdate).call(host, targetFile.fileName, newText, (updatedProgram, originalProgram, updatedFile) => {
@@ -179436,22 +179578,37 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr
         preferences,
         formatContext
       };
-      forEachChild(updatedFile, function cb(node) {
-        if (isIdentifier(node) && !(originalProgram == null ? void 0 : originalProgram.getTypeChecker().resolveName(
-          node.text,
-          node,
-          -1 /* All */,
-          /*excludeGlobals*/
-          false
-        ))) {
-          importAdder.addImportForUnresolvedIdentifier(
-            context,
+      let offset = 0;
+      pasteLocations.forEach((location, i) => {
+        const oldTextLength = location.end - location.pos;
+        const textToBePasted = actualPastedText ?? pastedText[i];
+        const startPos = location.pos + offset;
+        const endPos = startPos + textToBePasted.length;
+        const range = { pos: startPos, end: endPos };
+        offset += textToBePasted.length - oldTextLength;
+        const enclosingNode = findAncestor(
+          getTokenAtPosition(context.sourceFile, range.pos),
+          (ancestorNode) => rangeContainsRange(ancestorNode, range)
+        );
+        if (!enclosingNode) return;
+        forEachChild(enclosingNode, function importUnresolvedIdentifiers(node) {
+          const isImportCandidate = isIdentifier(node) && rangeContainsPosition(range, node.getStart(updatedFile)) && !(updatedProgram == null ? void 0 : updatedProgram.getTypeChecker().resolveName(
+            node.text,
             node,
-            /*useAutoImportProvider*/
-            true
-          );
-        }
-        node.forEachChild(cb);
+            -1 /* All */,
+            /*excludeGlobals*/
+            false
+          ));
+          if (isImportCandidate) {
+            return importAdder.addImportForUnresolvedIdentifier(
+              context,
+              node,
+              /*useAutoImportProvider*/
+              true
+            );
+          }
+          node.forEachChild(importUnresolvedIdentifiers);
+        });
       });
     }
     importAdder.writeFixes(changes, getQuotePreference(copiedFrom ? copiedFrom.file : targetFile, preferences));
@@ -179463,7 +179620,7 @@ function pasteEdits(targetFile, pastedText, pasteLocations, copiedFrom, host, pr
     changes.replaceRangeWithText(
       targetFile,
       { pos: paste.pos, end: paste.end },
-      actualPastedText ? actualPastedText[0] : pastedText[i]
+      actualPastedText ?? pastedText[i]
     );
   });
 }
@@ -188987,7 +189144,7 @@ Dynamic files must always be opened with service's current directory or service
     if (cleanupAfter) {
       this.cleanupConfiguredProjects(
         configuredProjects,
-        new Set(proj.projectFileName)
+        /* @__PURE__ */ new Set([proj.projectFileName])
       );
       this.printProjects();
     }

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.6.0-dev.20240819",
+    "version": "5.7.0-dev.20240820",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -117,5 +117,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "2a8865e6ba95c9bdcdb9e2c9c08f10c5f5c75391"
+    "gitHead": "2192336dfee6f740b5828c8a4a8226e56626de1d"
 }