New auto-import infrastructure

cmd/tsgo/lsp.go

@@ -64,6 +64,7 @@ func runLSP(args []string) int {
 	defer stop()
 
 	if err := s.Run(ctx); err != nil {
+		fmt.Fprintln(os.Stderr, err)
 		return 1
 	}
 	return 0

internal/api/api.go

@@ -161,7 +161,7 @@ func (api *API) GetSymbolAtPosition(ctx context.Context, projectId Handle[projec
 		return nil, errors.New("project not found")
 	}
 
-	languageService := ls.NewLanguageService(project.GetProgram(), snapshot)
+	languageService := ls.NewLanguageService(project.ConfigFilePath(), project.GetProgram(), snapshot)
 	symbol, err := languageService.GetSymbolAtPosition(ctx, fileName, position)
 	if err != nil || symbol == nil {
 		return nil, err
@@ -203,7 +203,7 @@ func (api *API) GetSymbolAtLocation(ctx context.Context, projectId Handle[projec
 	if node == nil {
 		return nil, fmt.Errorf("node of kind %s not found at position %d in file %q", kind.String(), pos, sourceFile.FileName())
 	}
-	languageService := ls.NewLanguageService(project.GetProgram(), snapshot)
+	languageService := ls.NewLanguageService(project.ConfigFilePath(), project.GetProgram(), snapshot)
 	symbol := languageService.GetSymbolAtLocation(ctx, node)
 	if symbol == nil {
 		return nil, nil
@@ -233,7 +233,7 @@ func (api *API) GetTypeOfSymbol(ctx context.Context, projectId Handle[project.Pr
 	if !ok {
 		return nil, fmt.Errorf("symbol %q not found", symbolHandle)
 	}
-	languageService := ls.NewLanguageService(project.GetProgram(), snapshot)
+	languageService := ls.NewLanguageService(project.ConfigFilePath(), project.GetProgram(), snapshot)
 	t := languageService.GetTypeOfSymbol(ctx, symbol)
 	if t == nil {
 		return nil, nil

internal/ast/symbol.go

@@ -35,6 +35,14 @@ func (s *Symbol) IsStatic() bool {
 	return modifierFlags&ModifierFlagsStatic != 0
 }
 
+// See comment on `declareModuleMember` in `binder.go`.
+func (s *Symbol) CombinedLocalAndExportSymbolFlags() SymbolFlags {
+	if s.ExportSymbol != nil {
+		return s.Flags | s.ExportSymbol.Flags
+	}
+	return s.Flags
+}
+
 // SymbolTable
 
 type SymbolTable map[string]*Symbol

internal/ast/utilities.go

@@ -1870,11 +1870,11 @@ func IsExpressionNode(node *Node) bool {
 		for node.Parent.Kind == KindQualifiedName {
 			node = node.Parent
 		}
-		return IsTypeQueryNode(node.Parent) || IsJSDocLinkLike(node.Parent) || IsJSDocNameReference(node.Parent) || isJSXTagName(node)
+		return IsTypeQueryNode(node.Parent) || IsJSDocLinkLike(node.Parent) || IsJSDocNameReference(node.Parent) || IsJsxTagName(node)
 	case KindPrivateIdentifier:
 		return IsBinaryExpression(node.Parent) && node.Parent.AsBinaryExpression().Left == node && node.Parent.AsBinaryExpression().OperatorToken.Kind == KindInKeyword
 	case KindIdentifier:
-		if IsTypeQueryNode(node.Parent) || IsJSDocLinkLike(node.Parent) || IsJSDocNameReference(node.Parent) || isJSXTagName(node) {
+		if IsTypeQueryNode(node.Parent) || IsJSDocLinkLike(node.Parent) || IsJSDocNameReference(node.Parent) || IsJsxTagName(node) {
 			return true
 		}
 		fallthrough
@@ -1991,15 +1991,6 @@ func IsJSDocTag(node *Node) bool {
 	return node.Kind >= KindFirstJSDocTagNode && node.Kind <= KindLastJSDocTagNode
 }
 
-func isJSXTagName(node *Node) bool {
-	parent := node.Parent
-	switch parent.Kind {
-	case KindJsxOpeningElement, KindJsxSelfClosingElement, KindJsxClosingElement:
-		return parent.TagName() == node
-	}
-	return false
-}
-
 func IsSuperCall(node *Node) bool {
 	return IsCallExpression(node) && node.Expression().Kind == KindSuperKeyword
 }
@@ -3407,12 +3398,12 @@ func IsExternalModuleAugmentation(node *Node) bool {
 func GetSourceFileOfModule(module *Symbol) *SourceFile {
 	declaration := module.ValueDeclaration
 	if declaration == nil {
-		declaration = getNonAugmentationDeclaration(module)
+		declaration = GetNonAugmentationDeclaration(module)
 	}
 	return GetSourceFileOfNode(declaration)
 }
 
-func getNonAugmentationDeclaration(symbol *Symbol) *Node {
+func GetNonAugmentationDeclaration(symbol *Symbol) *Node {
 	return core.Find(symbol.Declarations, func(d *Node) bool {
 		return !IsExternalModuleAugmentation(d) && !IsGlobalScopeAugmentation(d)
 	})
@@ -3888,6 +3879,37 @@ func GetContainingFunction(node *Node) *Node {
 	return FindAncestor(node.Parent, IsFunctionLike)
 }
 
+func ImportFromModuleSpecifier(node *Node) *Node {
+	if result := TryGetImportFromModuleSpecifier(node); result != nil {
+		return result
+	}
+	debug.FailBadSyntaxKind(node.Parent)
+	return nil
+}
+
+func TryGetImportFromModuleSpecifier(node *StringLiteralLike) *Node {
+	switch node.Parent.Kind {
+	case KindImportDeclaration, KindJSImportDeclaration, KindExportDeclaration:
+		return node.Parent
+	case KindExternalModuleReference:
+		return node.Parent.Parent
+	case KindCallExpression:
+		if IsImportCall(node.Parent) || IsRequireCall(node.Parent, false /*requireStringLiteralLikeArgument*/) {
+			return node.Parent
+		}
+		return nil
+	case KindLiteralType:
+		if !IsStringLiteral(node) {
+			return nil
+		}
+		if IsImportTypeNode(node.Parent.Parent) {
+			return node.Parent.Parent
+		}
+		return nil
+	}
+	return nil
+}
+
 func IsImplicitlyExportedJSTypeAlias(node *Node) bool {
 	return IsJSTypeAliasDeclaration(node) && IsSourceFile(node.Parent) && IsExternalOrCommonJSModule(node.Parent.AsSourceFile())
 }

internal/checker/checker.go

@@ -14430,6 +14430,9 @@ func (c *Checker) getEmitSyntaxForModuleSpecifierExpression(usage *ast.Node) cor
 }
 
 func (c *Checker) errorNoModuleMemberSymbol(moduleSymbol *ast.Symbol, targetSymbol *ast.Symbol, node *ast.Node, name *ast.Node) {
+	if c.compilerOptions.NoCheck.IsTrue() {
+		return
+	}
 	moduleName := c.getFullyQualifiedName(moduleSymbol, node)
 	declarationName := scanner.DeclarationNameToString(name)
 	var suggestion *ast.Symbol
@@ -14641,6 +14644,7 @@ func (c *Checker) markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration *ast.N
 
 func (c *Checker) resolveExternalModuleName(location *ast.Node, moduleReferenceExpression *ast.Node, ignoreErrors bool) *ast.Symbol {
 	errorMessage := diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations
+	ignoreErrors = ignoreErrors || c.compilerOptions.NoCheck.IsTrue()
 	return c.resolveExternalModuleNameWorker(location, moduleReferenceExpression, core.IfElse(ignoreErrors, nil, errorMessage), ignoreErrors, false /*isForAugmentation*/)
 }
 

internal/checker/services.go

@@ -26,7 +26,7 @@ func (c *Checker) getSymbolsInScope(location *ast.Node, meaning ast.SymbolFlags)
 	// Copy the given symbol into symbol tables if the symbol has the given meaning
 	// and it doesn't already exists in the symbol table.
 	copySymbol := func(symbol *ast.Symbol, meaning ast.SymbolFlags) {
-		if GetCombinedLocalAndExportSymbolFlags(symbol)&meaning != 0 {
+		if symbol.CombinedLocalAndExportSymbolFlags()&meaning != 0 {
 			id := symbol.Name
 			// We will copy all symbol regardless of its reserved name because
 			// symbolsToArray will check whether the key is a reserved name and
@@ -393,6 +393,13 @@ func (c *Checker) GetRootSymbols(symbol *ast.Symbol) []*ast.Symbol {
 	return result
 }
 
+func (c *Checker) GetMappedTypeSymbolOfProperty(symbol *ast.Symbol) *ast.Symbol {
+	if valueLinks := c.valueSymbolLinks.TryGet(symbol); valueLinks != nil {
+		return valueLinks.containingType.symbol
+	}
+	return nil
+}
+
 func (c *Checker) getImmediateRootSymbols(symbol *ast.Symbol) []*ast.Symbol {
 	if symbol.CheckFlags&ast.CheckFlagsSynthetic != 0 {
 		return core.MapNonNil(

internal/checker/utilities.go

@@ -1622,14 +1622,6 @@ func symbolsToArray(symbols ast.SymbolTable) []*ast.Symbol {
 	return result
 }
 
-// See comment on `declareModuleMember` in `binder.go`.
-func GetCombinedLocalAndExportSymbolFlags(symbol *ast.Symbol) ast.SymbolFlags {
-	if symbol.ExportSymbol != nil {
-		return symbol.Flags | symbol.ExportSymbol.Flags
-	}
-	return symbol.Flags
-}
-
 func SkipAlias(symbol *ast.Symbol, checker *Checker) *ast.Symbol {
 	if symbol.Flags&ast.SymbolFlagsAlias != 0 {
 		return checker.GetAliasedSymbol(symbol)

internal/collections/multimap.go

@@ -10,6 +10,12 @@ type MultiMap[K comparable, V comparable] struct {
 	M map[K][]V
 }
 
+func NewMultiMapWithSizeHint[K comparable, V comparable](hint int) *MultiMap[K, V] {
+	return &MultiMap[K, V]{
+		M: make(map[K][]V, hint),
+	}
+}
+
 func GroupBy[K comparable, V comparable](items []V, groupId func(V) K) *MultiMap[K, V] {
 	m := &MultiMap[K, V]{}
 	for _, item := range items {

internal/collections/set.go

@@ -14,6 +14,9 @@ func NewSetWithSizeHint[T comparable](hint int) *Set[T] {
 }
 
 func (s *Set[T]) Has(key T) bool {
+	if s == nil {
+		return false
+	}
 	_, ok := s.M[key]
 	return ok
 }
@@ -30,14 +33,23 @@ func (s *Set[T]) Delete(key T) {
 }
 
 func (s *Set[T]) Len() int {
+	if s == nil {
+		return 0
+	}
 	return len(s.M)
 }
 
 func (s *Set[T]) Keys() map[T]struct{} {
+	if s == nil {
+		return nil
+	}
 	return s.M
 }
 
 func (s *Set[T]) Clear() {
+	if s == nil {
+		return
+	}
 	clear(s.M)
 }
 
@@ -58,6 +70,37 @@ func (s *Set[T]) Clone() *Set[T] {
 	return clone
 }
 
+func (s *Set[T]) Union(other *Set[T]) {
+	if s.Len() == 0 && other.Len() == 0 {
+		return
+	}
+	if s == nil {
+		panic("cannot modify nil Set")
+	}
+	if s.M == nil {
+		s.M = maps.Clone(other.M)
+		return
+	}
+	maps.Copy(s.M, other.M)
+}
+
+func (s *Set[T]) UnionedWith(other *Set[T]) *Set[T] {
+	if s == nil && other == nil {
+		return nil
+	}
+	result := s.Clone()
+	if other != nil {
+		if result == nil {
+			result = &Set[T]{}
+		}
+		if result.M == nil {
+			result.M = make(map[T]struct{}, len(other.M))
+		}
+		maps.Copy(result.M, other.M)
+	}
+	return result
+}
+
 func (s *Set[T]) Equals(other *Set[T]) bool {
 	if s == other {
 		return true
@@ -68,6 +111,33 @@ func (s *Set[T]) Equals(other *Set[T]) bool {
 	return maps.Equal(s.M, other.M)
 }
 
+func (s *Set[T]) IsSubsetOf(other *Set[T]) bool {
+	if s == nil {
+		return true
+	}
+	if other == nil {
+		return false
+	}
+	for key := range s.M {
+		if !other.Has(key) {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *Set[T]) Intersects(other *Set[T]) bool {
+	if s == nil || other == nil {
+		return false
+	}
+	for key := range s.M {
+		if other.Has(key) {
+			return true
+		}
+	}
+	return false
+}
+
 func NewSetFromItems[T comparable](items ...T) *Set[T] {
 	s := &Set[T]{}
 	for _, item := range items {