@typescript-deploys/pr-build 5.2.0-pr-54316-2 → 5.2.0-pr-54052-23

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.2";
-      version = `${versionMajorMinor}.0-insiders.20230518`;
+      version = `${versionMajorMinor}.0-insiders.20230526`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -37258,6 +37258,7 @@ ${lanes.join("\n")}
         ["es2015.symbol", "lib.es2015.symbol.d.ts"],
         ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"],
         ["es2016.array.include", "lib.es2016.array.include.d.ts"],
+        ["es2017.date", "lib.es2017.date.d.ts"],
         ["es2017.object", "lib.es2017.object.d.ts"],
         ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"],
         ["es2017.string", "lib.es2017.string.d.ts"],
@@ -50343,32 +50344,34 @@ ${lanes.join("\n")}
             const methodDeclaration = signatureToSignatureDeclarationHelper(signature, 172 /* MethodSignature */, context, { name: propertyName, questionToken: optionalToken });
             typeElements.push(preserveCommentsOn(methodDeclaration));
           }
+          if (signatures.length || !optionalToken) {
+            return;
+          }
+        }
+        let propertyTypeNode;
+        if (shouldUsePlaceholderForProperty(propertySymbol, context)) {
+          propertyTypeNode = createElidedInformationPlaceholder(context);
         } else {
-          let propertyTypeNode;
-          if (shouldUsePlaceholderForProperty(propertySymbol, context)) {
-            propertyTypeNode = createElidedInformationPlaceholder(context);
-          } else {
-            if (propertyIsReverseMapped) {
-              context.reverseMappedStack || (context.reverseMappedStack = []);
-              context.reverseMappedStack.push(propertySymbol);
-            }
-            propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(133 /* AnyKeyword */);
-            if (propertyIsReverseMapped) {
-              context.reverseMappedStack.pop();
-            }
+          if (propertyIsReverseMapped) {
+            context.reverseMappedStack || (context.reverseMappedStack = []);
+            context.reverseMappedStack.push(propertySymbol);
           }
-          const modifiers = isReadonlySymbol(propertySymbol) ? [factory.createToken(148 /* ReadonlyKeyword */)] : void 0;
-          if (modifiers) {
-            context.approximateLength += 9;
+          propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(133 /* AnyKeyword */);
+          if (propertyIsReverseMapped) {
+            context.reverseMappedStack.pop();
           }
-          const propertySignature = factory.createPropertySignature(
-            modifiers,
-            propertyName,
-            optionalToken,
-            propertyTypeNode
-          );
-          typeElements.push(preserveCommentsOn(propertySignature));
         }
+        const modifiers = isReadonlySymbol(propertySymbol) ? [factory.createToken(148 /* ReadonlyKeyword */)] : void 0;
+        if (modifiers) {
+          context.approximateLength += 9;
+        }
+        const propertySignature = factory.createPropertySignature(
+          modifiers,
+          propertyName,
+          optionalToken,
+          propertyTypeNode
+        );
+        typeElements.push(preserveCommentsOn(propertySignature));
         function preserveCommentsOn(node) {
           var _a2;
           if (some(propertySymbol.declarations, (d) => d.kind === 354 /* JSDocPropertyTag */)) {
@@ -56431,7 +56434,7 @@ ${lanes.join("\n")}
         } else if (type !== firstType) {
           checkFlags |= 64 /* HasNonUniformType */;
         }
-        if (isLiteralType(type) || isPatternLiteralType(type) || type === uniqueLiteralType) {
+        if (isLiteralType(type) || isPatternLiteralType(type)) {
           checkFlags |= 128 /* HasLiteralType */;
         }
         if (type.flags & 131072 /* Never */ && type !== uniqueLiteralType) {
@@ -58658,31 +58661,28 @@ ${lanes.join("\n")}
       return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
     }
     function getUnionOrIntersectionTypePredicate(signatures, kind) {
-      let first2;
+      let last2;
       const types = [];
       for (const sig of signatures) {
         const pred = getTypePredicateOfSignature(sig);
-        if (!pred || pred.kind === 2 /* AssertsThis */ || pred.kind === 3 /* AssertsIdentifier */) {
-          if (kind !== 2097152 /* Intersection */) {
-            continue;
-          } else {
-            return;
-          }
-        }
-        if (first2) {
-          if (!typePredicateKindsMatch(first2, pred)) {
+        if (pred) {
+          if (pred.kind !== 0 /* This */ && pred.kind !== 1 /* Identifier */ || last2 && !typePredicateKindsMatch(last2, pred)) {
             return void 0;
           }
+          last2 = pred;
+          types.push(pred.type);
         } else {
-          first2 = pred;
+          const returnType = kind !== 2097152 /* Intersection */ ? getReturnTypeOfSignature(sig) : void 0;
+          if (returnType !== falseType && returnType !== regularFalseType) {
+            return void 0;
+          }
         }
-        types.push(pred.type);
       }
-      if (!first2) {
+      if (!last2) {
         return void 0;
       }
       const compositeType = getUnionOrIntersectionType(types, kind);
-      return createTypePredicate(first2.kind, first2.parameterName, first2.parameterIndex, compositeType);
+      return createTypePredicate(last2.kind, last2.parameterName, last2.parameterIndex, compositeType);
     }
     function typePredicateKindsMatch(a, b) {
       return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
@@ -59724,9 +59724,9 @@ ${lanes.join("\n")}
           );
           if (freshMapper) {
             const freshCombinedMapper = combineTypeMappers(mapper, freshMapper);
-            for (const p of freshParams) {
-              if (root.inferTypeParameters.indexOf(p) === -1) {
-                p.mapper = freshCombinedMapper;
+            for (let i = 0; i < freshParams.length; i++) {
+              if (freshParams[i] !== root.inferTypeParameters[i]) {
+                freshParams[i].mapper = freshCombinedMapper;
               }
             }
           }
@@ -60563,18 +60563,19 @@ ${lanes.join("\n")}
           case 185 /* TypeQuery */:
             const entityName = node2.exprName;
             const firstIdentifier = getFirstIdentifier(entityName);
-            const firstIdentifierSymbol = getResolvedSymbol(firstIdentifier);
-            const tpDeclaration = tp.symbol.declarations[0];
-            let tpScope;
-            if (tpDeclaration.kind === 167 /* TypeParameter */) {
-              tpScope = tpDeclaration.parent;
-            } else if (tp.isThisType) {
-              tpScope = tpDeclaration;
-            } else {
-              return true;
-            }
-            if (firstIdentifierSymbol.declarations) {
-              return some(firstIdentifierSymbol.declarations, (idDecl) => isNodeDescendantOf(idDecl, tpScope)) || some(node2.typeArguments, containsReference);
+            if (!isThisIdentifier(firstIdentifier)) {
+              const firstIdentifierSymbol = getResolvedSymbol(firstIdentifier);
+              const tpDeclaration = tp.symbol.declarations[0];
+              const tpScope = tpDeclaration.kind === 167 /* TypeParameter */ ? tpDeclaration.parent : (
+                // Type parameter is a regular type parameter, e.g. foo<T>
+                tp.isThisType ? tpDeclaration : (
+                  // Type parameter is the this type, and its declaration is the class declaration.
+                  void 0
+                )
+              );
+              if (firstIdentifierSymbol.declarations && tpScope) {
+                return some(firstIdentifierSymbol.declarations, (idDecl) => isNodeDescendantOf(idDecl, tpScope)) || some(node2.typeArguments, containsReference);
+              }
             }
             return true;
           case 173 /* MethodDeclaration */:
@@ -60628,6 +60629,9 @@ ${lanes.join("\n")}
       const elementFlags = tupleType.target.elementFlags;
       const elementTypes = map(getElementTypes(tupleType), (t, i) => {
         const singleton = elementFlags[i] & 8 /* Variadic */ ? t : elementFlags[i] & 4 /* Rest */ ? createArrayType(t) : createTupleType([t], [elementFlags[i]]);
+        if (singleton === typeVariable) {
+          return mappedType;
+        }
         return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper));
       });
       const newReadonly = getModifiedReadonlyState(tupleType.target.readonly, getMappedTypeModifiers(mappedType));
@@ -60965,6 +60969,10 @@ ${lanes.join("\n")}
         return true;
       }
       switch (node.kind) {
+        case 233 /* AsExpression */:
+          if (!isConstAssertion(node)) {
+            break;
+          }
         case 293 /* JsxExpression */:
         case 216 /* ParenthesizedExpression */:
           return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
@@ -64212,7 +64220,7 @@ ${lanes.join("\n")}
           }
         }
       }
-      const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i])) : target;
+      const filtered = contains(include, 0 /* False */) ? getUnionType(types.filter((_, i) => include[i]), 0 /* None */) : target;
       return filtered.flags & 131072 /* Never */ ? target : filtered;
     }
     function isWeakType(type) {
@@ -64416,7 +64424,7 @@ ${lanes.join("\n")}
     }
     function getRecursionIdentity(type) {
       if (type.flags & 524288 /* Object */ && !isObjectOrArrayLiteralType(type)) {
-        if (getObjectFlags(type) && 4 /* Reference */ && type.node) {
+        if (getObjectFlags(type) & 4 /* Reference */ && type.node) {
           return type.node;
         }
         if (type.symbol && !(getObjectFlags(type) & 16 /* Anonymous */ && type.symbol.flags & 32 /* Class */)) {
@@ -67243,7 +67251,7 @@ ${lanes.join("\n")}
             target.antecedents = saveAntecedents;
           } else if (flags & 2 /* Start */) {
             const container = flow.node;
-            if (container && container !== flowContainer && reference.kind !== 210 /* PropertyAccessExpression */ && reference.kind !== 211 /* ElementAccessExpression */ && reference.kind !== 110 /* ThisKeyword */) {
+            if (container && container !== flowContainer && reference.kind !== 210 /* PropertyAccessExpression */ && reference.kind !== 211 /* ElementAccessExpression */ && !(reference.kind === 110 /* ThisKeyword */ && container.kind !== 218 /* ArrowFunction */)) {
               flow = container.flowNode;
               continue;
             }
@@ -75730,7 +75738,7 @@ ${lanes.join("\n")}
           Debug.assertIsDefined(leftType);
           const rightType = getLastResult(state);
           Debug.assertIsDefined(rightType);
-          result = checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node);
+          result = checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, state.checkMode, node);
         }
         state.skip = false;
         setLeftType(
@@ -75792,9 +75800,9 @@ ${lanes.join("\n")}
         leftType = checkExpression(left, checkMode);
       }
       const rightType = checkExpression(right, checkMode);
-      return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode);
+      return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, checkMode, errorNode);
     }
