typescript 5.4.0-dev.20231212 → 5.4.0-dev.20231214

package/lib/tsserver.js

@@ -2335,7 +2335,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231212`;
+var version = `${versionMajorMinor}.0-dev.20231214`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -10227,6 +10227,7 @@ var Diagnostics = {
   A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values: diag(2863, 1 /* Error */, "A_class_cannot_extend_a_primitive_type_like_0_Classes_can_only_extend_constructable_values_2863", "A class cannot extend a primitive type like '{0}'. Classes can only extend constructable values."),
   A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types: diag(2864, 1 /* Error */, "A_class_cannot_implement_a_primitive_type_like_0_It_can_only_implement_other_named_object_types_2864", "A class cannot implement a primitive type like '{0}'. It can only implement other named object types."),
   Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: diag(2865, 1 /* Error */, "Import_0_conflicts_with_local_value_so_must_be_declared_with_a_type_only_import_when_isolatedModules_2865", "Import '{0}' conflicts with local value, so must be declared with a type-only import when 'isolatedModules' is enabled."),
+  Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled: diag(2866, 1 /* Error */, "Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_w_2866", "Import '{0}' conflicts with global value used in this file, so must be declared with a type-only import when 'isolatedModules' is enabled."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -50060,6 +50061,7 @@ function createTypeChecker(host) {
     }
     if (nameNotFoundMessage) {
       addLazyDiagnostic(() => {
+        var _a2;
         if (errorLocation && (meaning & 2 /* BlockScopedVariable */ || (meaning & 32 /* Class */ || meaning & 384 /* Enum */) && (meaning & 111551 /* Value */) === 111551 /* Value */)) {
           const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result);
           if (exportOrLocalSymbol.flags & 2 /* BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* Class */ || exportOrLocalSymbol.flags & 384 /* Enum */) {
@@ -50093,6 +50095,16 @@ function createTypeChecker(host) {
             );
           }
         }
+        if (compilerOptions.isolatedModules && result && isInExternalModule && (meaning & 111551 /* Value */) === 111551 /* Value */) {
+          const isGlobal = lookup(globals, name, meaning) === result;
+          const nonValueSymbol = isGlobal && isSourceFile(lastLocation) && lastLocation.locals && lookup(lastLocation.locals, name, ~111551 /* Value */);
+          if (nonValueSymbol) {
+            const importDecl = (_a2 = nonValueSymbol.declarations) == null ? void 0 : _a2.find((d) => d.kind === 276 /* ImportSpecifier */ || d.kind === 273 /* ImportClause */ || d.kind === 274 /* NamespaceImport */ || d.kind === 271 /* ImportEqualsDeclaration */);
+            if (importDecl && !isTypeOnlyImportDeclaration(importDecl)) {
+              error2(importDecl, Diagnostics.Import_0_conflicts_with_global_value_used_in_this_file_so_must_be_declared_with_a_type_only_import_when_isolatedModules_is_enabled, unescapeLeadingUnderscores(name));
+            }
+          }
+        }
       });
     }
     return result;
@@ -52422,12 +52434,16 @@ function createTypeChecker(host) {
   }
   function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
     let aliasesToMakeVisible;
+    let bindingElementToMakeVisible;
     if (!every(filter(symbol.declarations, (d) => d.kind !== 80 /* Identifier */), getIsDeclarationVisible)) {
       return void 0;
     }
-    return { accessibility: 0 /* Accessible */, aliasesToMakeVisible };
+    return { accessibility: 0 /* Accessible */, aliasesToMakeVisible, bindingElementToMakeVisible };
     function getIsDeclarationVisible(declaration) {
       var _a, _b;
+      if (isBindingElement(declaration) && findAncestor(declaration, isParameter)) {
+        bindingElementToMakeVisible = declaration;
+      }
       if (!isDeclarationVisible(declaration)) {
         const anyImportSyntax = getAnyImportSyntax(declaration);
         if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 32 /* Export */) && // import clause without export
@@ -73675,7 +73691,7 @@ function createTypeChecker(host) {
       /*contextFlags*/
       void 0
     );
-    const inTupleContext = isSpreadIntoCallOrNew(node) || !!contextualType && someType(contextualType, isTupleLikeType);
+    const inTupleContext = isSpreadIntoCallOrNew(node) || !!contextualType && someType(contextualType, (t) => isTupleLikeType(t) || isGenericMappedType(t) && !t.nameType && !!getHomomorphicTypeVariable(t.target || t));
     let hasOmittedExpression = false;
     for (let i = 0; i < elementCount; i++) {
       const e = elements[i];
@@ -112850,6 +112866,7 @@ function transformDeclarations(context) {
   let lateStatementReplacementMap;
   let suppressNewDiagnosticContexts;
   let exportedModulesFromDeclarationEmit;
+  const usedBindingElementAliases = /* @__PURE__ */ new Map();
   const { factory: factory2 } = context;
   const host = context.getEmitHost();
   const symbolTracker = {
@@ -112906,7 +112923,7 @@ function transformDeclarations(context) {
   }
   function handleSymbolAccessibilityError(symbolAccessibilityResult) {
     if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
-      if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
+      if (symbolAccessibilityResult.aliasesToMakeVisible) {
         if (!lateMarkedStatements) {
           lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;
         } else {
@@ -112915,6 +112932,17 @@ function transformDeclarations(context) {
           }
         }
       }
+      if (symbolAccessibilityResult.bindingElementToMakeVisible) {
+        const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible;
+        const parameter = findAncestor(bindingElement, isParameter);
+        Debug.assert(parameter !== void 0);
+        const parent2 = getOriginalNode(parameter.parent);
+        let aliases = usedBindingElementAliases.get(parent2);
+        if (!aliases) {
+          usedBindingElementAliases.set(parent2, aliases = /* @__PURE__ */ new Map());
+        }
+        aliases.set(getOriginalNode(bindingElement), bindingElement.name);
+      }
     } else {
       const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
       if (errorInfo) {
@@ -113264,7 +113292,7 @@ function transformDeclarations(context) {
       if (elem.propertyName && isComputedPropertyName(elem.propertyName) && isEntityNameExpression(elem.propertyName.expression)) {
         checkEntityNameVisibility(elem.propertyName.expression, enclosingDeclaration);
       }
-      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !elem.symbol.isReferenced && !isIdentifierANonContextualKeyword(elem.propertyName)) {
+      if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !isIdentifierANonContextualKeyword(elem.propertyName)) {
         return factory2.updateBindingElement(
           elem,
           elem.dotDotDotToken,
@@ -113283,6 +113311,161 @@ function transformDeclarations(context) {
       );
     }
   }
+  function ensureBindingAliasesInParameterList(input, updatedNode) {
+    const original = getOriginalNode(input);
+    const params = updatedNode.parameters;
+    const aliases = usedBindingElementAliases.get(original);
+    if (!aliases) {
+      return updatedNode;
+    }
+    usedBindingElementAliases.delete(original);
+    const newParams = map(params, addUsedBindingPatternsToParameter);
+    const newParamsNodeArray = factory2.createNodeArray(newParams, params.hasTrailingComma);
+    switch (updatedNode.kind) {
+      case 174 /* MethodDeclaration */:
+        return factory2.updateMethodDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.asteriskToken,
+          updatedNode.name,
+          updatedNode.questionToken,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.body
+        );
+      case 176 /* Constructor */:
+        return factory2.updateConstructorDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          newParamsNodeArray,
+          updatedNode.body
+        );
+      case 177 /* GetAccessor */:
+        return factory2.updateGetAccessorDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.name,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.body
+        );
+      case 178 /* SetAccessor */:
+        return factory2.updateSetAccessorDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.name,
+          newParamsNodeArray,
+          updatedNode.body
+        );
+      case 219 /* ArrowFunction */:
+        return factory2.updateArrowFunction(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.equalsGreaterThanToken,
+          updatedNode.body
+        );
+      case 262 /* FunctionDeclaration */:
+        return factory2.updateFunctionDeclaration(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.asteriskToken,
+          updatedNode.name,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type,
+          updatedNode.body
+        );
+      case 179 /* CallSignature */:
+        return factory2.updateCallSignature(
+          updatedNode,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 173 /* MethodSignature */:
+        return factory2.updateMethodSignature(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.name,
+          updatedNode.questionToken,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 180 /* ConstructSignature */:
+        return factory2.updateConstructSignature(
+          updatedNode,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 184 /* FunctionType */:
+        return factory2.updateFunctionTypeNode(
+          updatedNode,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      case 185 /* ConstructorType */:
+        return factory2.updateConstructorTypeNode(
+          updatedNode,
+          updatedNode.modifiers,
+          updatedNode.typeParameters,
+          newParamsNodeArray,
+          updatedNode.type
+        );
+      default:
+        Debug.assertNever(updatedNode);
+    }
+    function addUsedBindingPatternsToParameter(p) {
+      return factory2.updateParameterDeclaration(
+        p,
+        p.modifiers,
+        p.dotDotDotToken,
+        addUsedBindingPatternAliases(p.name),
+        p.questionToken,
+        p.type,
+        p.initializer
+      );
+    }
+    function addUsedBindingPatternAliases(name) {
+      if (name.kind === 80 /* Identifier */) {
+        return name;
+      } else {
+        if (name.kind === 207 /* ArrayBindingPattern */) {
+          return factory2.updateArrayBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isArrayBindingElement));
+        } else {
+          return factory2.updateObjectBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isBindingElement));
+        }
+      }
+      function visitBindingElement(elem) {
+        if (elem.kind === 232 /* OmittedExpression */) {
+          return elem;
+        }
+        const usedAlias = aliases.get(getOriginalNode(elem));
+        if (usedAlias && !elem.propertyName) {
+          return factory2.updateBindingElement(
+            elem,
+            elem.dotDotDotToken,
+            elem.name,
+            usedAlias,
+            elem.initializer
+          );
+        }
+        return factory2.updateBindingElement(
+          elem,
+          elem.dotDotDotToken,
+          elem.propertyName,
+          addUsedBindingPatternAliases(elem.name),
+          elem.initializer
+        );
+      }
+    }
+  }
   function ensureParameter(p, modifierMask, type) {
     let oldDiag;
     if (!suppressNewDiagnosticContexts) {
@@ -113669,19 +113852,25 @@ function transformDeclarations(context) {
           return cleanup(factory2.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
         }
         case 180 /* ConstructSignature */:
-          return cleanup(factory2.updateConstructSignature(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            factory2.updateConstructSignature(
+              input,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
+            )
           ));
         case 176 /* Constructor */: {
-          const ctor = factory2.createConstructorDeclaration(
-            /*modifiers*/
-            ensureModifiers(input),
-            updateParamsList(input, input.parameters, 0 /* None */),
-            /*body*/
-            void 0
+          const ctor = ensureBindingAliasesInParameterList(
+            input,
+            factory2.createConstructorDeclaration(
+              /*modifiers*/
+              ensureModifiers(input),
+              updateParamsList(input, input.parameters, 0 /* None */),
+              /*body*/
+              void 0
+            )
           );
           return cleanup(ctor);
         }
@@ -113692,17 +113881,20 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          const sig = factory2.createMethodDeclaration(
-            ensureModifiers(input),
-            /*asteriskToken*/
-            void 0,
-            input.name,
-            input.questionToken,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type),
-            /*body*/
-            void 0
+          const sig = ensureBindingAliasesInParameterList(
+            input,
+            factory2.createMethodDeclaration(
+              ensureModifiers(input),
+              /*asteriskToken*/
+              void 0,
+              input.name,
+              input.questionToken,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type),
+              /*body*/
+              void 0
+            )
           );
           return cleanup(sig);
         }
@@ -113714,14 +113906,17 @@ function transformDeclarations(context) {
             );
           }
           const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
-          return cleanup(factory2.updateGetAccessorDeclaration(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureModifiers(input),
-            input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-            ensureType(input, accessorType),
-            /*body*/
-            void 0
+            factory2.updateGetAccessorDeclaration(
+              input,
+              ensureModifiers(input),
+              input.name,
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+              ensureType(input, accessorType),
+              /*body*/
+              void 0
+            )
           ));
         }
         case 178 /* SetAccessor */: {
@@ -113731,13 +113926,16 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          return cleanup(factory2.updateSetAccessorDeclaration(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureModifiers(input),
-            input.name,
-            updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-            /*body*/
-            void 0
+            factory2.updateSetAccessorDeclaration(
+              input,
+              ensureModifiers(input),
+              input.name,
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+              /*body*/
+              void 0
+            )
           ));
         }
         case 172 /* PropertyDeclaration */:
@@ -113776,22 +113974,28 @@ function transformDeclarations(context) {
               void 0
             );
           }
-          return cleanup(factory2.updateMethodSignature(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureModifiers(input),
-            input.name,
-            input.questionToken,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            factory2.updateMethodSignature(
+              input,
+              ensureModifiers(input),
+              input.name,
+              input.questionToken,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
+            )
           ));
         }
         case 179 /* CallSignature */: {
-          return cleanup(factory2.updateCallSignature(
+          return cleanup(ensureBindingAliasesInParameterList(
             input,
-            ensureTypeParams(input, input.typeParameters),
-            updateParamsList(input, input.parameters),
-            ensureType(input, input.type)
+            factory2.updateCallSignature(
+              input,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
+            )
           ));
         }
         case 181 /* IndexSignature */: {
@@ -113846,10 +114050,27 @@ function transformDeclarations(context) {
           return cleanup(factory2.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
         }
         case 184 /* FunctionType */: {
-          return cleanup(factory2.updateFunctionTypeNode(input, visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), updateParamsList(input, input.parameters), Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))));
+          return cleanup(ensureBindingAliasesInParameterList(
+            input,
+            factory2.updateFunctionTypeNode(
+              input,
+              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+              updateParamsList(input, input.parameters),
+              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
+            )
+          ));
         }
         case 185 /* ConstructorType */: {
-          return cleanup(factory2.updateConstructorTypeNode(input, ensureModifiers(input), visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration), updateParamsList(input, input.parameters), Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))));
+          return cleanup(ensureBindingAliasesInParameterList(
+            input,
+            factory2.updateConstructorTypeNode(
+              input,
+              ensureModifiers(input),
+              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+              updateParamsList(input, input.parameters),
+              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
+            )
+          ));
         }
         case 205 /* ImportType */: {
           if (!isLiteralImportTypeNode(input))
@@ -114034,17 +114255,20 @@ function transformDeclarations(context) {
         ));
       }
       case 262 /* FunctionDeclaration */: {
-        const clean2 = cleanup(factory2.updateFunctionDeclaration(
+        const clean2 = cleanup(ensureBindingAliasesInParameterList(
           input,
-          ensureModifiers(input),
-          /*asteriskToken*/
-          void 0,
-          input.name,
-          ensureTypeParams(input, input.typeParameters),
-          updateParamsList(input, input.parameters),
-          ensureType(input, input.type),
-          /*body*/
-          void 0
+          factory2.updateFunctionDeclaration(
+            input,
+            ensureModifiers(input),
+            /*asteriskToken*/
+            void 0,
+            input.name,
+            ensureTypeParams(input, input.typeParameters),
+            updateParamsList(input, input.parameters),
+            ensureType(input, input.type),
+            /*body*/
+            void 0
+          )
         ));
         if (clean2 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
           const props = resolver.getPropertiesOfContainerFunction(input);
@@ -140109,7 +140333,7 @@ function doChange4(context, oldFile, targetFile, program, toMove, changes, host,
   } else {
     const targetSourceFile = Debug.checkDefined(program.getSourceFile(targetFile));
     const importAdder = ts_codefix_exports.createImportAdder(targetSourceFile, context.program, context.preferences, context.host);
-    getNewStatementsAndRemoveFromOldFile2(oldFile, targetSourceFile, getUsageInfo(oldFile, toMove.all, checker, getExistingImports(targetSourceFile, checker)), changes, toMove, program, host, preferences, importAdder);
+    getNewStatementsAndRemoveFromOldFile2(oldFile, targetSourceFile, getUsageInfo(oldFile, toMove.all, checker, getExistingLocals(targetSourceFile, toMove.all, checker)), changes, toMove, program, host, preferences, importAdder);
   }
 }
 function getNewStatementsAndRemoveFromOldFile2(oldFile, targetFile, usage, changes, toMove, program, host, preferences, importAdder) {
@@ -140775,7 +140999,7 @@ function isPureImport(node) {
       return false;
   }
 }
-function getUsageInfo(oldFile, toMove, checker, existingTargetImports = /* @__PURE__ */ new Set()) {
+function getUsageInfo(oldFile, toMove, checker, existingTargetLocals = /* @__PURE__ */ new Set()) {
   const movedSymbols = /* @__PURE__ */ new Set();
   const oldImportsNeededByTargetFile = /* @__PURE__ */ new Map();
   const targetFileImportsFromOldFile = /* @__PURE__ */ new Set();
@@ -140795,7 +141019,7 @@ function getUsageInfo(oldFile, toMove, checker, existingTargetImports = /* @__PU
       if (!symbol.declarations) {
         return;
       }
-      if (existingTargetImports.has(skipAlias(symbol, checker))) {
+      if (existingTargetLocals.has(skipAlias(symbol, checker))) {
         unusedImportsFromOldFile.add(symbol);
         return;
       }
@@ -140997,15 +141221,15 @@ function getOverloadRangeToMove(sourceFile, statement) {
   }
   return void 0;
 }
-function getExistingImports(sourceFile, checker) {
-  const imports = /* @__PURE__ */ new Set();
+function getExistingLocals(sourceFile, statements, checker) {
+  const existingLocals = /* @__PURE__ */ new Set();
   for (const moduleSpecifier of sourceFile.imports) {
     const declaration = importFromModuleSpecifier(moduleSpecifier);
     if (isImportDeclaration(declaration) && declaration.importClause && declaration.importClause.namedBindings && isNamedImports(declaration.importClause.namedBindings)) {
       for (const e of declaration.importClause.namedBindings.elements) {
         const symbol = checker.getSymbolAtLocation(e.propertyName || e.name);
         if (symbol) {
-          imports.add(skipAlias(symbol, checker));
+          existingLocals.add(skipAlias(symbol, checker));
         }
       }
     }
@@ -141013,12 +141237,20 @@ function getExistingImports(sourceFile, checker) {
       for (const e of declaration.parent.name.elements) {
         const symbol = checker.getSymbolAtLocation(e.propertyName || e.name);
         if (symbol) {
-          imports.add(skipAlias(symbol, checker));
+          existingLocals.add(skipAlias(symbol, checker));
         }
       }
     }
   }
-  return imports;
+  for (const statement of statements) {
+    forEachReference(statement, checker, (s) => {
+      const symbol = skipAlias(s, checker);
+      if (symbol.valueDeclaration && getSourceFileOfNode(symbol.valueDeclaration) === sourceFile) {
+        existingLocals.add(symbol);
+      }
+    });
+  }
+  return existingLocals;
 }
 
 // src/services/_namespaces/ts.refactor.addOrRemoveBracesToArrowFunction.ts
@@ -166401,15 +166633,17 @@ function getJsDocTagsFromDeclarations(declarations, checker) {
     }
     for (const tag of tags) {
       infos.push({ name: tag.tagName.text, text: getCommentDisplayParts(tag, checker) });
-      if (isJSDocPropertyLikeTag(tag) && tag.isNameFirst && tag.typeExpression && isJSDocTypeLiteral(tag.typeExpression.type)) {
-        forEach(tag.typeExpression.type.jsDocPropertyTags, (propTag) => {
-          infos.push({ name: propTag.tagName.text, text: getCommentDisplayParts(propTag, checker) });
-        });
-      }
+      infos.push(...getJSDocPropertyTagsInfo(tryGetJSDocPropertyTags(tag), checker));
     }
   });
   return infos;
 }
+function getJSDocPropertyTagsInfo(nodes, checker) {
+  return flatMap(nodes, (propTag) => concatenate([{ name: propTag.tagName.text, text: getCommentDisplayParts(propTag, checker) }], getJSDocPropertyTagsInfo(tryGetJSDocPropertyTags(propTag), checker)));
+}
+function tryGetJSDocPropertyTags(node) {
+  return isJSDocPropertyLikeTag(node) && node.isNameFirst && node.typeExpression && isJSDocTypeLiteral(node.typeExpression.type) ? node.typeExpression.type.jsDocPropertyTags : void 0;
+}
 function getDisplayPartsFromComment(comment, checker) {
   if (typeof comment === "string") {
     return [textPart(comment)];