more

Author: jakebailey

internal/ls/findallreferences.go

@@ -976,7 +976,93 @@ func getMergedAliasedSymbolOfNamespaceExportDeclaration(node *ast.Node, symbol *
 }
 
 func getReferencedSymbolsForModule(program *compiler.Program, symbol *ast.Symbol, excludeImportTypeOfExportEquals bool, sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string]) []*SymbolAndEntries {
-	// !!! not implemented
+	debug.Assert(symbol.ValueDeclaration != nil)
+
+	checker, done := program.GetTypeChecker(nil)
+	defer done()
+
+	references := core.MapNonNil(findModuleReferences(program, sourceFiles, symbol, checker), func(reference ModuleReference) *referenceEntry {
+		switch reference.kind {
+		case ModuleReferenceKindImport:
+			parent := reference.literal.Parent
+			if ast.IsLiteralTypeNode(parent) {
+				importType := parent.Parent
+				if ast.IsImportTypeNode(importType) {
+					importTypeNode := importType.AsImportTypeNode()
+					if excludeImportTypeOfExportEquals && importTypeNode.Qualifier == nil {
+						return nil
+					}
+				}
+			}
+			// import("foo") with no qualifier will reference the `export =` of the module, which may be referenced anyway.
+			return newNodeEntry(reference.literal)
+		case ModuleReferenceKindImplicit:
+			// For implicit references (e.g., JSX runtime imports), return the first statement or the whole file.
+			// We skip the complex JSX detection for now and just use the first statement or the file itself.
+			var rangeNode *ast.Node
+			if reference.referencingFile.Statements != nil && len(reference.referencingFile.Statements.Nodes) > 0 {
+				rangeNode = reference.referencingFile.Statements.Nodes[0]
+			} else {
+				rangeNode = reference.referencingFile.AsNode()
+			}
+			return newNodeEntry(rangeNode)
+		case ModuleReferenceKindReference:
+			// <reference path> or <reference types>
+			// We can't easily create a proper range entry here without access to LanguageService,
+			// but we can create a node-based entry pointing to the source file which will be resolved later
+			return newNodeEntry(reference.referencingFile.AsNode())
+		}
+		return nil
+	})
+
+	// Add references to the module declarations themselves
+	if len(symbol.Declarations) > 0 {
+		for _, decl := range symbol.Declarations {
+			switch decl.Kind {
+			case ast.KindSourceFile:
+				// Don't include the source file itself. (This may not be ideal behavior, but awkward to include an entire file as a reference.)
+				continue
+			case ast.KindModuleDeclaration:
+				if sourceFilesSet.Has(ast.GetSourceFileOfNode(decl).FileName()) {
+					references = append(references, newNodeEntry(decl.AsModuleDeclaration().Name()))
+				}
+			default:
+				// This may be merged with something.
+				debug.Assert(symbol.Flags&ast.SymbolFlagsTransient != 0, "Expected a module symbol to be declared by a SourceFile or ModuleDeclaration.")
+			}
+		}
+	}
+
+	// Handle export equals declarations
+	exported := symbol.Exports[ast.InternalSymbolNameExportEquals]
+	if exported != nil && len(exported.Declarations) > 0 {
+		for _, decl := range exported.Declarations {
+			sourceFile := ast.GetSourceFileOfNode(decl)
+			if sourceFilesSet.Has(sourceFile.FileName()) {
+				var node *ast.Node
+				// At `module.exports = ...`, reference node is `module`
+				if ast.IsBinaryExpression(decl) && ast.IsPropertyAccessExpression(decl.AsBinaryExpression().Left) {
+					node = decl.AsBinaryExpression().Left.AsPropertyAccessExpression().Expression
+				} else if ast.IsExportAssignment(decl) {
+					// Find the export keyword - for now, just use the declaration itself
+					node = decl
+				} else {
+					node = ast.GetNameOfDeclaration(decl)
+					if node == nil {
+						node = decl
+					}
+				}
+				references = append(references, newNodeEntry(node))
+			}
+		}
+	}
+
+	if len(references) > 0 {
+		return []*SymbolAndEntries{{
+			definition: &Definition{Kind: definitionKindSymbol, symbol: symbol},
+			references: references,
+		}}
+	}
 	return nil
 }
 