-    function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) {
+    function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, checkMode, errorNode) {
       const operator = operatorToken.kind;
       switch (operator) {
         case 42 /* AsteriskToken */:
@@ -75951,12 +75959,14 @@ ${lanes.join("\n")}
         case 36 /* ExclamationEqualsToken */:
         case 37 /* EqualsEqualsEqualsToken */:
         case 38 /* ExclamationEqualsEqualsToken */:
-          if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
-            const eqType = operator === 35 /* EqualsEqualsToken */ || operator === 37 /* EqualsEqualsEqualsToken */;
-            error(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
+          if (!(checkMode && checkMode & 128 /* TypeOnly */)) {
+            if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
+              const eqType = operator === 35 /* EqualsEqualsToken */ || operator === 37 /* EqualsEqualsEqualsToken */;
+              error(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
+            }
+            checkNaNEquality(errorNode, operator, left, right);
+            reportOperatorErrorUnless((left2, right2) => isTypeEqualityComparableTo(left2, right2) || isTypeEqualityComparableTo(right2, left2));
           }
-          checkNaNEquality(errorNode, operator, left, right);
-          reportOperatorErrorUnless((left2, right2) => isTypeEqualityComparableTo(left2, right2) || isTypeEqualityComparableTo(right2, left2));
           return booleanType;
         case 104 /* InstanceOfKeyword */:
           return checkInstanceOfExpression(left, right, leftType, rightType);
@@ -76267,7 +76277,7 @@ ${lanes.join("\n")}
       }
     }
     function checkConditionalExpression(node, checkMode) {
-      const type = checkTruthinessExpression(node.condition);
+      const type = checkTruthinessExpression(node.condition, checkMode);
       checkTestingKnownTruthyCallableOrAwaitableType(node.condition, type, node.whenTrue);
       const type1 = checkExpression(node.whenTrue, checkMode);
       const type2 = checkExpression(node.whenFalse, checkMode);
@@ -76608,7 +76618,7 @@ ${lanes.join("\n")}
         }
       }
       const startInvocationCount = flowInvocationCount;
