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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231212`;
+      version = `${versionMajorMinor}.0-dev.20231214`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -8002,6 +8002,7 @@ ${lanes.join("\n")}
         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}'."),
@@ -47820,6 +47821,7 @@ ${lanes.join("\n")}
       }
       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 */) {
@@ -47853,6 +47855,16 @@ ${lanes.join("\n")}
               );
             }
           }
+          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;
@@ -50182,12 +50194,16 @@ ${lanes.join("\n")}
     }
     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
@@ -71435,7 +71451,7 @@ ${lanes.join("\n")}
         /*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];
@@ -110919,6 +110935,7 @@ ${lanes.join("\n")}
     let lateStatementReplacementMap;
     let suppressNewDiagnosticContexts;
     let exportedModulesFromDeclarationEmit;
+    const usedBindingElementAliases = /* @__PURE__ */ new Map();
     const { factory: factory2 } = context;
     const host = context.getEmitHost();
     const symbolTracker = {
@@ -110975,7 +110992,7 @@ ${lanes.join("\n")}
     }
     function handleSymbolAccessibilityError(symbolAccessibilityResult) {
       if (symbolAccessibilityResult.accessibility === 0 /* Accessible */) {
-        if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) {
+        if (symbolAccessibilityResult.aliasesToMakeVisible) {
           if (!lateMarkedStatements) {
             lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible;
           } else {
@@ -110984,6 +111001,17 @@ ${lanes.join("\n")}
             }
           }
         }
+        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) {
@@ -111333,7 +111361,7 @@ ${lanes.join("\n")}
         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,
@@ -111352,6 +111380,161 @@ ${lanes.join("\n")}
         );
       }
     }
+    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) {
@@ -111738,19 +111921,25 @@ ${lanes.join("\n")}
             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);
           }
@@ -111761,17 +111950,20 @@ ${lanes.join("\n")}
                 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);
           }
@@ -111783,14 +111975,17 @@ ${lanes.join("\n")}
               );
             }
             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 */: {
@@ -111800,13 +111995,16 @@ ${lanes.join("\n")}
                 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 */:
@@ -111845,22 +112043,28 @@ ${lanes.join("\n")}
                 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 */: {
@@ -111915,10 +112119,27 @@ ${lanes.join("\n")}
             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))
@@ -112103,17 +112324,20 @@ ${lanes.join("\n")}
           ));
         }
         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);
@@ -138481,7 +138705,7 @@ ${lanes.join("\n")}
     } 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) {
@@ -139147,7 +139371,7 @@ ${lanes.join("\n")}
         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();
@@ -139167,7 +139391,7 @@ ${lanes.join("\n")}
         if (!symbol.declarations) {
           return;
         }
-        if (existingTargetImports.has(skipAlias(symbol, checker))) {
+        if (existingTargetLocals.has(skipAlias(symbol, checker))) {
           unusedImportsFromOldFile.add(symbol);
           return;
         }
@@ -139369,15 +139593,15 @@ ${lanes.join("\n")}
     }
     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));
           }
         }
       }
@@ -139385,12 +139609,20 @@ ${lanes.join("\n")}
         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;
   }
   var refactorNameForMoveToFile, description2, moveToFileAction;
   var init_moveToFile = __esm({
@@ -165661,15 +165893,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       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)];

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231212`;
+var version = `${versionMajorMinor}.0-dev.20231214`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6049,6 +6049,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}'."),

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.4.0-dev.20231212",
+    "version": "5.4.0-dev.20231214",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -113,5 +113,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "efc9c065a2caa52c5bebd08d730eed508075a78a"
+    "gitHead": "2c7162143bbbf567ccecc64105010699fa7a2128"
 }