internal/ls/importTracker.go

@@ -6,6 +6,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/ast"
 	"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"
 	"github.com/microsoft/typescript-go/internal/debug"
 )
@@ -42,6 +43,22 @@ type ImportsResult struct {
 
 type ImportTracker func(exportSymbol *ast.Symbol, exportInfo *ExportInfo, isForRename bool) *ImportsResult
 
+type ModuleReferenceKind int32
+
+const (
+	ModuleReferenceKindImport ModuleReferenceKind = iota
+	ModuleReferenceKindReference
+	ModuleReferenceKindImplicit
+)
+
+// ModuleReference represents a reference to a module, either via import, <reference>, or implicit reference
+type ModuleReference struct {
+	kind            ModuleReferenceKind
+	literal         *ast.Node // for import and implicit kinds (StringLiteralLike)
+	referencingFile *ast.SourceFile
+	ref             *ast.FileReference // for reference kind
+}
+
 // Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily.
 func createImportTracker(sourceFiles []*ast.SourceFile, sourceFilesSet *collections.Set[string], checker *checker.Checker) ImportTracker {
 	allDirectImports := getDirectImportsMap(sourceFiles, checker)
@@ -654,3 +671,58 @@ func symbolNameNoDefault(symbol *ast.Symbol) string {
 	}
 	return ""
 }
+
+// findModuleReferences finds all references to a module symbol across the given source files.
+// This includes import statements, <reference> directives, and implicit references (e.g., JSX runtime imports).
+func findModuleReferences(program *compiler.Program, sourceFiles []*ast.SourceFile, searchModuleSymbol *ast.Symbol, checker *checker.Checker) []ModuleReference {
+	refs := []ModuleReference{}
+
+	for _, referencingFile := range sourceFiles {
+		searchSourceFile := searchModuleSymbol.ValueDeclaration
+		if searchSourceFile != nil && searchSourceFile.Kind == ast.KindSourceFile {
+			// Check <reference path> directives
+			for _, ref := range referencingFile.ReferencedFiles {
+				if program.GetSourceFileFromReference(referencingFile, ref) == searchSourceFile.AsSourceFile() {
+					refs = append(refs, ModuleReference{
+						kind:            ModuleReferenceKindReference,
+						referencingFile: referencingFile,
+						ref:             ref,
+					})
+				}
+			}
+
+			// Check <reference types> directives
+			for _, ref := range referencingFile.TypeReferenceDirectives {
+				referenced := program.GetResolvedTypeReferenceDirectiveFromTypeReferenceDirective(ref, referencingFile)
+				if referenced != nil && referenced.ResolvedFileName == searchSourceFile.AsSourceFile().FileName() {
+					refs = append(refs, ModuleReference{
+						kind:            ModuleReferenceKindReference,
+						referencingFile: referencingFile,
+						ref:             ref,
+					})
+				}
+			}
+		}
+
+		// Check all imports (including require() calls)
+		forEachImport(referencingFile, func(importDecl *ast.Node, moduleSpecifier *ast.Node) {
+			moduleSymbol := checker.GetSymbolAtLocation(moduleSpecifier)
+			if moduleSymbol == searchModuleSymbol {
+				if ast.NodeIsSynthesized(importDecl) {
+					refs = append(refs, ModuleReference{
+						kind:            ModuleReferenceKindImplicit,
+						literal:         moduleSpecifier,
+						referencingFile: referencingFile,
+					})
+				} else {
+					refs = append(refs, ModuleReference{
+						kind:    ModuleReferenceKindImport,
+						literal: moduleSpecifier,
+					})
+				}
+			}
+		})
+	}
+
+	return refs
+}