-      const type = checkExpression(node);
+      const type = checkExpression(node, 128 /* TypeOnly */);
       if (flowInvocationCount !== startInvocationCount) {
         const cache = flowTypeCache || (flowTypeCache = []);
         cache[getNodeId(node)] = type;
@@ -76684,7 +76694,7 @@ ${lanes.join("\n")}
       if (getIsolatedModules(compilerOptions)) {
         Debug.assert(!!(type.symbol.flags & 128 /* ConstEnum */));
         const constEnumDeclaration = type.symbol.valueDeclaration;
-        if (constEnumDeclaration.flags & 16777216 /* Ambient */) {
+        if (constEnumDeclaration.flags & 16777216 /* Ambient */ && !isValidTypeOnlyAliasUseSite(node)) {
           error(node, Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled, isolatedModulesLikeFlagName);
         }
       }
@@ -77113,6 +77123,9 @@ ${lanes.join("\n")}
             case "length":
             case "caller":
             case "arguments":
+              if (compilerOptions.useDefineForClassFields) {
+                break;
+              }
             case "prototype":
               const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
               const className = getNameOfSymbolAsWritten(getSymbolOfDeclaration(node));
@@ -84119,7 +84132,7 @@ ${lanes.join("\n")}
                   if (requestedExternalEmitHelperNames.has(name))
                     continue;
                   requestedExternalEmitHelperNames.add(name);
-                  const symbol = getSymbol2(helpersModule.exports, escapeLeadingUnderscores(name), 111551 /* Value */);
+                  const symbol = getSymbol2(getExportsOfModule(helpersModule), escapeLeadingUnderscores(name), 111551 /* Value */);
                   if (!symbol) {
                     error(location, Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, externalHelpersModuleNameText, name);
                   } else if (helper & 524288 /* ClassPrivateFieldGet */) {
@@ -85815,6 +85828,7 @@ ${lanes.join("\n")}
         CheckMode3[CheckMode3["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
         CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
         CheckMode3[CheckMode3["RestBindingElement"] = 64] = "RestBindingElement";
+        CheckMode3[CheckMode3["TypeOnly"] = 128] = "TypeOnly";
         return CheckMode3;
       })(CheckMode || {});
       SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
@@ -121831,7 +121845,7 @@ ${lanes.join("\n")}
     let filesWithChangedSetOfUnresolvedImports;
     let filesWithInvalidatedResolutions;
     let filesWithInvalidatedNonRelativeUnresolvedImports;
-    const nonRelativeExternalModuleResolutions = /* @__PURE__ */ new Set();
+    const nonRelativeExternalModuleResolutions = createMultiMap();
     const resolutionsWithFailedLookups = /* @__PURE__ */ new Set();
     const resolutionsWithOnlyAffectingLocations = /* @__PURE__ */ new Set();
     const resolvedFileToResolution = /* @__PURE__ */ new Map();
@@ -121965,7 +121979,8 @@ ${lanes.join("\n")}
       moduleResolutionCache.clearAllExceptPackageJsonInfoCache();
       typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache();
       libraryResolutionCache.clearAllExceptPackageJsonInfoCache();
-      watchFailedLookupLocationOfNonRelativeModuleResolutions();
+      nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
+      nonRelativeExternalModuleResolutions.clear();
     }
     function cleanupLibResolutionWatching(newProgram) {
       resolvedLibraries.forEach((resolution, libFileName) => {
@@ -121983,7 +121998,8 @@ ${lanes.join("\n")}
     function finishCachingPerDirectoryResolution(newProgram, oldProgram) {
       filesWithInvalidatedNonRelativeUnresolvedImports = void 0;
       allModuleAndTypeResolutionsAreInvalidated = false;
-      watchFailedLookupLocationOfNonRelativeModuleResolutions();
+      nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions);
+      nonRelativeExternalModuleResolutions.clear();
       if (newProgram !== oldProgram) {
         cleanupLibResolutionWatching(newProgram);
         newProgram == null ? void 0 : newProgram.getSourceFiles().forEach((newFile) => {
@@ -122264,7 +122280,7 @@ ${lanes.join("\n")}
         if (!deferWatchingNonRelativeResolution || isExternalModuleNameRelative(name)) {
           watchFailedLookupLocationOfResolution(resolution);
         } else {
-          nonRelativeExternalModuleResolutions.add(resolution);
+          nonRelativeExternalModuleResolutions.add(name, resolution);
         }
         const resolved = getResolutionWithResolvedFileName(resolution);
         if (resolved && resolved.resolvedFileName) {
@@ -122394,9 +122410,17 @@ ${lanes.join("\n")}
         paths.add(affectingLocation);
       }
     }
-    function watchFailedLookupLocationOfNonRelativeModuleResolutions() {
-      nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfResolution);
-      nonRelativeExternalModuleResolutions.clear();
+    function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) {
+      const program = resolutionHost.getCurrentProgram();
+      if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) {
+        resolutions.forEach(watchFailedLookupLocationOfResolution);
+      } else {
+        resolutions.forEach((resolution) => watchAffectingLocationsOfResolution(
+          resolution,
+          /*addToResolutionsWithOnlyAffectingLocations*/
+          true
+        ));
+      }
     }
     function setDirectoryWatcher(dir, dirPath, nonRecursive) {
       const dirWatcher = directoryWatchesOfFailedLookups.get(dirPath);
@@ -134169,12 +134193,12 @@ ${lanes.join("\n")}
       refactorName = "Convert export";
       defaultToNamedAction = {
         name: "Convert default export to named export",
-        description: Diagnostics.Convert_default_export_to_named_export.message,
+        description: getLocaleSpecificMessage(Diagnostics.Convert_default_export_to_named_export),
         kind: "refactor.rewrite.export.named"
       };
       namedToDefaultAction = {
         name: "Convert named export to default export",
-        description: Diagnostics.Convert_named_export_to_default_export.message,
+        description: getLocaleSpecificMessage(Diagnostics.Convert_named_export_to_default_export),
         kind: "refactor.rewrite.export.default"
       };
       registerRefactor(refactorName, {
@@ -134192,7 +134216,7 @@ ${lanes.join("\n")}
           }
           if (context.preferences.provideRefactorNotApplicableReason) {
             return [
-              { name: refactorName, description: Diagnostics.Convert_default_export_to_named_export.message, actions: [
+              { name: refactorName, description: getLocaleSpecificMessage(Diagnostics.Convert_default_export_to_named_export), actions: [
                 { ...defaultToNamedAction, notApplicableReason: info.error },
                 { ...namedToDefaultAction, notApplicableReason: info.error }
               ] }
@@ -134394,17 +134418,17 @@ ${lanes.join("\n")}
       actions = {
         [0 /* Named */]: {
           name: "Convert namespace import to named imports",
-          description: Diagnostics.Convert_namespace_import_to_named_imports.message,
+          description: getLocaleSpecificMessage(Diagnostics.Convert_namespace_import_to_named_imports),
           kind: "refactor.rewrite.import.named"
         },
         [2 /* Namespace */]: {
           name: "Convert named imports to namespace import",
-          description: Diagnostics.Convert_named_imports_to_namespace_import.message,
+          description: getLocaleSpecificMessage(Diagnostics.Convert_named_imports_to_namespace_import),
           kind: "refactor.rewrite.import.namespace"
         },
         [1 /* Default */]: {
           name: "Convert named imports to default import",
-          description: Diagnostics.Convert_named_imports_to_default_import.message,
+          description: getLocaleSpecificMessage(Diagnostics.Convert_named_imports_to_default_import),
           kind: "refactor.rewrite.import.default"
         }
       };
@@ -134873,10 +134897,9 @@ ${lanes.join("\n")}
 
   // src/services/refactors/moveToFile.ts
   function doChange4(context, oldFile, targetFile, program, toMove, changes, host, preferences) {
-    var _a;
     const checker = program.getTypeChecker();
     const usage = getUsageInfo(oldFile, toMove.all, checker);
-    if (!host.fileExists(targetFile) || host.fileExists(targetFile) && ((_a = program.getSourceFile(targetFile)) == null ? void 0 : _a.statements.length) === 0) {
+    if (!host.fileExists(targetFile)) {
       changes.createNewFile(oldFile, targetFile, getNewStatementsAndRemoveFromOldFile2(oldFile, targetFile, usage, changes, toMove, program, host, preferences));
       addNewFileToTsconfig(program, changes, oldFile.fileName, targetFile, hostGetCanonicalFileName(host));
     } else {
@@ -134914,6 +134937,13 @@ ${lanes.join("\n")}
     if (typeof targetFile !== "string") {
       if (targetFile.statements.length > 0) {
         changes.insertNodesAfter(targetFile, targetFile.statements[targetFile.statements.length - 1], body);
+      } else {
+        changes.insertNodesAtEndOfFile(
+          targetFile,
+          body,
+          /*blankLineBetween*/
+          false
+        );
       }
       if (imports.length > 0) {
         insertImports(
@@ -135500,6 +135530,10 @@ ${lanes.join("\n")}
     if (isNamedDeclaration(startStatement) && startStatement.name && rangeContainsRange(startStatement.name, range)) {
       return { toMove: [statements[startNodeIndex]], afterLast: statements[startNodeIndex + 1] };
     }
+    const overloadRangeToMove = getOverloadRangeToMove(file, startStatement);
+    if (overloadRangeToMove) {
+      return overloadRangeToMove;
+    }
     if (range.pos > startStatement.getStart(file))
       return void 0;
     const afterEndNodeIndex = findIndex(statements, (s) => s.end > range.end, startNodeIndex);
@@ -135695,6 +135729,19 @@ ${lanes.join("\n")}
         return false;
     }
   }
+  function getOverloadRangeToMove(sourceFile, statement) {
+    if (isFunctionLikeDeclaration(statement)) {
+      const declarations = statement.symbol.declarations;
+      if (declarations === void 0 || length(declarations) <= 1 || !contains(declarations, statement)) {
+        return void 0;
+      }
+      const lastDecl = declarations[length(declarations) - 1];
+      const statementsToMove = mapDefined(declarations, (d) => getSourceFileOfNode(d) === sourceFile && isStatement(d) ? d : void 0);
+      const end = findLastIndex(sourceFile.statements, (s) => s.end > lastDecl.end);
+      return { toMove: statementsToMove, afterLast: end >= 0 ? sourceFile.statements[end] : void 0 };
+    }
+    return void 0;
+  }
   var refactorNameForMoveToFile, description2, moveToFileAction;
   var init_moveToFile = __esm({
     "src/services/refactors/moveToFile.ts"() {
@@ -135949,7 +135996,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       init_ts4();
       init_ts_refactor();
       refactorName5 = "Convert overload list to single signature";
-      refactorDescription = Diagnostics.Convert_overload_list_to_single_signature.message;
+      refactorDescription = getLocaleSpecificMessage(Diagnostics.Convert_overload_list_to_single_signature);
       functionOverloadAction = {
         name: refactorName5,
         description: refactorDescription,
@@ -136079,15 +136126,15 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       init_ts4();
       init_ts_refactor();
       refactorName6 = "Add or remove braces in an arrow function";
-      refactorDescription2 = Diagnostics.Add_or_remove_braces_in_an_arrow_function.message;
+      refactorDescription2 = getLocaleSpecificMessage(Diagnostics.Add_or_remove_braces_in_an_arrow_function);
       addBracesAction = {
         name: "Add braces to arrow function",
-        description: Diagnostics.Add_braces_to_arrow_function.message,
+        description: getLocaleSpecificMessage(Diagnostics.Add_braces_to_arrow_function),
         kind: "refactor.rewrite.arrow.braces.add"
       };
       removeBracesAction = {
         name: "Remove braces from arrow function",
-        description: Diagnostics.Remove_braces_from_arrow_function.message,
+        description: getLocaleSpecificMessage(Diagnostics.Remove_braces_from_arrow_function),
         kind: "refactor.rewrite.arrow.braces.remove"
       };
       registerRefactor(refactorName6, {
@@ -136958,7 +137005,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     }
   }
   function isNotEqualsOperator(node) {
-    return node.operatorToken.kind !== 64 /* EqualsToken */;
+    return !(node.operatorToken.kind === 64 /* EqualsToken */ || node.operatorToken.kind === 65 /* PlusEqualsToken */);
   }
   function getParentBinaryExpression(expr) {
     const container = findAncestor(expr.parent, (n) => {
@@ -138993,7 +139040,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       init_ts4();
       init_ts_refactor();
       actionName = "Generate 'get' and 'set' accessors";
-      actionDescription = Diagnostics.Generate_get_and_set_accessors.message;
+      actionDescription = getLocaleSpecificMessage(Diagnostics.Generate_get_and_set_accessors);
       generateGetSetAction = {
         name: actionName,
         description: actionDescription,
@@ -139145,7 +139192,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       init_ts4();
       init_ts_refactor();
       refactorName12 = "Infer function return type";
-      refactorDescription6 = Diagnostics.Infer_function_return_type.message;
+      refactorDescription6 = getLocaleSpecificMessage(Diagnostics.Infer_function_return_type);
       inferReturnTypeAction = {
         name: refactorName12,
         description: refactorDescription6,
@@ -139816,7 +139863,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         onUnRecoverableConfigFileDiagnostic: noop
       };
       const documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings);
+      let releasedScriptKinds = /* @__PURE__ */ new Set();
       if (isProgramUptoDate(program, rootFileNames, newSettings, (_path, fileName) => host.getScriptVersion(fileName), (fileName) => compilerHost.fileExists(fileName), hasInvalidatedResolutions, hasInvalidatedLibResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) {
+        compilerHost = void 0;
+        parsedCommandLines = void 0;
+        releasedScriptKinds = void 0;
         return;
       }
       const options = {
@@ -139829,6 +139880,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       program = createProgram(options);
       compilerHost = void 0;
       parsedCommandLines = void 0;
+      releasedScriptKinds = void 0;
       sourceMapper.clearCache();
       program.getTypeChecker();
       return;
@@ -139883,10 +139935,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         if (!shouldCreateNewSourceFile) {
           const oldSourceFile = program && program.getSourceFileByPath(path);
           if (oldSourceFile) {
-            if (scriptKind === oldSourceFile.scriptKind) {
+            if (scriptKind === oldSourceFile.scriptKind || releasedScriptKinds.has(oldSourceFile.resolvedPath)) {
               return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions);
             } else {
               documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat);
+              releasedScriptKinds.add(oldSourceFile.resolvedPath);
             }
           }
         }
@@ -149182,9 +149235,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     if (call === void 0) {
       return void 0;
     }
-    if (isPrivateIdentifier(token)) {
-      return void 0;
-    }
     const methodName = token.text;
     const addMethodDeclarationChanges = (modifierFlags2) => ts_textChanges_exports.ChangeTracker.with(context, (t) => addMethodDeclaration(context, t, call, token, modifierFlags2, parentDeclaration, declSourceFile));
     const actions2 = [createCodeFixAction(fixMissingMember, addMethodDeclarationChanges(modifierFlags & 32 /* Static */), [modifierFlags & 32 /* Static */ ? Diagnostics.Declare_static_method_0 : Diagnostics.Declare_method_0, methodName], fixMissingMember, Diagnostics.Add_all_missing_members)];
@@ -152521,6 +152571,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           type === void 0 ? factory.createKeywordTypeNode(159 /* UnknownKeyword */) : type
         );
       case 261 /* FunctionDeclaration */:
+        Debug.assert(typeof name === "string" || isIdentifier(name), "Unexpected name");
         return factory.createFunctionDeclaration(
           modifiers,
           asteriskToken,
@@ -160806,9 +160857,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (refNode.parent.kind === 303 /* ShorthandPropertyAssignment */) {
             getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addReference2);
           }
-          const containingClass = getContainingClassIfInHeritageClause(refNode);
-          if (containingClass) {
-            addReference2(containingClass);
+          const containingNode = getContainingNodeIfInHeritageClause(refNode);
+          if (containingNode) {
+            addReference2(containingNode);
             return;
           }
           const typeNode = findAncestor(refNode, (a) => !isQualifiedName(a.parent) && !isTypeNode(a.parent) && !isTypeElement(a.parent));
@@ -160835,8 +160886,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               addReference2(e);
           }
         }
-        function getContainingClassIfInHeritageClause(node) {
-          return isIdentifier(node) || isPropertyAccessExpression(node) ? getContainingClassIfInHeritageClause(node.parent) : isExpressionWithTypeArguments(node) ? tryCast(node.parent.parent, isClassLike) : void 0;
+        function getContainingNodeIfInHeritageClause(node) {
+          return isIdentifier(node) || isPropertyAccessExpression(node) ? getContainingNodeIfInHeritageClause(node.parent) : isExpressionWithTypeArguments(node) ? tryCast(node.parent.parent, or(isClassLike, isInterfaceDeclaration)) : void 0;
         }
         function isImplementationExpression(node) {
           switch (node.kind) {
@@ -162348,7 +162399,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     const tags = (parameters ? parameterDocComments(parameters || [], isJavaScriptFile, indentationStr, newLine) : "") + (hasReturn2 ? returnsDocComment(indentationStr, newLine) : "");
     const openComment = "/**";
     const closeComment = " */";
-    const hasTag = (commentOwnerJsDoc || []).some((jsDoc) => !!jsDoc.tags);
+    const hasTag = length(getJSDocTags(commentOwner)) > 0;
     if (tags && !hasTag) {
       const preamble = openComment + newLine + indentationStr + " * ";
       const endLine = tokenStart === position ? newLine + indentationStr : "";
@@ -165869,6 +165920,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             this.insertNodeAt(sourceFile, pos, insert, options);
           }
         }
+        insertNodesAtEndOfFile(sourceFile, newNodes, blankLineBetween) {
+          this.insertAtEndOfFile(sourceFile, newNodes, blankLineBetween);
+        }
+        insertAtEndOfFile(sourceFile, insert, blankLineBetween) {
+          const pos = sourceFile.end + 1;
+          const options = {
+            prefix: this.newLineCharacter,
+            suffix: this.newLineCharacter + (blankLineBetween ? this.newLineCharacter : "")
+          };
+          this.insertNodesAt(sourceFile, pos, insert, options);
+        }
         insertStatementsInNewFile(fileName, statements, oldFile) {
           if (!this.newFileChanges) {
             this.newFileChanges = createMultiMap();
@@ -167901,7 +167963,8 @@ ${options.prefix}` : "\n" : options.prefix
       }
       processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta);
     }
-    if (!formattingScanner.isOnToken()) {
+    const remainingTrivia = formattingScanner.getCurrentLeadingTrivia();
+    if (remainingTrivia) {
       const indentation = SmartIndenter.nodeWillIndentChild(
         options,
         enclosingNode,
@@ -167911,25 +167974,30 @@ ${options.prefix}` : "\n" : options.prefix
         /*indentByDefault*/
         false
       ) ? initialIndentation + options.indentSize : initialIndentation;
-      const leadingTrivia = formattingScanner.getCurrentLeadingTrivia();
-      if (leadingTrivia) {
-        indentTriviaItems(
-          leadingTrivia,
-          indentation,
-          /*indentNextTokenOrTrivia*/
-          false,
-          (item) => processRange(
+      indentTriviaItems(
+        remainingTrivia,
+        indentation,
+        /*indentNextTokenOrTrivia*/
+        true,
+        (item) => {
+          processRange(
             item,
             sourceFile.getLineAndCharacterOfPosition(item.pos),
             enclosingNode,
             enclosingNode,
             /*dynamicIndentation*/
             void 0
-          )
-        );
-        if (options.trimTrailingWhitespace !== false) {
-          trimTrailingWhitespacesForRemainingRange(leadingTrivia);
+          );
+          insertIndentation(
+            item.pos,
+            indentation,
+            /*lineAdded*/
+            false
+          );
         }
+      );
+      if (options.trimTrailingWhitespace !== false) {
+        trimTrailingWhitespacesForRemainingRange(remainingTrivia);
       }
     }
     if (previousRange && formattingScanner.getTokenFullStart() >= originalRange.end) {