Jan 9, 2026 · Oct 15, 2025 · Oct 16, 2025 · Oct 27, 2025 · Oct 29, 2025 · Oct 29, 2025
diff --git a/cmd/tsgo/lsp.go b/cmd/tsgo/lsp.go
 defer stop()

 if err := s.Run(ctx); err != nil {
 fmt.Fprintln(os.Stderr, err)
 return 1
 }
 return 0
diff --git a/internal/api/api.go b/internal/api/api.go
 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
 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
 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
diff --git a/internal/ast/symbol.go b/internal/ast/symbol.go
 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
diff --git a/internal/ast/utilities.go b/internal/ast/utilities.go
 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
 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
 }
 func GetSourceFileOfModule(module *Symbol) *SourceFile {
 declaration := module.ValueDeclaration
 if declaration == nil {
 declaration =getNonAugmentationDeclaration(module)
 declaration =GetNonAugmentationDeclaration(module)
 }
 return GetSourceFileOfNode(declaration)
 }

 funcgetNonAugmentationDeclaration(symbol *Symbol) *Node {
 funcGetNonAugmentationDeclaration(symbol *Symbol) *Node {
 return core.Find(symbol.Declarations, func(d *Node) bool {
 return !IsExternalModuleAugmentation(d) && !IsGlobalScopeAugmentation(d)
 })
 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())
 }
diff --git a/internal/checker/checker.go b/internal/checker/checker.go
 }

 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

 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*/)
 }

