Organize Imports

internal/checker/exports.go

@@ -175,6 +175,14 @@ func (c *Checker) GetJsxNamespace(location *ast.Node) string {
 	return c.getJsxNamespace(location)
 }
 
+func (c *Checker) GetJsxFragmentFactory(location *ast.Node) string {
+	entity := c.getJsxFragmentFactoryEntity(location)
+	if entity != nil {
+		return ast.GetFirstIdentifier(entity).Text()
+	}
+	return ""
+}
+
 func (c *Checker) ResolveName(name string, location *ast.Node, meaning ast.SymbolFlags, excludeGlobals bool) *ast.Symbol {
 	return c.resolveName(location, name, meaning, nil, true, excludeGlobals)
 }

internal/checker/printer.go

@@ -182,7 +182,7 @@ func (c *Checker) TypeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags
 }
 
 func (c *Checker) typeToStringEx(t *Type, enclosingDeclaration *ast.Node, flags TypeFormatFlags) string {
-	writer := printer.NewTextWriter("")
+	writer := printer.NewTextWriter("", 0)
 	noTruncation := (c.compilerOptions.NoErrorTruncation == core.TSTrue) || (flags&TypeFormatFlagsNoTruncation != 0)
 	combinedFlags := toNodeBuilderFlags(flags) | nodebuilder.FlagsIgnoreErrors
 	if noTruncation {

internal/checker/services.go

@@ -3,11 +3,15 @@ package checker
 import (
 	"maps"
 	"slices"
+	"strings"
 
 	"github.com/microsoft/typescript-go/internal/ast"
+	"github.com/microsoft/typescript-go/internal/astnav"
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/debug"
 	"github.com/microsoft/typescript-go/internal/printer"
+	"github.com/microsoft/typescript-go/internal/scanner"
 )
 
 func (c *Checker) GetSymbolsInScope(location *ast.Node, meaning ast.SymbolFlags) []*ast.Symbol {
@@ -499,6 +503,146 @@ func (c *Checker) GetSymbolsOfParameterPropertyDeclaration(parameter *ast.Node /
 	panic("There should exist two symbols, one as property declaration and one as parameter declaration")
 }
 
+// IsDeclarationUsed checks if an import declaration identifier is used in the source file.
+// This is primarily used for organizing imports to determine which imports can be removed.
+func (c *Checker) IsDeclarationUsed(
+	sourceFile *ast.SourceFile,
+	identifier *ast.Identifier,
+	jsxElementsPresent bool,
+	jsxModeNeedsExplicitImport bool,
+) bool {
+	if jsxElementsPresent && jsxModeNeedsExplicitImport {
+		jsxNamespace := c.getJsxNamespace(sourceFile.AsNode())
+		jsxFragmentFactory := c.GetJsxFragmentFactory(sourceFile.AsNode())
+		identifierText := identifier.Text
+		if identifierText == jsxNamespace {
+			return true
+		}
+		if jsxFragmentFactory != "" && identifierText == jsxFragmentFactory {
+			return true
+		}
+	}
+
+	symbol := c.GetSymbolAtLocation(identifier.AsNode())
+	if symbol == nil {
+		return true
+	}
+
+	return c.IsSymbolReferencedInFile(sourceFile, identifier, symbol)
+}
+
+// IsSymbolReferencedInFile checks if a symbol is referenced in the source file (besides its definition).
+// This is used as a quick check for whether a symbol is used at all in a file.
+func (c *Checker) IsSymbolReferencedInFile(
+	sourceFile *ast.SourceFile,
+	definition *ast.Identifier,
+	symbol *ast.Symbol,
+) bool {
+	identifierText := definition.Text
+	for _, token := range getPossibleSymbolReferenceNodes(sourceFile, identifierText, sourceFile.AsNode()) {
+		if !ast.IsIdentifier(token) {
+			continue
+		}
+		id := token.AsIdentifier()
+		if id == definition || id.Text != identifierText {
+			continue
+		}
+		refSymbol := c.GetSymbolAtLocation(token)
+		if refSymbol == symbol {
+			return true
+		}
+		if token.Parent != nil && token.Parent.Kind == ast.KindShorthandPropertyAssignment {
+			shorthandSymbol := c.GetShorthandAssignmentValueSymbol(token.Parent)
+			if shorthandSymbol == symbol {
+				return true
+			}
+		}
+		if token.Parent != nil && ast.IsExportSpecifier(token.Parent) {
+			localSymbol := c.getLocalSymbolForExportSpecifier(token.AsIdentifier(), refSymbol, token.Parent.AsExportSpecifier())
+			if localSymbol == symbol {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (c *Checker) getLocalSymbolForExportSpecifier(referenceLocation *ast.Identifier, referenceSymbol *ast.Symbol, exportSpecifier *ast.ExportSpecifier) *ast.Symbol {
+	if isExportSpecifierAlias(referenceLocation, exportSpecifier) {
+		if symbol := c.GetExportSpecifierLocalTargetSymbol(exportSpecifier.AsNode()); symbol != nil {
+			return symbol
+		}
+	}
+	return referenceSymbol
+}
+
+func isExportSpecifierAlias(referenceLocation *ast.Identifier, exportSpecifier *ast.ExportSpecifier) bool {
+	debug.Assert(exportSpecifier.PropertyName == referenceLocation.AsNode() || exportSpecifier.Name() == referenceLocation.AsNode(), "referenceLocation is not export specifier name or property name")
+	propertyName := exportSpecifier.PropertyName
+	if propertyName != nil {
+		// Given `export { foo as bar } [from "someModule"]`: It's an alias at `foo`, but at `bar` it's a new symbol.
+		return propertyName == referenceLocation.AsNode()
+	} else {
+		// `export { foo } from "foo"` is a re-export.
+		// `export { foo };` is not a re-export, it creates an alias for the local variable `foo`.
+		return exportSpecifier.Parent.Parent.ModuleSpecifier() == nil
+	}
+}
+
+func getPossibleSymbolReferenceNodes(sourceFile *ast.SourceFile, symbolName string, container *ast.Node) []*ast.Node {
+	return core.MapNonNil(getPossibleSymbolReferencePositions(sourceFile, symbolName, container), func(pos int) *ast.Node {
+		if referenceLocation := astnav.GetTouchingPropertyName(sourceFile, pos); referenceLocation != sourceFile.AsNode() {
+			return referenceLocation
+		}
+		return nil
+	})
+}
+
+func getPossibleSymbolReferencePositions(sourceFile *ast.SourceFile, symbolName string, container *ast.Node) []int {
+	positions := []int{}
+
+	// TODO: Cache symbol existence for files to save text search
+	// Also, need to make this work for unicode escapes.
+
+	// Be resilient in the face of a symbol with no name or zero length name
+	if symbolName == "" {
+		return positions
+	}
+
+	text := sourceFile.Text()
+	sourceLength := len(text)
+	symbolNameLength := len(symbolName)
+
+	if container == nil {
+		container = sourceFile.AsNode()
+	}
+
+	position := strings.Index(text[container.Pos():], symbolName)
+	endPos := container.End()
+	for position >= 0 && position < endPos {
+		// We found a match.  Make sure it's not part of a larger word (i.e. the char
+		// before and after it have to be a non-identifier char).
+		endPosition := position + symbolNameLength
+
+		if (position == 0 || !scanner.IsIdentifierPart(rune(text[position-1]))) &&
+			(endPosition == sourceLength || !scanner.IsIdentifierPart(rune(text[endPosition]))) {
+			// Found a real match.  Keep searching.
+			positions = append(positions, position)
+		}
+		startIndex := position + symbolNameLength + 1
+		if startIndex > len(text) {
+			break
+		}
+		if foundIndex := strings.Index(text[startIndex:], symbolName); foundIndex != -1 {
+			position = startIndex + foundIndex
+		} else {
+			break
+		}
+	}
+
+	return positions
+}
+
 func (c *Checker) GetTypeArgumentConstraint(node *ast.Node) *Type {
 	if !ast.IsTypeNode(node) {
 		return nil

internal/compiler/program.go

@@ -1409,7 +1409,7 @@ func (p *Program) Emit(ctx context.Context, options EmitOptions) *EmitResult {
 	newLine := p.Options().NewLine.GetNewLineCharacter()
 	writerPool := &sync.Pool{
 		New: func() any {
-			return printer.NewTextWriter(newLine)
+			return printer.NewTextWriter(newLine, 0)
 		},
 	}
 	wg := core.NewWorkGroup(p.SingleThreaded())