autoimport completions (#1553)

Co-authored-by: Gabriela Araujo Britto <[email protected]>

Author: iisaduan

internal/ast/ast.go

@@ -994,6 +994,8 @@ func (n *Node) ModuleSpecifier() *Expression {
 		return n.AsImportDeclaration().ModuleSpecifier
 	case KindExportDeclaration:
 		return n.AsExportDeclaration().ModuleSpecifier
+	case KindJSDocImportTag:
+		return n.AsJSDocImportTag().ModuleSpecifier
 	}
 	panic("Unhandled case in Node.ModuleSpecifier: " + n.Kind.String())
 }

internal/ast/utilities.go

@@ -1409,6 +1409,16 @@ func GetNameOfDeclaration(declaration *Node) *Node {
 	return nil
 }
 
+func GetImportClauseOfDeclaration(declaration *Declaration) *ImportClause {
+	switch declaration.Kind {
+	case KindImportDeclaration:
+		return declaration.AsImportDeclaration().ImportClause.AsImportClause()
+	case KindJSDocImportTag:
+		return declaration.AsJSDocImportTag().ImportClause.AsImportClause()
+	}
+	return nil
+}
+
 func GetNonAssignedNameOfDeclaration(declaration *Node) *Node {
 	// !!!
 	switch declaration.Kind {
@@ -2723,6 +2733,15 @@ func IsRequireCall(node *Node, requireStringLiteralLikeArgument bool) bool {
 	return !requireStringLiteralLikeArgument || IsStringLiteralLike(call.Arguments.Nodes[0])
 }
 
+func IsRequireVariableStatement(node *Node) bool {
+	if IsVariableStatement(node) {
+		if declarations := node.AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes; len(declarations) > 0 {
+			return core.Every(declarations, IsVariableDeclarationInitializedToRequire)
+		}
+	}
+	return false
+}
+
 func GetJSXImplicitImportBase(compilerOptions *core.CompilerOptions, file *SourceFile) string {
 	jsxImportSourcePragma := GetPragmaFromSourceFile(file, "jsximportsource")
 	jsxRuntimePragma := GetPragmaFromSourceFile(file, "jsxruntime")

internal/checker/exports.go

@@ -26,6 +26,26 @@ func (c *Checker) GetMergedSymbol(symbol *ast.Symbol) *ast.Symbol {
 	return c.getMergedSymbol(symbol)
 }
 
+func (c *Checker) TryFindAmbientModule(moduleName string) *ast.Symbol {
+	return c.tryFindAmbientModule(moduleName, true /* withAugmentations */)
+}
+
+func (c *Checker) GetImmediateAliasedSymbol(symbol *ast.Symbol) *ast.Symbol {
+	return c.getImmediateAliasedSymbol(symbol)
+}
+
+func (c *Checker) GetTypeOnlyAliasDeclaration(symbol *ast.Symbol) *ast.Node {
+	return c.getTypeOnlyAliasDeclaration(symbol)
+}
+
+func (c *Checker) ResolveExternalModuleName(moduleSpecifier *ast.Node) *ast.Symbol {
+	return c.resolveExternalModuleName(moduleSpecifier, moduleSpecifier, true /*ignoreErrors*/)
+}
+
+func (c *Checker) ResolveExternalModuleSymbol(moduleSymbol *ast.Symbol) *ast.Symbol {
+	return c.resolveExternalModuleSymbol(moduleSymbol, false /*dontResolveAlias*/)
+}
+
 func (c *Checker) GetTypeFromTypeNode(node *ast.Node) *Type {
 	return c.getTypeFromTypeNode(node)
 }
@@ -150,7 +170,3 @@ func (c *Checker) GetIndexSignaturesAtLocation(node *ast.Node) []*ast.Node {
 func (c *Checker) GetResolvedSymbol(node *ast.Node) *ast.Symbol {
 	return c.getResolvedSymbol(node)
 }
-
-func (c *Checker) GetImmediateAliasedSymbol(symbol *ast.Symbol) *ast.Symbol {
-	return c.getImmediateAliasedSymbol(symbol)
-}

internal/checker/nodebuilderimpl.go

@@ -1076,7 +1076,7 @@ func canHaveModuleSpecifier(node *ast.Node) bool {
 	return false
 }
 
-func tryGetModuleSpecifierFromDeclaration(node *ast.Node) *ast.Node {
+func TryGetModuleSpecifierFromDeclaration(node *ast.Node) *ast.Node {
 	res := tryGetModuleSpecifierFromDeclarationWorker(node)
 	if res == nil || !ast.IsStringLiteral(res) {
 		return nil
@@ -1162,7 +1162,7 @@ func (b *nodeBuilderImpl) getSpecifierForModuleSymbol(symbol *ast.Symbol, overri
 	enclosingDeclaration := b.e.MostOriginal(b.ctx.enclosingDeclaration)
 	var originalModuleSpecifier *ast.Node
 	if canHaveModuleSpecifier(enclosingDeclaration) {
-		originalModuleSpecifier = tryGetModuleSpecifierFromDeclaration(enclosingDeclaration)
+		originalModuleSpecifier = TryGetModuleSpecifierFromDeclaration(enclosingDeclaration)
 	}
 	contextFile := b.ctx.enclosingFile
 	resolutionMode := overrideImportMode
@@ -1213,6 +1213,7 @@ func (b *nodeBuilderImpl) getSpecifierForModuleSymbol(symbol *ast.Symbol, overri
 		modulespecifiers.ModuleSpecifierOptions{
 			OverrideImportMode: overrideImportMode,
 		},
+		false, /*forAutoImports*/
 	)
 	specifier := allSpecifiers[0]
 	links.specifierCache[cacheKey] = specifier

internal/checker/services.go

@@ -118,6 +118,35 @@ func (c *Checker) GetExportsOfModule(symbol *ast.Symbol) []*ast.Symbol {
 	return symbolsToArray(c.getExportsOfModule(symbol))
 }
 
+func (c *Checker) ForEachExportAndPropertyOfModule(moduleSymbol *ast.Symbol, cb func(*ast.Symbol, string)) {
+	for key, exportedSymbol := range c.getExportsOfModule(moduleSymbol) {
+		if !isReservedMemberName(key) {
+			cb(exportedSymbol, key)
+		}
+	}
+
+	exportEquals := c.resolveExternalModuleSymbol(moduleSymbol, false /*dontResolveAlias*/)
+	if exportEquals == moduleSymbol {
+		return
+	}
+
+	typeOfSymbol := c.getTypeOfSymbol(exportEquals)
+	if !c.shouldTreatPropertiesOfExternalModuleAsExports(typeOfSymbol) {
+		return
+	}
+
+	// forEachPropertyOfType
+	reducedType := c.getReducedApparentType(typeOfSymbol)
+	if reducedType.flags&TypeFlagsStructuredType == 0 {
+		return
+	}
+	for name, symbol := range c.resolveStructuredTypeMembers(reducedType).members {
+		if c.isNamedMember(symbol, name) {
+			cb(symbol, name)
+		}
+	}
+}
+
 func (c *Checker) IsValidPropertyAccess(node *ast.Node, propertyName string) bool {
 	return c.isValidPropertyAccess(node, propertyName)
 }
@@ -345,6 +374,13 @@ func runWithoutResolvedSignatureCaching[T any](c *Checker, node *ast.Node, fn fu
 	return fn()
 }
 
+func (c *Checker) SkipAlias(symbol *ast.Symbol) *ast.Symbol {
+	if symbol.Flags&ast.SymbolFlagsAlias != 0 {
+		return c.GetAliasedSymbol(symbol)
+	}
+	return symbol
+}
+
 func (c *Checker) GetRootSymbols(symbol *ast.Symbol) []*ast.Symbol {
 	roots := c.getImmediateRootSymbols(symbol)
 	if len(roots) == 0 {

internal/compiler/program.go

@@ -155,6 +155,10 @@ func (p *Program) UseCaseSensitiveFileNames() bool {
 	return p.Host().FS().UseCaseSensitiveFileNames()
 }
 
+func (p *Program) UsesUriStyleNodeCoreModules() bool {
+	return p.usesUriStyleNodeCoreModules.IsTrue()
+}
+
 var _ checker.Program = (*Program)(nil)
 
 /** This should have similar behavior to 'processSourceFile' without diagnostics or mutation. */

internal/core/compileroptions.go

@@ -477,6 +477,17 @@ const (
 	NewLineKindLF   NewLineKind = 2
 )
 
+func GetNewLineKind(s string) NewLineKind {
+	switch s {
+	case "\r\n":
+		return NewLineKindCRLF
+	case "\n":
+		return NewLineKindLF
+	default:
+		return NewLineKindNone
+	}
+}
+
 func (newLine NewLineKind) GetNewLineCharacter() string {
 	switch newLine {
 	case NewLineKindCRLF:

internal/core/core.go

@@ -176,6 +176,17 @@ func Every[T any](slice []T, f func(T) bool) bool {
 	return true
 }
 
+func Or[T any](funcs ...func(T) bool) func(T) bool {
+	return func(input T) bool {
+		for _, f := range funcs {
+			if f(input) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
 func Find[T any](slice []T, f func(T) bool) T {
 	for _, value := range slice {
 		if f(value) {

internal/core/nodemodules.go

@@ -70,7 +70,7 @@ var ExclusivelyPrefixedNodeCoreModules = map[string]bool{
 	"node:test/reporters": true,
 }
 
-var nodeCoreModules = sync.OnceValue(func() map[string]bool {
+var NodeCoreModules = sync.OnceValue(func() map[string]bool {
 	nodeCoreModules := make(map[string]bool, len(UnprefixedNodeCoreModules)*2+len(ExclusivelyPrefixedNodeCoreModules))
 	for unprefixed := range UnprefixedNodeCoreModules {
 		nodeCoreModules[unprefixed] = true
@@ -81,7 +81,7 @@ var nodeCoreModules = sync.OnceValue(func() map[string]bool {
 })
 
 func NonRelativeModuleNameForTypingCache(moduleName string) string {
-	if nodeCoreModules()[moduleName] {
+	if NodeCoreModules()[moduleName] {
 		return "node"
 	}
 	return moduleName

internal/core/textchange.go

@@ -1,5 +1,7 @@
 package core
 
+import "strings"
+
 type TextChange struct {
 	TextRange
 	NewText string
@@ -8,3 +10,21 @@ type TextChange struct {
 func (t TextChange) ApplyTo(text string) string {
 	return text[:t.Pos()] + t.NewText + text[t.End():]
 }
+
+func ApplyBulkEdits(text string, edits []TextChange) string {
+	b := strings.Builder{}
+	b.Grow(len(text))
+	lastEnd := 0
+	for _, e := range edits {
+		start := e.TextRange.Pos()
+		if start != lastEnd {
+			b.WriteString(text[lastEnd:e.TextRange.Pos()])
+		}
+		b.WriteString(e.NewText)
+
+		lastEnd = e.TextRange.End()
+	}
+	b.WriteString(text[lastEnd:])
+
+	return b.String()
+}