diff --git a/internal/checker/services.go b/internal/checker/services.go
 // 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) {
 ifGetCombinedLocalAndExportSymbolFlags(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
 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(
diff --git a/internal/checker/utilities.go b/internal/checker/utilities.go
 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)
diff --git a/internal/collections/multimap.go b/internal/collections/multimap.go
 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 {
diff --git a/internal/collections/set.go b/internal/collections/set.go
 }

 func (s *Set[T]) Has(key T) bool {
 if s == nil {
 return false
 }
 _, ok := s.M[key]
 return ok
 }
 }

 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)
 }

 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
 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 {
diff --git a/internal/compiler/filesparser.go b/internal/compiler/filesparser.go
 typeResolutionsInFile        module.ModeAwareCache[*module.ResolvedTypeReferenceDirective]
 typeResolutionsTrace         []module.DiagAndArgs
 resolutionDiagnostics        []*ast.Diagnostic
 resolvedPackageNames         collections.Set[string]
 unresolvedPackageNames       collections.Set[string]
 processingDiagnostics        []*processingDiagnostic
 importHelpersImportSpecifier *ast.Node
 jsxRuntimeImportSpecifier    *jsxRuntimeImportSpecifier
diff --git a/internal/compiler/program.go b/internal/compiler/program.go
 "github.com/microsoft/typescript-go/internal/diagnostics"
 "github.com/microsoft/typescript-go/internal/locale"
 "github.com/microsoft/typescript-go/internal/module"
 "github.com/microsoft/typescript-go/internal/modulespecifiers"
 "github.com/microsoft/typescript-go/internal/outputpaths"
 "github.com/microsoft/typescript-go/internal/packagejson"
 "github.com/microsoft/typescript-go/internal/parser"
 knownSymlinks         *symlinks.KnownSymlinks
 knownSymlinksOnce     sync.Once

 // Used by auto-imports
 packageNamesOnce       sync.Once
 resolvedPackageNames   *collections.Set[string]
 unresolvedPackageNames *collections.Set[string]

 // Used by workspace/symbol
 hasTSFileOnce sync.Once
 hasTSFile     bool
 programDiagnostics:          p.programDiagnostics,
 hasEmitBlockingDiagnostics:  p.hasEmitBlockingDiagnostics,
 unresolvedImports:           p.unresolvedImports,
 resolvedPackageNames:        p.resolvedPackageNames,
 unresolvedPackageNames:      p.unresolvedPackageNames,
 knownSymlinks:               p.knownSymlinks,
 }
 result.initCheckerPool()
 return sourceFileMayBeEmitted(sourceFile, p, forceDtsEmit)
 }

 func (p *Program) ResolvedPackageNames() *collections.Set[string] {
 p.collectPackageNames()
 return p.resolvedPackageNames
 }

 func (p *Program) UnresolvedPackageNames() *collections.Set[string] {
 p.collectPackageNames()
 return p.unresolvedPackageNames
 }

 func (p *Program) collectPackageNames() {
 p.packageNamesOnce.Do(func() {
 if p.resolvedPackageNames == nil {
 p.resolvedPackageNames = &collections.Set[string]{}
 p.unresolvedPackageNames = &collections.Set[string]{}
 for _, file := range p.files {
 if p.IsSourceFileDefaultLibrary(file.Path()) || p.IsSourceFileFromExternalLibrary(file) {
 continue
 }
 for _, imp := range file.Imports() {
 if tspath.IsExternalModuleNameRelative(imp.Text()) {
 continue
 }
 if resolvedModules, ok := p.resolvedModules[file.Path()]; ok {
 key := module.ModeAwareCacheKey{Name: imp.Text(), Mode: p.GetModeForUsageLocation(file, imp)}
 if resolvedModule, ok := resolvedModules[key]; ok && resolvedModule.IsResolved() {
 if !resolvedModule.IsExternalLibraryImport {
 continue
 }
 name := resolvedModule.PackageId.Name
 if name == "" {
 // node_modules package, but no name in package.json - this can happen in a monorepo package,
 // and unfortunately in lots of fourslash tests
 name = modulespecifiers.GetPackageNameFromDirectory(resolvedModule.ResolvedFileName)
 }
 p.resolvedPackageNames.Add(name)
 continue
 }
 }
 p.unresolvedPackageNames.Add(imp.Text())
 }
 }
 }
 })
 }

 func (p *Program) IsLibFile(sourceFile *ast.SourceFile) bool {
 _, ok := p.libFiles[sourceFile.Path()]
 return ok
Original file line number	Diff line number	Diff line change
Expand Up		@@ -64,6 +64,7 @@ func runLSP(args []string) int {
		defer stop()

		if err := s.Run(ctx); err != nil {
		fmt.Fprintln(os.Stderr, err)
Copy link MemberAuthor andrewbranchDec 16, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. I haven’t looked at#2336 yet, but this could be what’s missing to show a stack trace.
		return 1
		}
		return 0
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Expand DownExpand Up		@@ -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
Expand DownExpand Up		@@ -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
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
Expand DownExpand Up		@@ -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
		}
Expand DownExpand Up		@@ -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)
		}

		funcgetNonAugmentationDeclaration(symbol Symbol) Node {
		funcGetNonAugmentationDeclaration(symbol Symbol) Node {
		return core.Find(symbol.Declarations, func(d *Node) bool {
		return !IsExternalModuleAugmentation(d) && !IsGlobalScopeAugmentation(d)
		})
Expand DownExpand Up		@@ -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())
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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() {
Copy link MemberAuthor andrewbranchDec 16, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. Auto-imports uses checkers for minimal alias resolution, and these code paths go way down a rabbit hole hitting the file system and using the node builder to generate errors. Added some targeted short circuits.
		return
		}
		moduleName := c.getFullyQualifiedName(moduleSymbol, node)
		declarationName := scanner.DeclarationNameToString(name)
		var suggestion *ast.Symbol
Expand DownExpand Up		@@ -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/)
		}

Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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) {
		ifGetCombinedLocalAndExportSymbolFlags(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
Expand DownExpand Up		@@ -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(
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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)
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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 {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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
		}
Expand All		@@ -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)
		}

Expand All		@@ -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
Expand All		@@ -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
gabritto marked this conversation as resolved. OutdatedShow resolvedHide resolved
		}
		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 {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -32,6 +32,8 @@ type parseTask struct {
		typeResolutionsInFile module.ModeAwareCache[*module.ResolvedTypeReferenceDirective]
		typeResolutionsTrace []module.DiagAndArgs
		resolutionDiagnostics []*ast.Diagnostic
		resolvedPackageNames collections.Set[string]
		unresolvedPackageNames collections.Set[string]
		processingDiagnostics []*processingDiagnostic
		importHelpersImportSpecifier *ast.Node
		jsxRuntimeImportSpecifier *jsxRuntimeImportSpecifier
Expand Down