Convert UMD and type-only fixes to use autoimport.Fix

- Add TypeOnlyAliasDeclaration field to autoimport.Fix
- Implement PromoteTypeOnly case in Fix.Edits()
- Move promoteFromTypeOnly and helper functions to autoimport package
- Convert UMD fixes from old ImportFix to new autoimport.Fix via converter
- Remove oldFix field from fixInfo struct - now all fixes use autoimport.Fix
- Simplify getImportCodeActions to only handle autoimport.Fix type

Co-authored-by: andrewbranch <3277153+andrewbranch@users.noreply.github.com>

Author: Copilot

internal/ls/autoimport/fix.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/astnav"
+	"github.com/microsoft/typescript-go/internal/checker"
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/compiler"
 	"github.com/microsoft/typescript-go/internal/core"
@@ -21,6 +22,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/ls/organizeimports"
 	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
 	"github.com/microsoft/typescript-go/internal/modulespecifiers"
+	"github.com/microsoft/typescript-go/internal/scanner"
 	"github.com/microsoft/typescript-go/internal/stringutil"
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
@@ -38,6 +40,9 @@ type Fix struct {
 	ModuleSpecifierKind modulespecifiers.ResultKind
 	IsReExport          bool
 	ModuleFileName      string
+
+	// For PromoteTypeOnly fixes
+	TypeOnlyAliasDeclaration *ast.Declaration
 }
 
 func (f *Fix) Edits(
@@ -105,6 +110,14 @@ func (f *Fix) Edits(
 		// 	addNamespaceQualifier(tracker, file, qualification)
 		// }
 		return tracker.GetChanges()[file.FileName()], diagnostics.Add_import_from_0.Format(f.ModuleSpecifier)
+	case lsproto.AutoImportFixKindPromoteTypeOnly:
+		promotedDeclaration := promoteFromTypeOnly(tracker, f.TypeOnlyAliasDeclaration, compilerOptions, file, preferences)
+		if promotedDeclaration.Kind == ast.KindImportSpecifier {
+			moduleSpec := getModuleSpecifierText(promotedDeclaration.Parent.Parent)
+			return tracker.GetChanges()[file.FileName()], diagnostics.Remove_type_from_import_of_0_from_1.Format(f.Name, moduleSpec)
+		}
+		moduleSpec := getModuleSpecifierText(promotedDeclaration)
+		return tracker.GetChanges()[file.FileName()], diagnostics.Remove_type_from_import_declaration_from_0.Format(moduleSpec)
 	default:
 		panic("unimplemented fix edit")
 	}
@@ -711,6 +724,186 @@ func isIndexFileName(fileName string) bool {
 	return fileName == "index"
 }
 
+func promoteFromTypeOnly(
+	changes *change.Tracker,
+	aliasDeclaration *ast.Declaration,
+	compilerOptions *core.CompilerOptions,
+	sourceFile *ast.SourceFile,
+	preferences *lsutil.UserPreferences,
+) *ast.Declaration {
+	// See comment in `doAddExistingFix` on constant with the same name.
+	convertExistingToTypeOnly := compilerOptions.VerbatimModuleSyntax
+
+	switch aliasDeclaration.Kind {
+	case ast.KindImportSpecifier:
+		spec := aliasDeclaration.AsImportSpecifier()
+		if spec.IsTypeOnly {
+			if spec.Parent != nil && spec.Parent.Kind == ast.KindNamedImports {
+				// TypeScript creates a new specifier with isTypeOnly=false, computes insertion index,
+				// and if different from current position, deletes and re-inserts at new position.
+				// For now, we just delete the range from the first token (type keyword) to the property name or name.
+				firstToken := lsutil.GetFirstToken(aliasDeclaration, sourceFile)
+				typeKeywordPos := scanner.GetTokenPosOfNode(firstToken, sourceFile, false)
+				var targetNode *ast.DeclarationName
+				if spec.PropertyName != nil {
+					targetNode = spec.PropertyName
+				} else {
+					targetNode = spec.Name()
+				}
+				targetPos := scanner.GetTokenPosOfNode(targetNode.AsNode(), sourceFile, false)
+				changes.DeleteRange(sourceFile, core.NewTextRange(typeKeywordPos, targetPos))
+			}
+			return aliasDeclaration
+		} else {
+			// The parent import clause is type-only
+			if spec.Parent == nil || spec.Parent.Kind != ast.KindNamedImports {
+				panic("ImportSpecifier parent must be NamedImports")
+			}
+			if spec.Parent.Parent == nil || spec.Parent.Parent.Kind != ast.KindImportClause {
+				panic("NamedImports parent must be ImportClause")
+			}
+			promoteImportClause(changes, spec.Parent.Parent.AsImportClause(), compilerOptions, sourceFile, preferences, convertExistingToTypeOnly, aliasDeclaration)
+			return spec.Parent.Parent
+		}
+
+	case ast.KindImportClause:
+		promoteImportClause(changes, aliasDeclaration.AsImportClause(), compilerOptions, sourceFile, preferences, convertExistingToTypeOnly, aliasDeclaration)
+		return aliasDeclaration
+
+	case ast.KindNamespaceImport:
+		// Promote the parent import clause
+		if aliasDeclaration.Parent == nil || aliasDeclaration.Parent.Kind != ast.KindImportClause {
+			panic("NamespaceImport parent must be ImportClause")
+		}
+		promoteImportClause(changes, aliasDeclaration.Parent.AsImportClause(), compilerOptions, sourceFile, preferences, convertExistingToTypeOnly, aliasDeclaration)
+		return aliasDeclaration.Parent
+
+	case ast.KindImportEqualsDeclaration:
+		// Remove the 'type' keyword (which is the second token: 'import' 'type' name '=' ...)
+		importEqDecl := aliasDeclaration.AsImportEqualsDeclaration()
+		// The type keyword is after 'import' and before the name
+		scan := scanner.GetScannerForSourceFile(sourceFile, importEqDecl.Pos())
+		// Skip 'import' keyword to get to 'type'
+		scan.Scan()
+		deleteTypeKeyword(changes, sourceFile, scan.TokenStart())
+		return aliasDeclaration
+	default:
+		panic(fmt.Sprintf("Unexpected alias declaration kind: %v", aliasDeclaration.Kind))
+	}
+}
+
+// promoteImportClause removes the type keyword from an import clause
+func promoteImportClause(
+	changes *change.Tracker,
+	importClause *ast.ImportClause,
+	compilerOptions *core.CompilerOptions,
+	sourceFile *ast.SourceFile,
+	preferences *lsutil.UserPreferences,
+	convertExistingToTypeOnly core.Tristate,
+	aliasDeclaration *ast.Declaration,
+) {
+	// Delete the 'type' keyword
+	if importClause.PhaseModifier == ast.KindTypeKeyword {
+		deleteTypeKeyword(changes, sourceFile, importClause.Pos())
+	}
+
+	// Handle .ts extension conversion to .js if necessary
+	if compilerOptions.AllowImportingTsExtensions.IsFalse() {
+		moduleSpecifier := checker.TryGetModuleSpecifierFromDeclaration(importClause.Parent)
+		if moduleSpecifier != nil {
+			// Note: We can't check ResolvedUsingTsExtension without program, so we'll skip this optimization
+			// The fix will still work, just might not change .ts to .js extensions in all cases
+		}
+	}
+
+	// Handle verbatimModuleSyntax conversion
+	// If convertExistingToTypeOnly is true, we need to add 'type' to other specifiers
+	// in the same import declaration
+	if convertExistingToTypeOnly.IsTrue() {
+		namedImports := importClause.NamedBindings
+		if namedImports != nil && namedImports.Kind == ast.KindNamedImports {
+			namedImportsData := namedImports.AsNamedImports()
+			if len(namedImportsData.Elements.Nodes) > 1 {
+				// Check if the list is sorted and if we need to reorder
+				_, isSorted := organizeimports.GetNamedImportSpecifierComparerWithDetection(
+					importClause.Parent,
+					sourceFile,
+					preferences,
+				)
+
+				// If the alias declaration is an ImportSpecifier and the list is sorted,
+				// move it to index 0 (since it will be the only non-type-only import)
+				if isSorted.IsFalse() == false && // isSorted !== false
+					aliasDeclaration != nil &&
+					aliasDeclaration.Kind == ast.KindImportSpecifier {
+					// Find the index of the alias declaration
+					aliasIndex := -1
+					for i, element := range namedImportsData.Elements.Nodes {
+						if element == aliasDeclaration {
+							aliasIndex = i
+							break
+						}
+					}
+					// If not already at index 0, move it there
+					if aliasIndex > 0 {
+						// Delete the specifier from its current position
+						changes.Delete(sourceFile, aliasDeclaration)
+						// Insert it at index 0
+						changes.InsertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0)
+					}
+				}
+
+				// Add 'type' keyword to all other import specifiers that aren't already type-only
+				for _, element := range namedImportsData.Elements.Nodes {
+					spec := element.AsImportSpecifier()
+					// Skip the specifier being promoted (if aliasDeclaration is an ImportSpecifier)
+					if aliasDeclaration != nil && aliasDeclaration.Kind == ast.KindImportSpecifier {
+						if element == aliasDeclaration {
+							continue
+						}
+					}
+					// Skip if already type-only
+					if !spec.IsTypeOnly {
+						changes.InsertModifierBefore(sourceFile, ast.KindTypeKeyword, element)
+					}
+				}
+			}
+		}
+	}
+}
+
+// deleteTypeKeyword deletes the 'type' keyword token starting at the given position,
+// including any trailing whitespace.
+func deleteTypeKeyword(changes *change.Tracker, sourceFile *ast.SourceFile, startPos int) {
+	scan := scanner.GetScannerForSourceFile(sourceFile, startPos)
+	if scan.Token() != ast.KindTypeKeyword {
+		return
+	}
+	typeStart := scan.TokenStart()
+	typeEnd := scan.TokenEnd()
+	// Skip trailing whitespace
+	text := sourceFile.Text()
+	for typeEnd < len(text) && (text[typeEnd] == ' ' || text[typeEnd] == '\t') {
+		typeEnd++
+	}
+	changes.DeleteRange(sourceFile, core.NewTextRange(typeStart, typeEnd))
+}
+
+func getModuleSpecifierText(promotedDeclaration *ast.Node) string {
+	if promotedDeclaration.Kind == ast.KindImportEqualsDeclaration {
+		importEqualsDeclaration := promotedDeclaration.AsImportEqualsDeclaration()
+		if ast.IsExternalModuleReference(importEqualsDeclaration.ModuleReference) {
+			expr := importEqualsDeclaration.ModuleReference.Expression()
+			if expr != nil && expr.Kind == ast.KindStringLiteral {
+				return expr.Text()
+			}
+
+		}
+		return importEqualsDeclaration.ModuleReference.Text()
+	}
+	return promotedDeclaration.Parent.ModuleSpecifier().Text()
+}
+
 // returns `-1` if `a` is better than `b`
 func compareModuleSpecifierRelativity(a *Fix, b *Fix, preferences modulespecifiers.UserPreferences) int {
 	switch preferences.ImportModuleSpecifierPreference {