package api import ( "cmp" "context" "encoding/base64" "errors" "fmt" "io" "runtime/debug" "slices" "strconv" "strings" "sync" "sync/atomic" "time" "github.com/microsoft/TypeScript/tsc/internal/api/encoder" "github.com/microsoft/TypeScript/tsc/internal/api/requestfilesystem" "github.com/microsoft/TypeScript/tsc/internal/ast" "github.com/microsoft/TypeScript/tsc/internal/astnav" "github.com/microsoft/TypeScript/tsc/internal/checker" "github.com/microsoft/TypeScript/tsc/internal/collections" "github.com/microsoft/TypeScript/tsc/internal/compiler" "github.com/microsoft/TypeScript/tsc/internal/core" compilerdebug "github.com/microsoft/TypeScript/tsc/internal/debug" "github.com/microsoft/TypeScript/tsc/internal/diagnostics" "github.com/microsoft/TypeScript/tsc/internal/execute/build" "github.com/microsoft/TypeScript/tsc/internal/execute/tsc" "github.com/microsoft/TypeScript/tsc/internal/format" "github.com/microsoft/TypeScript/tsc/internal/ipc" "github.com/microsoft/TypeScript/tsc/internal/jsnum" "github.com/microsoft/TypeScript/tsc/internal/json" "github.com/microsoft/TypeScript/tsc/internal/ls" "github.com/microsoft/TypeScript/tsc/internal/ls/autoimport" "github.com/microsoft/TypeScript/tsc/internal/ls/lsconv" "github.com/microsoft/TypeScript/tsc/internal/lsp/lsproto" "github.com/microsoft/TypeScript/tsc/internal/module" "github.com/microsoft/TypeScript/tsc/internal/nodebuilder" "github.com/microsoft/TypeScript/tsc/internal/pprof" "github.com/microsoft/TypeScript/tsc/internal/printer" "github.com/microsoft/TypeScript/tsc/internal/project" "github.com/microsoft/TypeScript/tsc/internal/transpile" "github.com/microsoft/TypeScript/tsc/internal/tsoptions" "github.com/microsoft/TypeScript/tsc/internal/tspath" "github.com/microsoft/TypeScript/tsc/internal/vfs" "github.com/zeebo/xxh3" ) var ( sessionIDCounter atomic.Uint64 sourceFileSymbolIndexKey = ast.NewSourceFileDataKey[map[SymbolID]*ast.Symbol]() ) func getSourceFileSymbolIndex(sourceFile *ast.SourceFile) map[SymbolID]*ast.Symbol { return sourceFile.GetOrComputeData(sourceFileSymbolIndexKey, func(file *ast.SourceFile) map[SymbolID]*ast.Symbol { index := make(map[SymbolID]*ast.Symbol, file.SymbolCount) var addSymbol func(*ast.Symbol) addSymbol = func(symbol *ast.Symbol) { if symbol == nil || symbol.Flags&ast.SymbolFlagsTransient != 0 { return } compilerdebug.Assert(ast.GetSourceFileOfSymbol(symbol) == file) id := SymbolHandle(symbol) if existing := index[id]; existing != nil { compilerdebug.Assert(existing == symbol) return } index[id] = symbol addSymbol(symbol.Parent) addSymbol(symbol.ExportSymbol) for _, table := range []ast.SymbolTable{symbol.Members, symbol.Exports} { for _, child := range table { addSymbol(child) } } } for _, node := range encoder.GetNodeIndexTable(file).Nodes { if node == nil { continue } addSymbol(node.Symbol()) addSymbol(node.LocalSymbol()) for _, symbol := range node.Locals() { addSymbol(symbol) } } for _, symbol := range file.GlobalExports { addSymbol(symbol) } for _, module := range file.PatternAmbientModules { addSymbol(module.Symbol) } return index }) } // snapshotData holds the per-snapshot state including the snapshot itself // and symbol/type registries scoped to this snapshot. // Multiple clients may hold references to the same snapshot via ref counting; // the registries are cleaned up when refCount reaches zero. type snapshotData struct { handle SnapshotID snapshot *project.Snapshot fileSystem vfs.FS refCount int openProjects collections.Set[tspath.Path] openFiles collections.Set[tspath.Path] // Symbol IDs come from ast.GetSymbolId, a global atomic counter, so the same // *ast.Symbol pointer always has the same unique ID across all projects in the // snapshot. Symbols are registered snapshot-wide to ensure identity semantics: // querying the same symbol from two different projects returns the same handle. symbolRegistry map[SymbolID]*ast.Symbol symbolRegistryMu sync.RWMutex // symbolCanonicalProjects records, for each registered symbol, the project it was // first observed in. Because symbols are shared snapshot-wide (binder symbols are // attached to source files, which can be shared across projects), lookups that need // a project context (e.g. member/export ordering, node handle resolution) but don't // receive one from the caller default to this canonical project. First-writer wins so // the choice is stable. Guarded by symbolRegistryMu. symbolCanonicalProjects map[SymbolID]project.ID projectRegistries map[project.ID]*projectRegistryData projectRegistriesMu sync.RWMutex } type moduleResolverRegistration struct { id ModuleResolverID compilerOptions *core.CompilerOptions resolutions *module.StaticResolutions resolveModuleNameCallback string } // projectRegistryData holds per-project type and signature registries. // Types and signatures use per-checker sequential IDs, so the same local ID // can appear in multiple projects. Separate maps per project prevent collisions // and allow clean teardown when a project is removed. type projectRegistryData struct { typeRegistry map[TypeID]*checker.Type typeRegistryMu sync.RWMutex signatureRegistry map[SignatureID]*checker.Signature signatureRegistryMu sync.RWMutex } // getProgram looks up a program from a project handle within this snapshot. func (sd *snapshotData) getProgram(projectHandle project.ID) (*compiler.Program, error) { proj, err := sd.getProject(projectHandle) if err != nil { return nil, err } program := proj.GetProgram() if program == nil { return nil, fmt.Errorf("%w: project has no program", ErrClientError) } return program, nil } // getProject looks up a project from a project handle within this snapshot. func (sd *snapshotData) getProject(projectHandle project.ID) (*project.Project, error) { proj := sd.snapshot.ProjectCollection.GetProject(projectHandle) if proj == nil { return nil, fmt.Errorf("%w: project %s not found", ErrClientError, projectHandle) } return proj, nil } // nodeHandleFrom creates an index-based node handle (index.kind.path), building a node index table // for the file on-demand if needed. func (sd *snapshotData) nodeHandleFrom(node *ast.Node) NodeHandle { return nodeHandleFrom(node) } // getOrCreateProjectRegistry returns the registry for the given project, creating it if needed. func (sd *snapshotData) getOrCreateProjectRegistry(projectID project.ID) *projectRegistryData { if projectID == "" { panic("getOrCreateProjectRegistry: empty project ID") } // Fast path: registry already exists — read lock only. sd.projectRegistriesMu.RLock() reg := sd.projectRegistries[projectID] sd.projectRegistriesMu.RUnlock() if reg != nil { return reg } // Slow path: create under write lock. sd.projectRegistriesMu.Lock() defer sd.projectRegistriesMu.Unlock() if sd.projectRegistries[projectID] == nil { sd.projectRegistries[projectID] = &projectRegistryData{ typeRegistry: make(map[TypeID]*checker.Type), signatureRegistry: make(map[SignatureID]*checker.Signature), } } return sd.projectRegistries[projectID] } // symbolOwnerFile returns the source file that owns a symbol's client identity, or nil when the // symbol is owned by its snapshot. Content-mapped outputs live in a cache that cannot yet be // addressed by file key, so their binder symbols remain snapshot-owned. func symbolOwnerFile(symbol *ast.Symbol) *ast.SourceFile { if symbol.Flags&ast.SymbolFlagsTransient != 0 { return nil } file := ast.GetSourceFileOfSymbol(symbol) if file.IsContentMapped() { return nil } return file } // newSymbolResponse classifies a symbol's ownership before exposing its identity to a client. // Only snapshot-owned symbols are registered in the snapshot; file-owned symbols are resolved // through their source file. func (sd *snapshotData) newSymbolResponse(symbol *ast.Symbol, canonicalProject project.ID) *SymbolResponse { if symbol == nil { return nil } if symbolOwnerFile(symbol) != nil { return newFileSymbolResponse(symbol) } id, project := sd.registerSymbol(symbol, canonicalProject) reference := SymbolReference{ Id: id, Kind: SymbolOwnerKindSnapshot, Snapshot: sd.handle, Project: project, } return buildSymbolResponse(symbol, reference, nil) } func newFileSymbolResponse(symbol *ast.Symbol) *SymbolResponse { file := symbolOwnerFile(symbol) compilerdebug.Assert(file != nil, "Expected a file-owned symbol") descriptor := newSourceFileDescriptor(file) reference := SymbolReference{ Id: SymbolHandle(symbol), Kind: SymbolOwnerKindFile, File: &descriptor, } return buildSymbolResponse(symbol, reference, file) } func buildSymbolResponse(symbol *ast.Symbol, reference SymbolReference, owner *ast.SourceFile) *SymbolResponse { resp := &SymbolResponse{ Reference: reference, Name: ast.EscapeSymbolName(symbol.Name), Flags: uint32(symbol.Flags), CheckFlags: uint32(symbol.CheckFlags), Parent: newSymbolReference(symbol.Parent), ExportSymbol: newSymbolReference(symbol.ExportSymbol), } if owner != nil { // A client resolves a file-owned symbol's relationships through its own source file. compilerdebug.Assert(symbol.Parent == nil || symbolOwnerFile(symbol.Parent) == owner, "File-owned symbol parent belongs to another owner") compilerdebug.Assert(symbol.ExportSymbol == nil || symbolOwnerFile(symbol.ExportSymbol) == owner, "File-owned export symbol belongs to another owner") } if len(symbol.Declarations) > 0 { resp.Declarations = make([]NodeHandle, len(symbol.Declarations)) for i, decl := range symbol.Declarations { resp.Declarations[i] = symbolNodeHandleFrom(decl, owner) } } if symbol.ValueDeclaration != nil { resp.ValueDeclaration = symbolNodeHandleFrom(symbol.ValueDeclaration, owner) } return resp } // newSymbolReference creates a compact reference to a symbol without registering it. Clients resolve // it from their caches or fetch the full response through the corresponding property method. func newSymbolReference(symbol *ast.Symbol) *CompactSymbolReference { if symbol == nil { return nil } reference := &CompactSymbolReference{Id: SymbolHandle(symbol)} if file := symbolOwnerFile(symbol); file != nil { reference.File = strconv.FormatUint(sourceFileNodeID(file), 10) } return reference } func symbolNodeHandleFrom(node *ast.Node, owner *ast.SourceFile) NodeHandle { if owner != nil { compilerdebug.Assert(ast.GetSourceFileOfNode(node) == owner, "File-owned symbol declaration belongs to another source file") } return nodeHandleFrom(node) } func nodeHandleFrom(node *ast.Node) NodeHandle { sourceFile := ast.GetSourceFileOfNode(node) table := encoder.GetNodeIndexTable(sourceFile) idx := table.GetIndex(node) return NodeHandle(fmt.Sprintf("%d.%d.%s", idx, node.Kind, sourceFile.Path())) } // registerSymbol registers a symbol in the snapshot's registry and returns its handle along with // its canonical project. The canonical project is the project the symbol was first observed in // (first writer wins for stability) and is always non-empty: every symbol handed to a client must // carry a project so that project-scoped follow-up lookups (members/exports, parent, node // resolution) have a default context. Callers must supply a non-empty project. func (sd *snapshotData) registerSymbol(symbol *ast.Symbol, canonicalProject project.ID) (SymbolID, project.ID) { if symbol == nil { return 0, project.ID("") } if canonicalProject == "" { panic("registerSymbol requires a non-empty canonical project") } id := SymbolHandle(symbol) sd.symbolRegistryMu.Lock() defer sd.symbolRegistryMu.Unlock() existing := sd.symbolRegistry[id] if existing != nil { if existing != symbol { panic("duplicate symbol") } } else { sd.symbolRegistry[id] = symbol } project, ok := sd.symbolCanonicalProjects[id] if !ok { sd.symbolCanonicalProjects[id] = canonicalProject project = canonicalProject } return id, project } // newTypeResponse registers a type in the project's registry and returns the response. func (sd *snapshotData) newTypeResponse(projectID project.ID, t *checker.Type, c *checker.Checker) *TypeResponse { if t == nil { return nil } resp := newTypeResponse(t, sd.registerType(projectID, t)) resp.Symbol = newSymbolReference(t.Symbol()) if t.Alias() != nil { resp.AliasSymbol = newSymbolReference(t.Alias().Symbol()) } if t.ObjectFlags()&checker.ObjectFlagsMapped != 0 { mapped := t.AsMappedType() mapped.ResolveComponents(c, t) resp.TypeParameter = sd.registerType(projectID, mapped.TypeParameter()) resp.ConstraintType = sd.registerType(projectID, mapped.ConstraintType()) resp.NameType = sd.registerType(projectID, mapped.NameType()) resp.TemplateType = sd.registerType(projectID, mapped.TemplateType()) } if checker.IsTupleTypeTarget(t) { elementInfos := t.AsTupleType().ElementInfos() for i := range elementInfos { if declaration := elementInfos[i].LabeledDeclaration(); declaration != nil { if resp.LabeledElementDeclarations == nil { resp.LabeledElementDeclarations = make([]NodeHandle, len(elementInfos)) } resp.LabeledElementDeclarations[i] = sd.nodeHandleFrom(declaration) } } } return resp } func (sd *snapshotData) registerType(projectID project.ID, t *checker.Type) TypeID { if t == nil { return 0 } id := TypeHandle(t) reg := sd.getOrCreateProjectRegistry(projectID) reg.typeRegistryMu.Lock() defer reg.typeRegistryMu.Unlock() existing := reg.typeRegistry[id] if existing != nil { if existing != t { panic("duplicate type") } return id } reg.typeRegistry[id] = t return id } // resolveSymbolHandle resolves a snapshot-owned symbol handle within the snapshot's registry. func (sd *snapshotData) resolveSymbolHandle(handle SymbolID) (*ast.Symbol, error) { if handle == 0 { return nil, fmt.Errorf("%w: empty symbol handle", ErrClientError) } sd.symbolRegistryMu.RLock() symbol, ok := sd.symbolRegistry[handle] sd.symbolRegistryMu.RUnlock() if !ok { return nil, fmt.Errorf("%w: symbol handle %d not found in snapshot registry", ErrClientError, handle) } return symbol, nil } // resolveSymbolReference resolves a symbol without a semantic context. A file reference holds the // exact cached AST until the returned release function is called; a snapshot reference also returns // the snapshot and canonical project that own the symbol. func (s *Session) resolveSymbolReference(ref SymbolReference) (*ast.Symbol, *snapshotData, project.ID, func(), error) { switch ref.Kind { case SymbolOwnerKindFile: if ref.File == nil || ref.Snapshot != 0 || ref.Project != "" { return nil, nil, "", nil, fmt.Errorf("%w: invalid file symbol reference", ErrClientError) } lease, err := s.acquireCachedSourceFile(*ref.File) if err != nil { return nil, nil, "", nil, err } symbol := getSourceFileSymbolIndex(lease.SourceFile())[ref.Id] if symbol == nil { lease.Release() return nil, nil, "", nil, fmt.Errorf("%w: symbol %d not found in source file", ErrClientError, ref.Id) } return symbol, nil, "", lease.Release, nil case SymbolOwnerKindSnapshot: if ref.File != nil || ref.Snapshot == 0 || ref.Project == "" { return nil, nil, "", nil, fmt.Errorf("%w: invalid snapshot symbol reference", ErrClientError) } sd, err := s.getSnapshotData(ref.Snapshot) if err != nil { return nil, nil, "", nil, err } symbol, err := sd.resolveSymbolHandle(ref.Id) if err != nil { return nil, nil, "", nil, err } return symbol, sd, ref.Project, func() {}, nil default: return nil, nil, "", nil, fmt.Errorf("%w: invalid symbol reference kind %d", ErrClientError, ref.Kind) } } // resolveTypeHandle resolves a type handle within the project's registry. func (sd *snapshotData) resolveTypeHandle(projectID project.ID, handle TypeID) (*checker.Type, error) { if handle == 0 { return nil, fmt.Errorf("%w: empty type handle", ErrClientError) } if projectID == "" { return nil, fmt.Errorf("%w: empty project ID for type handle %d", ErrClientError, handle) } sd.projectRegistriesMu.RLock() reg := sd.projectRegistries[projectID] sd.projectRegistriesMu.RUnlock() if reg == nil { return nil, fmt.Errorf("%w: type handle %d not found (no registry for project %s)", ErrClientError, handle, projectID) } reg.typeRegistryMu.RLock() t, ok := reg.typeRegistry[handle] reg.typeRegistryMu.RUnlock() if !ok { return nil, fmt.Errorf("%w: type handle %d not found in project registry", ErrClientError, handle) } return t, nil } // resolveSignatureHandle resolves a signature handle within the project's registry. func (sd *snapshotData) resolveSignatureHandle(projectID project.ID, handle SignatureID) (*checker.Signature, error) { if handle == 0 { return nil, fmt.Errorf("%w: empty signature handle", ErrClientError) } if projectID == "" { return nil, fmt.Errorf("%w: empty project ID for signature handle %d", ErrClientError, handle) } sd.projectRegistriesMu.RLock() reg := sd.projectRegistries[projectID] sd.projectRegistriesMu.RUnlock() if reg == nil { return nil, fmt.Errorf("%w: signature handle %d not found (no registry for project %s)", ErrClientError, handle, projectID) } reg.signatureRegistryMu.RLock() sig, ok := reg.signatureRegistry[handle] reg.signatureRegistryMu.RUnlock() if !ok { return nil, fmt.Errorf("%w: signature handle %d not found in project registry", ErrClientError, handle) } return sig, nil } // newSignatureResponse registers a signature in the project's registry and returns the response. func (sd *snapshotData) newSignatureResponse(projectID project.ID, sig *checker.Signature) *SignatureResponse { if sig == nil { return nil } resp := &SignatureResponse{ Id: sd.registerSignature(projectID, sig), Flags: uint32(sig.Flags()), } if sig.Declaration() != nil { resp.Declaration = sd.nodeHandleFrom(sig.Declaration()) } if len(sig.TypeParameters()) > 0 { resp.TypeParameters = typeHandles(sig.TypeParameters()) } if len(sig.Parameters()) > 0 { resp.Parameters = make([]CompactSymbolReference, len(sig.Parameters())) for i, parameter := range sig.Parameters() { resp.Parameters[i] = *newSymbolReference(parameter) } } if sig.ThisParameter() != nil { resp.ThisParameter = newSymbolReference(sig.ThisParameter()) } if sig.Target() != nil { resp.Target = SignatureHandle(sig.Target()) } return resp } func (sd *snapshotData) registerSignature(projectID project.ID, sig *checker.Signature) SignatureID { if sig == nil { return 0 } id := SignatureHandle(sig) reg := sd.getOrCreateProjectRegistry(projectID) reg.signatureRegistryMu.Lock() defer reg.signatureRegistryMu.Unlock() existing := reg.signatureRegistry[id] if existing != nil { if existing != sig { panic("duplicate signature") } return id } reg.signatureRegistry[id] = sig return id } // Session represents an API session that provides programmatic access // to TypeScript language services through the LSP server. // It implements the Handler interface to process incoming API requests. // The session supports multiple active snapshots, each with their own // symbol and type registries for maintaining object identity. type Session struct { id string snapshotHost *project.SnapshotHost ownsSnapshotHost bool withLocale func(context.Context) context.Context projectSession *project.Session closeOnce sync.Once // This is set to true when using MessagePackProtocol. useBinaryResponses bool batchResponsePages sync.Map nextBatchResponsePageID atomic.Uint64 // snapshots maps snapshot handles to their data. Each snapshot has its own // symbol/type registries. // // snapshotsMu guards the snapshots map. It is held only for // short, map-bounded critical sections, never across slow work like a project // snapshot update or checker queries. Read handlers (getSnapshotData and the // language-service handlers built on it) take it for reading; handleRelease and // snapshot creation bookkeeping takes it for writing. This is what // lets queries against an existing snapshot run concurrently with the building of // the next one. snapshots map[SnapshotID]*snapshotData snapshotsMu sync.RWMutex // openProjects, openFiles, and createdPrograms are the canonical LSP-state resources // owned by this API client. Guarded by languageServerUpdateMu. openProjects collections.Set[tspath.Path] openFiles collections.Set[tspath.Path] createdPrograms collections.Set[project.SyntheticProjectID] languageServerUpdateMu sync.Mutex buildOrchestrators map[BuildOrchestratorID]*build.Orchestrator buildMu sync.Mutex nextModuleResolverID atomic.Uint64 moduleResolvers map[ModuleResolverID]*moduleResolverRegistration moduleResolversMu sync.RWMutex nextProgramResolutionContextID atomic.Uint64 programResolutionContexts map[uint64]*programResolutionContext programResolutionContextsMu sync.RWMutex sourceFileLeases map[SourceFileLeaseID]*project.SourceFileLease sourceFileLeasesMu sync.Mutex nextSourceFileLeaseID atomic.Uint64 conn ipc.Conn cpuProfiler pprof.CPUProfiler } type batchResponsePage struct { encodedResponses []json.Value } // Ensure Session implements Handler var _ ipc.Handler = (*Session)(nil) // SessionOptions configures an API session. type SessionOptions struct { // UseBinaryResponses enables binary responses for msgpack protocol. UseBinaryResponses bool } // DefaultMaxResponseBytesPerPage leaves room for base64 expansion beneath V8's // maximum string length while rounding down to an even decimal value. const DefaultMaxResponseBytesPerPage = 300_000_000 // NewLSPSession creates a new API session with the given project session. func NewLSPSession(projectSession *project.Session, options *SessionOptions) *Session { s := newSession(projectSession.SnapshotHost, projectSession.WithCurrentLocale, options) s.projectSession = projectSession return s } // NewStandaloneSession creates an API session with an independently owned snapshot host. func NewStandaloneSession(init *project.SessionInit, options *SessionOptions) *Session { snapshotHost := project.NewSnapshotHost(init) s := newSession(snapshotHost, nil, options) s.ownsSnapshotHost = true return s } func newSession(snapshotHost *project.SnapshotHost, withLocale func(context.Context) context.Context, options *SessionOptions) *Session { id := sessionIDCounter.Add(1) if withLocale == nil { withLocale = func(ctx context.Context) context.Context { return ctx } } s := &Session{ id: formatSessionID(id), snapshotHost: snapshotHost, withLocale: withLocale, snapshots: make(map[SnapshotID]*snapshotData), buildOrchestrators: make(map[BuildOrchestratorID]*build.Orchestrator), moduleResolvers: make(map[ModuleResolverID]*moduleResolverRegistration), programResolutionContexts: make(map[uint64]*programResolutionContext), sourceFileLeases: make(map[SourceFileLeaseID]*project.SourceFileLease), } if options != nil { s.useBinaryResponses = options.UseBinaryResponses } return s } // ID returns the unique identifier for this session. func (s *Session) ID() string { return s.id } func (s *Session) SetConnection(conn ipc.Conn) { s.conn = conn } func (s *Session) GetCurrentDirectory() string { return s.snapshotHost.GetCurrentDirectory() } func (s *Session) FS() vfs.FS { if s.projectSession != nil { return s.projectSession.FS() } return s.snapshotHost.FS() } func (s *Session) DefaultLibraryPath() string { if s.projectSession != nil { return s.projectSession.DefaultLibraryPath() } return s.snapshotHost.DefaultLibraryPath() } func (s *Session) useCaseSensitiveFileNames() bool { return s.snapshotHost.FS().UseCaseSensitiveFileNames() } // snapshotHandle creates a snapshot handle from a snapshot's ID. func snapshotHandle(snapshot *project.Snapshot) SnapshotID { return SnapshotID(snapshot.ID()) } // getSnapshotData looks up snapshot data by handle. func (s *Session) getSnapshotData(handle SnapshotID) (*snapshotData, error) { s.snapshotsMu.RLock() sd, ok := s.snapshots[handle] s.snapshotsMu.RUnlock() if !ok { return nil, fmt.Errorf("%w: snapshot %d not found", ErrClientError, handle) } return sd, nil } // retainSnapshotData pins snapshot data while an operation builds a derived snapshot. func (s *Session) retainSnapshotData(handle SnapshotID) (*snapshotData, error) { s.snapshotsMu.Lock() defer s.snapshotsMu.Unlock() sd, ok := s.snapshots[handle] if !ok { return nil, fmt.Errorf("%w: snapshot %d not found", ErrClientError, handle) } sd.refCount++ return sd, nil } func (s *Session) releaseSnapshot(handle SnapshotID) error { s.snapshotsMu.Lock() sd := s.snapshots[handle] if sd == nil { s.snapshotsMu.Unlock() return fmt.Errorf("%w: snapshot %d not found", ErrClientError, handle) } sd.refCount-- if sd.refCount <= 0 { delete(s.snapshots, handle) } else { sd = nil } s.snapshotsMu.Unlock() if sd != nil { sd.snapshot.Deref() } return nil } // checkerSetup holds the common context needed by handlers that require a type checker. type checkerSetup struct { sd *snapshotData snapshot SnapshotID program *compiler.Program checker *checker.Checker done func() projectID project.ID } func (setup checkerSetup) newSymbolResponse(sym *ast.Symbol) *SymbolResponse { return setup.sd.newSymbolResponse(sym, setup.projectID) } func (setup checkerSetup) newSignatureResponse(sig *checker.Signature) *SignatureResponse { return setup.sd.newSignatureResponse(setup.projectID, sig) } func (setup checkerSetup) newIndexInfoResponse(info *checker.IndexInfo) *IndexInfoResponse { if info == nil { return nil } result := &IndexInfoResponse{ KeyType: *setup.sd.newTypeResponse(setup.projectID, info.KeyType(), setup.checker), ValueType: *setup.sd.newTypeResponse(setup.projectID, info.ValueType(), setup.checker), IsReadonly: info.IsReadonly(), } if info.Declaration() != nil { result.Declaration = setup.sd.nodeHandleFrom(info.Declaration()) } return result } func (setup checkerSetup) resolveTypeHandle(id TypeID) (*checker.Type, error) { return setup.sd.resolveTypeHandle(setup.projectID, id) } func (setup checkerSetup) resolveSymbolHandle(ref SymbolReference) (*ast.Symbol, error) { if ref.Kind == SymbolOwnerKindSnapshot { if ref.Snapshot != setup.snapshot || ref.File != nil { return nil, fmt.Errorf("%w: snapshot symbol reference does not match the requested checker", ErrClientError) } return setup.sd.resolveSymbolHandle(ref.Id) } else if ref.Kind == SymbolOwnerKindFile { if ref.File == nil || ref.Snapshot != 0 || ref.Project != "" { return nil, fmt.Errorf("%w: invalid file symbol reference", ErrClientError) } sourceFile := setup.program.GetSourceFileByPath(ref.File.Path) if sourceFile == nil || newSourceFileDescriptor(sourceFile) != *ref.File { return nil, fmt.Errorf("%w: source file is not part of the requested program", ErrClientError) } symbol := getSourceFileSymbolIndex(sourceFile)[ref.Id] if symbol == nil { return nil, fmt.Errorf("%w: symbol handle %d not found in source file", ErrClientError, ref.Id) } return symbol, nil } else { return nil, fmt.Errorf("%w: invalid symbol reference kind %d", ErrClientError, ref.Kind) } } func (setup checkerSetup) resolveSignatureHandle(id SignatureID) (*checker.Signature, error) { return setup.sd.resolveSignatureHandle(setup.projectID, id) } // resolveLocation resolves an optional location, given either as a node handle or as a // file and position. Returns nil when neither is provided. func (setup checkerSetup) resolveLocation(handle NodeHandle, file *DocumentIdentifier, position *uint32) (*ast.Node, error) { if handle != "" { return setup.sd.resolveNodeHandle(setup.program, handle) } if file != nil && position != nil { sourceFile := setup.program.GetSourceFile(file.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, *file) } return astnav.GetTouchingPropertyName(sourceFile, sourceFile.GetPositionMap().UTF16ToUTF8(int(*position))), nil } return nil, nil } // setupChecker resolves snapshot, program, and type checker for a project. // Callers must defer setup.done() to release the checker. func (s *Session) setupChecker(ctx context.Context, snapshot SnapshotID, projectHandle project.ID) (checkerSetup, error) { sd, err := s.getSnapshotData(snapshot) if err != nil { return checkerSetup{}, err } program, err := sd.getProgram(projectHandle) if err != nil { return checkerSetup{}, err } c, done := program.GetTypeChecker(core.WithCheckerLifetime(ctx, core.CheckerLifetimeAPI)) return checkerSetup{ sd: sd, snapshot: snapshot, program: program, checker: c, done: done, projectID: projectHandle, }, nil } // setupLanguageService creates a LanguageService for the given snapshot/project. // Unlike setupChecker, this does NOT acquire a checker from the pool, so callers that // only need an LS (and not a Checker) can avoid blocking on / holding a pooled checker. // // The LS acquires its own checker internally (keyed by the ctx's checker lifetime). // If a handler returns symbol/type/signature handles the client may later re-query // on the API checker (e.g. completion with IncludeSymbol -> GetTypeOfSymbol), wrap // ctx with core.WithCheckerLifetime(ctx, core.CheckerLifetimeAPI) so those handles // are produced on the persistent API checker and stay resolvable. Only safe when the // LS operation acquires a checker exactly once; nested acquisitions (e.g. find-all- // references) would deadlock on the single-slot persistent checker. func (s *Session) setupLanguageService(snapshot *project.Snapshot, program *compiler.Program, projectHandle project.ID, activeFile string) (*ls.LanguageService, error) { proj := snapshot.ProjectCollection.GetProject(projectHandle) if proj == nil { return nil, fmt.Errorf("%w: project %s not found", ErrClientError, projectHandle) } return ls.NewLanguageService(proj.ID(), program, snapshot, activeFile), nil } // HandleRequest implements Handler. func (s *Session) HandleRequest(ctx context.Context, method string, params json.Value) (any, error) { if s != nil && s.withLocale != nil { ctx = s.withLocale(ctx) } // Handle simple methods that don't need param parsing switch method { case "echo": // Return raw binary for msgpack protocol compatibility if s.useBinaryResponses { return RawBinary(params), nil } return params, nil case "ping": return "pong", nil } parsed, err := unmarshalPayload(method, params) if err != nil { return nil, fmt.Errorf("%w: %w", ErrInvalidRequest, err) } switch method { case string(MethodBatchRequests): return s.handleBatchRequests(ctx, parsed.(*BatchRequestsParams)) case string(MethodRelease): return s.handleRelease(ctx, parsed.(*ReleaseParams)) case string(MethodReleaseSourceFile): return s.handleReleaseSourceFile(parsed.(*ReleaseSourceFileParams)) case string(MethodRetainSourceFile): return s.handleRetainSourceFile(parsed.(*RetainSourceFileParams)) case string(MethodGetCachedSourceFile): return s.handleGetCachedSourceFile(parsed.(*GetCachedSourceFileParams)) case string(MethodInitialize): return s.handleInitialize(ctx) case string(MethodCreateSnapshot): return s.handleCreateSnapshot(ctx, parsed.(*CreateSnapshotParams)) case string(MethodUpdateSnapshot): return s.handleUpdateSnapshot(ctx, parsed.(*UpdateSnapshotParams)) case string(MethodGetCurrentLanguageServerSnapshot): return s.handleGetCurrentLanguageServerSnapshot(ctx, parsed.(*GetCurrentLanguageServerSnapshotParams)) case string(MethodCreateModuleResolver): return s.handleCreateModuleResolver(parsed.(*CreateModuleResolverParams)) case string(MethodReleaseModuleResolver): return s.handleReleaseModuleResolver(parsed.(*ReleaseModuleResolverParams)) case string(MethodResolveModuleName): return s.handleResolveModuleName(ctx, parsed.(*ResolveModuleNameParams)) case string(MethodParseCommandLine): return s.handleParseCommandLine(ctx, parsed.(*ParseCommandLineParams)) case string(MethodReadConfigFile): return s.handleReadConfigFile(ctx, parsed.(*ReadConfigFileParams)) case string(MethodParseJsonConfigFile): return s.handleParseJsonConfigFileContent(ctx, parsed.(*ParseJsonConfigFileContentParams)) case string(MethodParseConfigFile): return s.handleParseConfigFile(ctx, parsed.(*ParseConfigFileParams)) case string(MethodCreateBuildOrchestrator): return s.handleCreateBuildOrchestrator(ctx, parsed.(*CreateBuildOrchestratorParams)) case string(MethodDisposeBuildOrchestrator): return s.handleDisposeBuildOrchestrator(ctx, parsed.(*DisposeBuildOrchestratorParams)) case string(MethodBuild): return s.handleBuild(ctx, parsed.(*BuildParams)) case string(MethodBuildReferences): return s.handleBuildReferences(ctx, parsed.(*BuildParams)) case string(MethodCleanBuild): return s.handleCleanBuild(ctx, parsed.(*CleanBuildParams)) case string(MethodCleanReferences): return s.handleCleanReferences(ctx, parsed.(*CleanBuildParams)) case string(MethodCreateSourceFile): return s.handleCreateSourceFile(ctx, parsed.(*CreateSourceFileParams)) case string(MethodCreateSourceFileFromFile): return s.handleCreateSourceFileFromFile(ctx, parsed.(*CreateSourceFileFromFileParams)) case string(MethodTranspileModule): return s.handleTranspile(ctx, parsed.(*TranspileParams), false) case string(MethodTranspileModuleFromFile): return s.handleTranspileFromFile(ctx, parsed.(*TranspileFromFileParams), false) case string(MethodTranspileDeclaration): return s.handleTranspile(ctx, parsed.(*TranspileParams), true) case string(MethodTranspileDeclarationFromFile): return s.handleTranspileFromFile(ctx, parsed.(*TranspileFromFileParams), true) case string(MethodGetDefaultProjectForFile): return s.handleGetDefaultProjectForFile(ctx, parsed.(*GetDefaultProjectForFileParams)) case string(MethodGetSourceFile): return s.handleGetSourceFile(ctx, parsed.(*GetSourceFileParams)) case string(MethodGetSourceFileNames): return s.handleGetSourceFileNames(ctx, parsed.(*GetSourceFileNamesParams)) case string(MethodGetSourceFileMetadata): return s.handleGetSourceFileMetadata(ctx, parsed.(*GetSourceFileParams)) case string(MethodGetModeForUsageLocation): return s.handleGetModeForUsageLocation(ctx, parsed.(*GetModeForUsageLocationParams)) case string(MethodGetModeForResolutionAtIndex): return s.handleGetModeForResolutionAtIndex(ctx, parsed.(*GetModeForResolutionAtIndexParams)) case string(MethodGetResolvedModule): return s.handleGetResolvedModule(ctx, parsed.(*GetResolvedModuleParams)) case string(MethodGetResolvedModuleFromModuleSpecifier): return s.handleGetResolvedModuleFromModuleSpecifier(ctx, parsed.(*GetResolvedModuleFromModuleSpecifierParams)) case string(MethodGetResolvedTypeReferenceDirective): return s.handleGetResolvedTypeReferenceDirective(ctx, parsed.(*GetResolvedTypeReferenceDirectiveParams)) case string(MethodGetResolvedTypeReferenceDirectiveFromReference): return s.handleGetResolvedTypeReferenceDirectiveFromReference(ctx, parsed.(*GetResolvedTypeReferenceDirectiveFromReferenceParams)) case string(MethodGetConfigFileNames): return s.handleGetConfigFileNames(ctx, parsed.(*GetProjectDiagnosticsParams)) case string(MethodGetConfigSourceFile): return s.handleGetConfigSourceFile(ctx, parsed.(*GetSourceFileParams)) case string(MethodGetSymbolAtPosition): return s.handleGetSymbolAtPosition(ctx, parsed.(*GetSymbolAtPositionParams)) case string(MethodGetSymbolsAtPositions): return s.handleGetSymbolsAtPositions(ctx, parsed.(*GetSymbolsAtPositionsParams)) case string(MethodGetSymbolAtLocation): return s.handleGetSymbolAtLocation(ctx, parsed.(*GetSymbolAtLocationParams)) case string(MethodGetSymbolsAtLocations): return s.handleGetSymbolsAtLocations(ctx, parsed.(*GetSymbolsAtLocationsParams)) case string(MethodGetSymbolOfSourceFile): return s.handleGetSymbolOfSourceFile(ctx, parsed.(*GetSymbolOfSourceFileParams)) case string(MethodGetSymbolsOfSourceFiles): return s.handleGetSymbolsOfSourceFiles(ctx, parsed.(*GetSymbolsOfSourceFilesParams)) case string(MethodGetTypeOfSymbol): return s.handleGetTypeOfSymbol(ctx, parsed.(*GetTypeOfSymbolParams)) case string(MethodGetTypesOfSymbols): return s.handleGetTypesOfSymbols(ctx, parsed.(*GetTypesOfSymbolsParams)) case string(MethodGetDeclaredTypeOfSymbol): return s.handleGetDeclaredTypeOfSymbol(ctx, parsed.(*GetTypeOfSymbolParams)) case string(MethodGetNonMissingTypeOfSymbol): return s.handleGetNonMissingTypeOfSymbol(ctx, parsed.(*GetTypeOfSymbolParams)) case string(MethodResolveName): return s.handleResolveName(ctx, parsed.(*ResolveNameParams)) case string(MethodGetSymbolsInScope): return s.handleGetSymbolsInScope(ctx, parsed.(*GetSymbolsInScopeParams)) case string(MethodGetSignaturesOfType): return s.handleGetSignaturesOfType(ctx, parsed.(*GetSignaturesOfTypeParams)) case string(MethodGetResolvedSignature): return s.handleGetResolvedSignature(ctx, parsed.(*GetResolvedSignatureParams)) case string(MethodGetTypeAtLocation): return s.handleGetTypeAtLocation(ctx, parsed.(*GetTypeAtLocationParams)) case string(MethodGetTypeAtLocations): return s.handleGetTypeAtLocations(ctx, parsed.(*GetTypeAtLocationsParams)) case string(MethodGetTypeAtPosition): return s.handleGetTypeAtPosition(ctx, parsed.(*GetTypeAtPositionParams)) case string(MethodGetTypesAtPositions): return s.handleGetTypesAtPositions(ctx, parsed.(*GetTypesAtPositionsParams)) case string(MethodGetParentOfSymbol): return s.handleGetParentOfSymbol(ctx, parsed.(*GetSymbolPropertyParams)) case string(MethodGetMembersOfSymbol): return s.handleGetMembersOfSymbol(ctx, parsed.(*GetSymbolPropertyParams)) case string(MethodGetExportsOfSymbol): return s.handleGetExportsOfSymbol(ctx, parsed.(*GetSymbolPropertyParams)) case string(MethodGetExportSymbolOfSymbol): return s.handleGetExportSymbolOfSymbol(ctx, parsed.(*GetSymbolPropertyParams)) case string(MethodGetSymbolOfType): return s.handleGetSymbolOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTargetOfType): return s.handleGetTargetOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetFreshTypeOfType): return s.handleGetFreshTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetRegularTypeOfType): return s.handleGetRegularTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTypesOfType): return s.handleGetTypesOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTypeParametersOfType): return s.handleGetTypeParametersOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetOuterTypeParametersOfType): return s.handleGetOuterTypeParametersOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetLocalTypeParametersOfType): return s.handleGetLocalTypeParametersOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetThisTypeOfType): return s.handleGetThisTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetAliasTypeArgumentsOfType): return s.handleGetAliasTypeArgumentsOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetAliasSymbolOfType): return s.handleGetAliasSymbolOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetObjectTypeOfType): return s.handleGetObjectTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetIndexTypeOfType): return s.handleGetIndexTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetCheckTypeOfType): return s.handleGetCheckTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetExtendsTypeOfType): return s.handleGetExtendsTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetBaseTypeOfType): return s.handleGetBaseTypeOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetConstraintOfType): return s.handleGetConstraintOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTypeParameterOfMappedType): return s.handleGetTypeParameterOfMappedType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetConstraintTypeOfMappedType): return s.handleGetConstraintTypeOfMappedType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetNameTypeOfMappedType): return s.handleGetNameTypeOfMappedType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTemplateTypeOfMappedType): return s.handleGetTemplateTypeOfMappedType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTrueTypeOfConditionalType): return s.handleGetTrueTypeOfConditionalType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetFalseTypeOfConditionalType): return s.handleGetFalseTypeOfConditionalType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTypeParametersOfSignature): return s.handleGetTypeParametersOfSignature(ctx, parsed.(*GetSignaturePropertyParams)) case string(MethodGetParametersOfSignature): return s.handleGetParametersOfSignature(ctx, parsed.(*GetSignaturePropertyParams)) case string(MethodGetThisParameterOfSignature): return s.handleGetThisParameterOfSignature(ctx, parsed.(*GetSignaturePropertyParams)) case string(MethodGetTargetOfSignature): return s.handleGetTargetOfSignature(ctx, parsed.(*GetSignaturePropertyParams)) case string(MethodGetContextualType): return s.handleGetContextualType(ctx, parsed.(*GetContextualTypeParams)) case string(MethodGetContextualTypeForArgument): return s.handleGetContextualTypeForArgument(ctx, parsed.(*GetContextualTypeForArgumentParams)) case string(MethodGetAwaitedType): return s.handleGetAwaitedType(ctx, parsed.(*CheckerTypeParams)) case string(MethodGetBaseTypeOfLiteralType): return s.handleGetBaseTypeOfLiteralType(ctx, parsed.(*GetBaseTypeOfLiteralTypeParams)) case string(MethodGetNonNullableType): return s.handleGetNonNullableType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTypeFromTypeNode): return s.handleGetTypeFromTypeNode(ctx, parsed.(*GetTypeFromTypeNodeParams)) case string(MethodGetWidenedType): return s.handleGetWidenedType(ctx, parsed.(*GetWidenedTypeParams)) case string(MethodGetParameterType): return s.handleGetParameterType(ctx, parsed.(*GetParameterTypeParams)) case string(MethodGetTypeParameterAtPosition): return s.handleGetTypeParameterAtPosition(ctx, parsed.(*GetParameterTypeParams)) case string(MethodIsArrayLikeType): return s.handleIsArrayLikeType(ctx, parsed.(*IsArrayLikeTypeParams)) case string(MethodIsTypeAssignableTo): return s.handleIsTypeAssignableTo(ctx, parsed.(*IsTypeAssignableToParams)) case string(MethodGetShorthandAssignmentValueSymbol): return s.handleGetShorthandAssignmentValueSymbol(ctx, parsed.(*GetTypeAtLocationParams)) case string(MethodGetTypeOfSymbolAtLocation): return s.handleGetTypeOfSymbolAtLocation(ctx, parsed.(*GetTypeOfSymbolAtLocationParams)) case string(MethodTypeToTypeNode): return s.handleTypeToTypeNode(ctx, parsed.(*TypeToTypeNodeParams)) case string(MethodSignatureToSignatureDeclaration): return s.handleSignatureToSignatureDeclaration(ctx, parsed.(*SignatureToSignatureDeclarationParams)) case string(MethodTypeToString): return s.handleTypeToString(ctx, parsed.(*TypeToTypeNodeParams)) case string(MethodPrintNode): return s.handlePrintNode(ctx, parsed.(*PrintNodeParams)) case string(MethodFormatNodeForInsertion): return s.handleFormatNodeForInsertion(ctx, parsed.(*FormatNodeForInsertionParams)) case string(MethodEmit): return s.handleEmit(ctx, parsed.(*EmitParams)) case string(MethodEmitToString): return s.handleEmitToString(ctx, parsed.(*EmitParams)) case string(MethodGetJavaScriptEmit): return s.handleSelectedFilesEmit(ctx, parsed.(*SelectedFilesEmitParams), compiler.EmitOnlyJs) case string(MethodGetDeclarationEmit): return s.handleSelectedFilesEmit(ctx, parsed.(*SelectedFilesEmitParams), compiler.EmitOnlyDts) case string(MethodIsContextSensitive): return s.handleIsContextSensitive(ctx, parsed.(*GetContextualTypeParams)) case string(MethodGetReturnTypeOfSignature): return s.handleGetReturnTypeOfSignature(ctx, parsed.(*GetSignaturePropertyParams)) case string(MethodGetRestTypeOfSignature): return s.handleGetRestTypeOfSignature(ctx, parsed.(*CheckerSignatureParams)) case string(MethodGetTypePredicateOfSignature): return s.handleGetTypePredicateOfSignature(ctx, parsed.(*CheckerSignatureParams)) case string(MethodGetBaseTypes): return s.handleGetBaseTypes(ctx, parsed.(*CheckerTypeParams)) case string(MethodGetPropertiesOfType): return s.handleGetPropertiesOfType(ctx, parsed.(*CheckerTypeParams)) case string(MethodGetApparentPropertiesOfType): return s.handleGetApparentPropertiesOfType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetApparentType): return s.handleGetApparentType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetReducedType): return s.handleGetReducedType(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetPropertyOfType): return s.handleGetPropertyOfType(ctx, parsed.(*GetPropertyOfTypeParams)) case string(MethodGetTypeOfPropertyOfType): return s.handleGetTypeOfPropertyOfType(ctx, parsed.(*GetPropertyOfTypeParams)) case string(MethodGetIndexInfoOfType): return s.handleGetIndexInfoOfType(ctx, parsed.(*GetIndexInfoOfTypeParams)) case string(MethodGetIndexInfosOfType): return s.handleGetIndexInfosOfType(ctx, parsed.(*CheckerTypeParams)) case string(MethodGetConstraintOfTypeParameter): return s.handleGetConstraintOfTypeParameter(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetBaseConstraintOfType): return s.handleGetBaseConstraintOfType(ctx, parsed.(*CheckerTypeParams)) case string(MethodGetDefaultFromTypeParameter): return s.handleGetDefaultFromTypeParameter(ctx, parsed.(*GetTypePropertyParams)) case string(MethodGetTypeArguments): return s.handleGetTypeArguments(ctx, parsed.(*CheckerTypeParams)) case string(MethodGetImportAdderEdits): return s.handleGetImportAdderEdits(ctx, parsed.(*GetImportAdderEditsParams)) case string(MethodGetConstantValue): return s.handleGetConstantValue(ctx, parsed.(*CheckerNodeParams)) case string(MethodGetSignatureFromDeclaration): return s.handleGetSignatureFromDeclaration(ctx, parsed.(*CheckerNodeParams)) case string(MethodGetExportSpecifierLocalTarget): return s.handleGetExportSpecifierLocalTargetSymbol(ctx, parsed.(*CheckerNodeParams)) case string(MethodGetAliasedSymbol): return s.handleGetAliasedSymbol(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetImmediateAliasedSymbol): return s.handleGetImmediateAliasedSymbol(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetTargetSymbol): return s.handleMethodGetTargetSymbol(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetExportSymbolOfSymbolForChecker): return s.handleGetExportSymbolOfSymbolForChecker(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetFullyQualifiedName): return s.handleGetFullyQualifiedName(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetExportsOfModule): return s.handleGetExportsOfModule(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetMemberInModuleExports): return s.handleGetMemberInModuleExports(ctx, parsed.(*GetMemberInModuleExportsParams)) case string(MethodGetJSDocTags): return s.handleGetJSDocTags(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetDocumentationComment): return s.handleGetDocumentationComment(ctx, parsed.(*CheckerSymbolParams)) case string(MethodIsArrayType): return s.handleIsArrayType(ctx, parsed.(*CheckerTypeParams)) case string(MethodIsReadonlySymbol): return s.handleIsReadonlySymbol(ctx, parsed.(*CheckerSymbolParams)) case string(MethodGetAnyType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetAnyType) case string(MethodGetStringType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetStringType) case string(MethodGetNumberType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetNumberType) case string(MethodGetBooleanType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetBooleanType) case string(MethodGetVoidType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetVoidType) case string(MethodGetUndefinedType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetUndefinedType) case string(MethodGetNullType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetNullType) case string(MethodGetNeverType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetNeverType) case string(MethodGetUnknownType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetUnknownType) case string(MethodGetBigIntType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetBigIntType) case string(MethodGetESSymbolType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetESSymbolType) case string(MethodGetNonPrimitiveType): return s.handleGetIntrinsicType(ctx, parsed.(*GetIntrinsicTypeParams), (*checker.Checker).GetNonPrimitiveType) case string(MethodGetWellKnownSymbols): return s.handleGetWellKnownSymbols(ctx, parsed.(*GetIntrinsicTypeParams)) case string(MethodGetWellKnownSignatures): return s.handleGetWellKnownSignatures(ctx, parsed.(*GetIntrinsicTypeParams)) case string(MethodGetSyntacticDiagnostics): return s.handleGetSyntacticDiagnostics(ctx, parsed.(*GetDiagnosticsParams)) case string(MethodGetBindDiagnostics): return s.handleGetBindDiagnostics(ctx, parsed.(*GetDiagnosticsParams)) case string(MethodGetSemanticDiagnostics): return s.handleGetSemanticDiagnostics(ctx, parsed.(*GetDiagnosticsParams)) case string(MethodGetSuggestionDiagnostics): return s.handleGetSuggestionDiagnostics(ctx, parsed.(*GetDiagnosticsParams)) case string(MethodGetDeclarationDiagnostics): return s.handleGetDeclarationDiagnostics(ctx, parsed.(*GetDiagnosticsParams)) case string(MethodGetProgramDiagnostics): return s.handleGetProgramDiagnostics(ctx, parsed.(*GetProjectDiagnosticsParams)) case string(MethodGetGlobalDiagnostics): return s.handleGetGlobalDiagnostics(ctx, parsed.(*GetProjectDiagnosticsParams)) case string(MethodGetConfigFileParsingDiagnostics): return s.handleGetConfigFileParsingDiagnostics(ctx, parsed.(*GetProjectDiagnosticsParams)) case string(MethodStartCPUProfile): return s.handleStartCPUProfile(ctx, parsed.(*ProfileParams)) case string(MethodStopCPUProfile): return s.handleStopCPUProfile(ctx) case string(MethodSaveHeapProfile): return s.handleSaveHeapProfile(ctx, parsed.(*ProfileParams)) case string(MethodGetReferencesToSymbolInFile): return s.handleGetReferencesToSymbolInFile(ctx, parsed.(*GetReferencesToSymbolInFileParams)) case string(MethodGetReferencedSymbolsForNode): return s.handleGetReferencedSymbolsForNode(ctx, parsed.(*GetReferencedSymbolsForNodeParams)) case string(MethodGetSignatureUsages): return s.handleGetSignatureUsages(ctx, parsed.(*GetSignatureUsagesParams)) case string(MethodGetCompletionsAtPosition): return s.handleGetCompletionsAtPosition(ctx, parsed.(*GetCompletionsAtPositionParams)) default: return nil, fmt.Errorf("unknown method: %s", method) } } func (s *Session) handleBatchRequests(ctx context.Context, params *BatchRequestsParams) (*BatchRequestsResponse, error) { if params.ContinuationToken != "" { value, ok := s.batchResponsePages.LoadAndDelete(params.ContinuationToken) if !ok { return nil, fmt.Errorf("%w: invalid batch continuation token", ErrClientError) } page := value.(batchResponsePage) return s.paginateBatchResponses(page, nil, params.MaxResponseBytesPerPage) } responses := make([]BatchResponse, len(params.Requests)) for i, request := range params.Requests { responses[i] = s.handleBatchRequest(ctx, request) } if s == nil { return &BatchRequestsResponse{Responses: responses}, nil } page, err := newBatchResponsePage(responses) if err != nil { return nil, err } return s.paginateBatchResponses(page, responses, params.MaxResponseBytesPerPage) } func newBatchResponsePage(responses []BatchResponse) (batchResponsePage, error) { encodedResponses := make([]json.Value, len(responses)) for i := range responses { encoded, err := json.Marshal(&responses[i]) if err != nil { return batchResponsePage{}, err } encodedResponses[i] = encoded } return batchResponsePage{encodedResponses: encodedResponses}, nil } func (s *Session) paginateBatchResponses(page batchResponsePage, responses []BatchResponse, maxResponseBytesPerPage int) (*BatchRequestsResponse, error) { if maxResponseBytesPerPage <= 0 { maxResponseBytesPerPage = DefaultMaxResponseBytesPerPage } encodedLength := len(`{"responses":[]}`) pageLength := 0 for _, encoded := range page.encodedResponses { additionalLength := len(encoded) if pageLength > 0 { additionalLength++ } if pageLength > 0 && encodedLength+additionalLength > maxResponseBytesPerPage { break } encodedLength += additionalLength pageLength++ } if pageLength == len(page.encodedResponses) { return &BatchRequestsResponse{ Responses: responses, encodedResponses: page.encodedResponses, }, nil } continuationToken := fmt.Sprintf("%s-%d", s.id, s.nextBatchResponsePageID.Add(1)) continuationLength := len(`,"continuationToken":""`) + len(continuationToken) for pageLength > 1 && encodedLength+continuationLength > maxResponseBytesPerPage { encodedLength -= len(page.encodedResponses[pageLength-1]) + 1 pageLength-- } currentResponses := page.encodedResponses[:pageLength] remainingResponses := page.encodedResponses[pageLength:] response := &BatchRequestsResponse{ ContinuationToken: continuationToken, encodedResponses: currentResponses, } if responses != nil { response.Responses = responses[:pageLength] } s.batchResponsePages.Store(continuationToken, batchResponsePage{ encodedResponses: remainingResponses, }) return response, nil } func (s *Session) handleBatchRequest(ctx context.Context, request BatchRequest) (response BatchResponse) { response.Method = request.Method if request.Method == MethodBatchRequests { response.Error = fmt.Sprintf("%s: batchRequests cannot be nested", ErrInvalidRequest) return response } defer func() { if recovered := recover(); recovered != nil { response.Result = nil response.Error = fmt.Sprintf("panic: %v\n%s", recovered, debug.Stack()) } }() var err error response.Result, err = s.HandleRequest(ctx, string(request.Method), request.Params) if err != nil { response.Error = err.Error() } if data, ok := response.Result.(RawBinary); ok && isSourceFileResponseMethod(request.Method) { if data == nil { response.Result = nil } else { response.Result = &SourceFileResponse{Data: base64.StdEncoding.EncodeToString(data)} } } return response } func isSourceFileResponseMethod(method Method) bool { switch method { case MethodCreateSourceFile, MethodCreateSourceFileFromFile, MethodGetSourceFile, MethodGetCachedSourceFile, MethodGetConfigSourceFile, MethodTypeToTypeNode, MethodSignatureToSignatureDeclaration: return true default: return false } } func (s *Session) handleStartCPUProfile(_ context.Context, params *ProfileParams) (any, error) { if params == nil || params.Dir == "" { return nil, fmt.Errorf("%w: dir is required", ErrClientError) } if err := s.cpuProfiler.StartCPUProfile(params.Dir); err != nil { return nil, fmt.Errorf("%w: failed to start CPU profile: %w", ErrClientError, err) } return nil, nil } func (s *Session) handleStopCPUProfile(_ context.Context) (*ProfileResult, error) { filePath, err := s.cpuProfiler.StopCPUProfile() if err != nil { return nil, fmt.Errorf("%w: failed to stop CPU profile: %w", ErrClientError, err) } return &ProfileResult{File: filePath}, nil } func (s *Session) handleSaveHeapProfile(_ context.Context, params *ProfileParams) (*ProfileResult, error) { if params == nil || params.Dir == "" { return nil, fmt.Errorf("%w: dir is required", ErrClientError) } filePath, err := pprof.SaveHeapProfile(params.Dir) if err != nil { return nil, fmt.Errorf("%w: failed to save heap profile: %w", ErrClientError, err) } return &ProfileResult{File: filePath}, nil } // HandleNotification implements Handler. func (s *Session) HandleNotification(ctx context.Context, method string, params json.Value) error { // TODO: Implement notification handling return nil } func (s *Session) handleInitialize(ctx context.Context) (*InitializeResponse, error) { return &InitializeResponse{ UseCaseSensitiveFileNames: s.useCaseSensitiveFileNames(), CurrentDirectory: s.GetCurrentDirectory(), }, nil } // handleCreateSnapshot creates a new independent snapshot. func (s *Session) handleCreateSnapshot(ctx context.Context, params *CreateSnapshotParams) (*CreateSnapshotResponse, error) { apiRequest, err := s.toAPISnapshotRequest(ctx, ¶ms.SnapshotRequestChangesParams) if err != nil { return nil, err } openState := s.reconcileSnapshotOpens(apiRequest, snapshotOpenState{}) fileChanges := s.toFileChangeSummary(params.FileNotifications) var snapshotFileSystem vfs.FS if params.FileSystem != nil { fileSystem, fileSystemErr := requestfilesystem.NewForUpdate(params.FileSystem, s.FS(), s.GetCurrentDirectory(), &fileChanges) if fileSystemErr != nil { return nil, fmt.Errorf("%w: %w", ErrClientError, fileSystemErr) } snapshotFileSystem = fileSystem apiRequest.FileSystem = fileSystem apiRequest.ReplaceFileSystem = params.FileSystem.Kind == requestfilesystem.KindFull } root := s.snapshotHost.NewRootSnapshot() snapshot, err := s.snapshotHost.CloneSnapshot(ctx, root, fileChanges, apiRequest) root.Deref() if err != nil { snapshot.Deref() return nil, fmt.Errorf("%w: failed to create snapshot: %w", ErrClientError, err) } if err := moduleResolutionError(snapshot); err != nil { snapshot.Deref() return nil, err } response := s.createSnapshotResponse(snapshot, nil, ¶ms.SnapshotRequestChangesParams) s.registerSnapshot(snapshot, openState, snapshotFileSystem) return response, nil } func (s *Session) handleUpdateSnapshot(ctx context.Context, params *UpdateSnapshotParams) (*CreateSnapshotResponse, error) { baseSD, err := s.retainSnapshotData(params.Snapshot) if err != nil { return nil, err } defer func() { _ = s.releaseSnapshot(params.Snapshot) }() changes := params.Changes if changes == nil { changes = &CreateSnapshotParams{} } apiRequest, err := s.toAPISnapshotRequest(ctx, &changes.SnapshotRequestChangesParams) if err != nil { return nil, err } openState := s.reconcileSnapshotOpens(apiRequest, snapshotOpenState{openProjects: baseSD.openProjects, openFiles: baseSD.openFiles}) fileChanges := s.toFileChangeSummary(changes.FileNotifications) snapshotFileSystem := baseSD.fileSystem if changes.FileSystem != nil { baseFileSystem := snapshotFileSystem if baseFileSystem == nil { baseFileSystem = s.FS() } fileSystem, fileSystemErr := requestfilesystem.NewForUpdate(changes.FileSystem, baseFileSystem, s.GetCurrentDirectory(), &fileChanges) if fileSystemErr != nil { return nil, fmt.Errorf("%w: %w", ErrClientError, fileSystemErr) } snapshotFileSystem = fileSystem } if snapshotFileSystem != nil { apiRequest.FileSystem = snapshotFileSystem apiRequest.ReplaceFileSystem = changes.FileSystem != nil && changes.FileSystem.Kind == requestfilesystem.KindFull } snapshot, err := s.snapshotHost.CloneSnapshot(ctx, baseSD.snapshot, fileChanges, apiRequest) if err != nil { snapshot.Deref() return nil, fmt.Errorf("%w: failed to update snapshot: %w", ErrClientError, err) } if err := moduleResolutionError(snapshot); err != nil { snapshot.Deref() return nil, err } response := s.createSnapshotResponse(snapshot, baseSD.snapshot, &changes.SnapshotRequestChangesParams) s.registerSnapshot(snapshot, openState, snapshotFileSystem) return response, nil } func (s *Session) toAPISnapshotRequest(ctx context.Context, changes *SnapshotRequestChangesParams) (*project.APISnapshotRequest, error) { apiRequest := &project.APISnapshotRequest{} for _, p := range changes.OpenProjects { configFileName := p.ToAbsoluteFileName(s.GetCurrentDirectory()) configuredProjectID, ok := project.ParseConfiguredProjectID(s.toPath(configFileName)) if !ok { return nil, fmt.Errorf("%w: invalid configured project ID: %s", ErrClientError, configFileName) } if apiRequest.EnsurePrograms == nil { apiRequest.EnsurePrograms = collections.NewSetWithSizeHint[project.ID](len(changes.OpenProjects)) } apiRequest.EnsurePrograms.Add(configuredProjectID.AsID()) if apiRequest.OpenProjects == nil { apiRequest.OpenProjects = collections.NewSetWithSizeHint[string](len(changes.OpenProjects)) } apiRequest.OpenProjects.Add(configFileName) } for _, p := range changes.CloseProjects { configPath := s.toPath(p.ToAbsoluteFileName(s.GetCurrentDirectory())) if apiRequest.CloseProjects == nil { apiRequest.CloseProjects = collections.NewSetWithSizeHint[tspath.Path](len(changes.CloseProjects)) } apiRequest.CloseProjects.Add(configPath) } for _, f := range changes.OpenFiles { fileName := f.ToAbsoluteFileName(s.GetCurrentDirectory()) path := s.toPath(fileName) if apiRequest.OpenFiles == nil { apiRequest.OpenFiles = make(map[tspath.Path]string, len(changes.OpenFiles)) apiRequest.EnsureFiles = make(map[tspath.Path]string, len(changes.OpenFiles)) } if _, ok := apiRequest.OpenFiles[path]; !ok { apiRequest.OpenFiles[path] = fileName apiRequest.EnsureFiles[path] = fileName } } for _, f := range changes.CloseFiles { path := s.toPath(f.ToURI(s.GetCurrentDirectory()).FileName()) if apiRequest.CloseFiles == nil { apiRequest.CloseFiles = collections.NewSetWithSizeHint[tspath.Path](len(changes.CloseFiles)) } apiRequest.CloseFiles.Add(path) } apiRequest.CreatePrograms = make([]*project.APICreateProgramRequest, len(changes.CreatePrograms)) for i, programParams := range changes.CreatePrograms { if programParams == nil { return nil, fmt.Errorf("%w: createPrograms[%d] must not be null", ErrClientError, i) } rootFileNames := make([]string, len(programParams.RootFiles)) for j, rootFile := range programParams.RootFiles { rootFileNames[j] = rootFile.ToAbsoluteFileName(s.GetCurrentDirectory()) } request := &project.APICreateProgramRequest{ RootFileNames: rootFileNames, CompilerOptions: &programParams.CompilerOptions, } if programParams.Options != nil { request.ProjectReferences = programParams.Options.ProjectReferences request.ConfigFileParsingDiagnostics = core.Map(programParams.Options.ConfigFileParsingDiagnostics, func(d *DiagnosticResponse) *ast.Diagnostic { return d.ToDiagnostic() }) factory, err := s.moduleResolverFactory(programParams.Options) if err != nil { return nil, err } request.ModuleResolverFactory = factory request.ModuleResolverID = uint64(programParams.Options.ModuleResolver) } apiRequest.CreatePrograms[i] = request } apiRequest.ReconfigurePrograms = make([]*project.APIReconfigureProgramRequest, len(changes.ReconfigurePrograms)) reconfiguredProgramIDs := collections.Set[project.SyntheticProjectID]{} for i, programParams := range changes.ReconfigurePrograms { if programParams == nil { return nil, fmt.Errorf("%w: reconfigurePrograms[%d] must not be null", ErrClientError, i) } programID, ok := project.ParseSyntheticProjectID(string(programParams.Id)) if !ok { return nil, fmt.Errorf("%w: invalid synthetic project handle: %s", ErrClientError, programParams.Id) } if reconfiguredProgramIDs.Has(programID) { return nil, fmt.Errorf("%w: synthetic program reconfigured more than once: %s", ErrClientError, programID) } reconfiguredProgramIDs.Add(programID) rootFileNames := make([]string, len(programParams.RootFiles)) for j, rootFile := range programParams.RootFiles { rootFileNames[j] = rootFile.ToAbsoluteFileName(s.GetCurrentDirectory()) } request := &project.APIReconfigureProgramRequest{ ProgramID: programID, RootFileNames: rootFileNames, CompilerOptions: &programParams.CompilerOptions, } if programParams.Options != nil { request.ProjectReferences = programParams.Options.ProjectReferences request.ConfigFileParsingDiagnostics = core.Map(programParams.Options.ConfigFileParsingDiagnostics, func(d *DiagnosticResponse) *ast.Diagnostic { return d.ToDiagnostic() }) factory, err := s.moduleResolverFactory(programParams.Options) if err != nil { return nil, err } request.ModuleResolverFactory = factory request.ModuleResolverID = uint64(programParams.Options.ModuleResolver) } apiRequest.ReconfigurePrograms[i] = request } if len(changes.RemovePrograms) > 0 { apiRequest.RemovePrograms = collections.NewSetWithSizeHint[project.SyntheticProjectID](len(changes.RemovePrograms)) } for _, programID := range changes.RemovePrograms { if reconfiguredProgramIDs.Has(programID) { return nil, fmt.Errorf("%w: synthetic program cannot be reconfigured and removed: %s", ErrClientError, programID) } apiRequest.RemovePrograms.Add(programID) } if changes.EnsurePrograms != nil { apiRequest.EnsureAllPrograms = changes.EnsurePrograms.All if len(changes.EnsurePrograms.Projects) > 0 && apiRequest.EnsurePrograms == nil { apiRequest.EnsurePrograms = collections.NewSetWithSizeHint[project.ID](len(changes.EnsurePrograms.Projects)) } for _, program := range changes.EnsurePrograms.Projects { apiRequest.EnsurePrograms.Add(program) } } return apiRequest, nil } type languageServerSnapshotUpdate struct { request *project.APISnapshotRequest openState snapshotOpenState } func (s *Session) toLanguageServerSnapshotUpdate(ctx context.Context, changes *SnapshotRequestChangesParams) (*languageServerSnapshotUpdate, error) { apiRequest, err := s.toAPISnapshotRequest(ctx, changes) if err != nil { return nil, err } update := &languageServerSnapshotUpdate{ request: apiRequest, openState: s.reconcileSnapshotOpens(apiRequest, snapshotOpenState{ openProjects: s.openProjects, openFiles: s.openFiles, }), } for programID := range apiRequest.RemovePrograms.Keys() { if !s.createdPrograms.Has(programID) { apiRequest.RemovePrograms.Delete(programID) } } for _, reconfigure := range apiRequest.ReconfigurePrograms { if !s.createdPrograms.Has(reconfigure.ProgramID) { return nil, fmt.Errorf("%w: synthetic program is not owned by this API session: %s", ErrClientError, reconfigure.ProgramID) } } return update, nil } func (u *languageServerSnapshotUpdate) commit(s *Session, snapshot *project.Snapshot) { s.openProjects = *u.openState.openProjects.Clone() s.openFiles = *u.openState.openFiles.Clone() for programID := range u.request.RemovePrograms.Keys() { s.createdPrograms.Delete(programID) } for _, program := range snapshot.CreatedPrograms() { programID, ok := program.ID().Synthetic() if !ok { panic(fmt.Sprintf("created program has non-synthetic project ID: %s", program.ID())) } s.createdPrograms.Add(programID) } } type snapshotOpenState struct { openProjects collections.Set[tspath.Path] openFiles collections.Set[tspath.Path] } func (s *Session) reconcileSnapshotOpens(apiRequest *project.APISnapshotRequest, base snapshotOpenState) snapshotOpenState { state := snapshotOpenState{ openProjects: *base.openProjects.Clone(), openFiles: *base.openFiles.Clone(), } for path := range apiRequest.CloseProjects.Keys() { if state.openProjects.Has(path) { state.openProjects.Delete(path) } else { apiRequest.CloseProjects.Delete(path) } } for configFileName := range apiRequest.OpenProjects.Keys() { path := s.toPath(configFileName) if state.openProjects.Has(path) { apiRequest.OpenProjects.Delete(configFileName) } else { state.openProjects.Add(path) } } for path := range apiRequest.CloseFiles.Keys() { if state.openFiles.Has(path) { state.openFiles.Delete(path) } else { apiRequest.CloseFiles.Delete(path) } } for path := range apiRequest.OpenFiles { if state.openFiles.Has(path) { delete(apiRequest.OpenFiles, path) } else { state.openFiles.Add(path) } } return state } func (s *Session) registerSnapshot(snapshot *project.Snapshot, openState snapshotOpenState, fileSystem vfs.FS) { // If the same snapshot ID is returned (no changes), we increment the ref count // so each client-side Snapshot can be disposed independently. handle := snapshotHandle(snapshot) s.snapshotsMu.Lock() sd, exists := s.snapshots[handle] if exists { // Same snapshot already stored — release the caller's ref since // the stored snapshot already has one, and bump the API refcount. snapshot.Deref() sd.refCount++ } else { sd = &snapshotData{ handle: handle, snapshot: snapshot, fileSystem: fileSystem, refCount: 1, openProjects: *openState.openProjects.Clone(), openFiles: *openState.openFiles.Clone(), symbolRegistry: make(map[SymbolID]*ast.Symbol), symbolCanonicalProjects: make(map[SymbolID]project.ID), projectRegistries: make(map[project.ID]*projectRegistryData), } s.snapshots[handle] = sd } s.snapshotsMu.Unlock() } func (s *Session) handleGetCurrentLanguageServerSnapshot(ctx context.Context, params *GetCurrentLanguageServerSnapshotParams) (*CreateSnapshotResponse, error) { if s.projectSession == nil { return nil, fmt.Errorf("%w: getCurrentLanguageServerSnapshot requires an LSP-connected API session", ErrClientError) } var baseSnapshot *project.Snapshot if params.BaseSnapshot != 0 { baseSD, err := s.retainSnapshotData(params.BaseSnapshot) if err != nil { return nil, err } defer func() { _ = s.releaseSnapshot(params.BaseSnapshot) }() baseSnapshot = baseSD.snapshot } s.languageServerUpdateMu.Lock() defer s.languageServerUpdateMu.Unlock() changes := params.Changes if changes == nil { changes = &LanguageServerSnapshotChanges{} } update, err := s.toLanguageServerSnapshotUpdate(ctx, &changes.SnapshotRequestChangesParams) if err != nil { return nil, err } snapshot, err := s.projectSession.APIUpdate(ctx, project.FileChangeSummary{}, update.request) if err != nil { return nil, fmt.Errorf("%w: failed to update language server snapshot: %w", ErrClientError, err) } update.commit(s, snapshot) response := s.createSnapshotResponse(snapshot, baseSnapshot, &changes.SnapshotRequestChangesParams) s.registerSnapshot(snapshot, snapshotOpenState{openProjects: s.openProjects, openFiles: s.openFiles}, nil) return response, nil } // handleRelease decrements the ref count for a snapshot. // The snapshot and its registries are only cleaned up when the ref count reaches zero. func (s *Session) handleRelease(ctx context.Context, params *ReleaseParams) (any, error) { if params == nil || params.Snapshot == 0 { return nil, fmt.Errorf("%w: empty handle", ErrClientError) } if err := s.releaseSnapshot(params.Snapshot); err != nil { return nil, err } return true, nil } // handleGetDefaultProjectForFile returns the default project for a given file, // or nil if no project currently contains the file. // @gen-proto-nullable func (s *Session) handleGetDefaultProjectForFile(ctx context.Context, params *GetDefaultProjectForFileParams) (*ProjectResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } uri := params.File.ToURI(s.GetCurrentDirectory()) proj := sd.snapshot.GetDefaultProject(uri) if proj == nil { return nil, nil } return NewProjectResponse(proj), nil } func (s *Session) handleCreateBuildOrchestrator(ctx context.Context, params *CreateBuildOrchestratorParams) (*CreateBuildOrchestratorResponse, error) { buildSys := s.getBuildSys(params) command := tsoptions.ParseBuildCommandLine(params.RootNames, buildSys) createdOrchestratorResponse := &CreateBuildOrchestratorResponse{} if params.CompilerOptions != nil { command.CompilerOptions = params.CompilerOptions } if params.BuildOptions != nil { command.BuildOptions = params.BuildOptions } orchestrator := build.NewOrchestrator(build.Options{ Sys: buildSys, Command: command, }) createdOrchestratorResponse.BuildOrchestratorID = NewBuildOrchestratorID() s.buildMu.Lock() s.buildOrchestrators[createdOrchestratorResponse.BuildOrchestratorID] = orchestrator s.buildMu.Unlock() return createdOrchestratorResponse, nil } func (s *Session) handleDisposeBuildOrchestrator(ctx context.Context, params *DisposeBuildOrchestratorParams) (any, error) { s.buildMu.Lock() defer s.buildMu.Unlock() if s.buildOrchestrators[params.BuildOrchestratorID] == nil { return nil, errors.New("build orchestrator not found while disposing") } delete(s.buildOrchestrators, params.BuildOrchestratorID) return true, nil } func (s *Session) handleBuild(ctx context.Context, params *BuildParams) (*BuildResponse, error) { s.buildMu.Lock() defer s.buildMu.Unlock() if s.buildOrchestrators[params.BuildOrchestratorID] == nil { return nil, fmt.Errorf("build orchestrator not found while building %s", params.Project) } result := s.buildOrchestrators[params.BuildOrchestratorID].Build(ctx, params.Project) return &BuildResponse{ Status: result.Result.Status, Diagnostics: NewDiagnosticResponses(result.Errors), Statistics: result.Statistics, }, nil } func (s *Session) handleBuildReferences(ctx context.Context, params *BuildParams) (*BuildResponse, error) { s.buildMu.Lock() defer s.buildMu.Unlock() if s.buildOrchestrators[params.BuildOrchestratorID] == nil { return nil, fmt.Errorf("build orchestrator not found for building references for %s", params.Project) } result := s.buildOrchestrators[params.BuildOrchestratorID].BuildReferences(ctx, params.Project) return &BuildResponse{ Status: result.Result.Status, Diagnostics: NewDiagnosticResponses(result.Errors), Statistics: result.Statistics, }, nil } func (s *Session) handleCleanBuild(ctx context.Context, params *CleanBuildParams) (*CleanBuildResponse, error) { s.buildMu.Lock() defer s.buildMu.Unlock() if s.buildOrchestrators[params.BuildOrchestratorID] == nil { return nil, fmt.Errorf("build orchestrator not found while cleaning %s", params.Project) } result := s.buildOrchestrators[params.BuildOrchestratorID].Clean(params.Project) return &CleanBuildResponse{ Status: result.Result.Status, Diagnostics: NewDiagnosticResponses(result.Errors), Statistics: result.Statistics, FilesDeleted: result.FilesToDelete, }, nil } func (s *Session) handleCleanReferences(ctx context.Context, params *CleanBuildParams) (*CleanBuildResponse, error) { s.buildMu.Lock() defer s.buildMu.Unlock() if s.buildOrchestrators[params.BuildOrchestratorID] == nil { return nil, fmt.Errorf("build orchestrator not found while cleaning references for %s", params.Project) } result := s.buildOrchestrators[params.BuildOrchestratorID].CleanReferences(params.Project) return &CleanBuildResponse{ Status: result.Result.Status, Diagnostics: NewDiagnosticResponses(result.Errors), Statistics: result.Statistics, FilesDeleted: result.FilesToDelete, }, nil } func (s *Session) getBuildSys(params *CreateBuildOrchestratorParams) tsc.System { currentDirectory := params.Cwd if currentDirectory == "" { currentDirectory = s.GetCurrentDirectory() } return &apiBuildSystem{ session: s, currentDirectory: currentDirectory, start: time.Now(), } } // Wrapper for the API session for build orchestrator type apiBuildSystem struct { session *Session currentDirectory string start time.Time } func (s *apiBuildSystem) Writer() io.Writer { return io.Discard } func (s *apiBuildSystem) ErrorWriter() io.Writer { return io.Discard } func (s *apiBuildSystem) FS() vfs.FS { return s.session.snapshotHost.FS() } func (s *apiBuildSystem) DefaultLibraryPath() string { return s.session.DefaultLibraryPath() } func (s *apiBuildSystem) GetCurrentDirectory() string { return s.currentDirectory } func (s *apiBuildSystem) WriteOutputIsTTY() bool { return false } func (s *apiBuildSystem) GetWidthOfTerminal() int { return 0 } func (s *apiBuildSystem) GetEnvironmentVariable(name string) (string, bool) { return "", false } func (s *apiBuildSystem) Spawn(command []string, dir string, stderr io.Writer) (io.ReadWriteCloser, error) { return nil, errors.New("spawning processes is not supported by the API build orchestrator") } func (s *apiBuildSystem) Now() time.Time { return time.Now() } func (s *apiBuildSystem) SinceStart() time.Duration { return time.Since(s.start) } // handleParseCommandLine parses command-line arguments. func (s *Session) handleParseCommandLine(ctx context.Context, params *ParseCommandLineParams) (*ConfigFileResponse, error) { return NewConfigFileResponse(tsoptions.ParseCommandLine(params.CommandLine, s.snapshotHost)), nil } // handleReadConfigFile reads and parses a JSON configuration file. func (s *Session) handleReadConfigFile(ctx context.Context, params *ReadConfigFileParams) (*ReadConfigFileResponse, error) { configFileName := params.File.ToAbsoluteFileName(s.GetCurrentDirectory()) configFileContent, ok := s.snapshotHost.FS().ReadFile(configFileName) if !ok { return &ReadConfigFileResponse{ Config: map[string]any{}, Error: NewDiagnosticResponse(ast.NewCompilerDiagnostic(diagnostics.Cannot_read_file_0, configFileName)), }, nil } config, parseErrors := tsoptions.ParseConfigFileTextToJson( configFileName, s.toPath(configFileName), configFileContent, ) response := &ReadConfigFileResponse{Config: config} if len(parseErrors) > 0 { response.Error = NewDiagnosticResponse(parseErrors[0]) } return response, nil } // handleParseJsonConfigFileContent parses an in-memory JSON configuration. func (s *Session) handleParseJsonConfigFileContent(ctx context.Context, params *ParseJsonConfigFileContentParams) (*ConfigFileResponse, error) { if (params.ConfigDirectory == nil) == (params.ConfigFileName == nil) { return nil, fmt.Errorf("%w: exactly one of configDirectory or configFileName is required", ErrClientError) } var basePath string var configFileName string if params.ConfigDirectory != nil { basePath = tspath.GetNormalizedAbsolutePath(*params.ConfigDirectory, s.GetCurrentDirectory()) } else { configFileName = params.ConfigFileName.ToAbsoluteFileName(s.GetCurrentDirectory()) basePath = tspath.GetDirectoryPath(configFileName) } parsedCommandLine := tsoptions.ParseJsonConfigFileContent( jsonValueToAny(params.JSON), s.snapshotHost, basePath, nil, /*existingOptions*/ configFileName, nil, /*resolutionStack*/ nil, /*extendedConfigCache*/ ) return NewConfigFileResponse(parsedCommandLine), nil } // handleParseConfigFile parses a tsconfig.json file and returns its contents. func (s *Session) handleParseConfigFile(ctx context.Context, params *ParseConfigFileParams) (*ConfigFileResponse, error) { configFileName := params.File.ToAbsoluteFileName(s.GetCurrentDirectory()) configFileContent, ok := s.snapshotHost.FS().ReadFile(configFileName) if !ok { return nil, fmt.Errorf("%w: could not read file %q", ErrClientError, configFileName) } configDir := tspath.GetDirectoryPath(configFileName) tsConfigSourceFile := tsoptions.NewTsconfigSourceFileFromFilePath( configFileName, s.toPath(configFileName), configFileContent, ) parsedCommandLine := tsoptions.ParseJsonSourceFileConfigFileContent( tsConfigSourceFile, s.snapshotHost, configDir, nil, /*existingOptions*/ nil, /*existingOptionsRaw*/ configFileName, nil, /*resolutionStack*/ nil, /*extendedConfigCache*/ ) return NewConfigFileResponse(parsedCommandLine), nil } func (s *Session) handleTranspile(ctx context.Context, params *TranspileParams, declaration bool) (*TranspileOutputResponse, error) { return transpileOutput(ctx, params.Input, params.Options, declaration) } // @gen-proto-result: SourceFileResponse func (s *Session) handleCreateSourceFile(ctx context.Context, params *CreateSourceFileParams) (any, error) { lease, err := s.createSourceFile(params.FileName, params.SourceText, params.Options) if err != nil { return nil, err } return s.encodeLeasedSourceFile(lease) } // @gen-proto-result: SourceFileResponse func (s *Session) handleCreateSourceFileFromFile(ctx context.Context, params *CreateSourceFileFromFileParams) (any, error) { fileName := tspath.GetNormalizedAbsolutePath(params.FileName, s.GetCurrentDirectory()) sourceText, ok := s.snapshotHost.FS().ReadFile(fileName) if !ok { return nil, fmt.Errorf("%w: could not read file %q", ErrClientError, fileName) } lease, err := s.createSourceFile(fileName, sourceText, params.Options) if err != nil { return nil, err } return s.encodeLeasedSourceFile(lease) } func (s *Session) createSourceFile(fileName string, sourceText string, options CreateSourceFileOptions) (*project.SourceFileLease, error) { scriptKind := options.ScriptKind if scriptKind == core.ScriptKindUnknown { scriptKind = core.EnsureScriptKindFromFileName(fileName) } if !isValidCreateSourceFileScriptKind(scriptKind) { return nil, fmt.Errorf("%w: invalid scriptKind %d", ErrClientError, scriptKind) } fileName = tspath.GetNormalizedAbsolutePath(fileName, s.GetCurrentDirectory()) return s.acquireSourceFile(ast.SourceFileParseOptions{ FileName: fileName, Path: s.toPath(fileName), }, sourceText, scriptKind), nil } func (s *Session) acquireSourceFile(options ast.SourceFileParseOptions, sourceText string, scriptKind core.ScriptKind) *project.SourceFileLease { return s.snapshotHost.AcquireSourceFile(options, sourceText, scriptKind) } func (s *Session) encodeLeasedSourceFile(lease *project.SourceFileLease) (any, error) { data, _, err := encoder.EncodeSourceFile(lease.SourceFile()) if err != nil { lease.Release() return nil, fmt.Errorf("failed to encode source file: %w", err) } encoder.SetSourceFileID(data, sourceFileNodeID(lease.SourceFile())) id := s.registerSourceFileLease(lease) encoder.SetSourceFileLease(data, uint64(id)) if s.useBinaryResponses { return RawBinary(data), nil } return &SourceFileResponse{Data: base64.StdEncoding.EncodeToString(data)}, nil } func (s *Session) handleRetainSourceFile(params *RetainSourceFileParams) (*RetainSourceFileResponse, error) { lease, err := s.acquireCachedSourceFile(params.File) if err != nil { return nil, err } return &RetainSourceFileResponse{ Lease: s.registerSourceFileLease(lease), }, nil } // @gen-proto-result: SourceFileResponse func (s *Session) handleGetCachedSourceFile(params *GetCachedSourceFileParams) (any, error) { lease, err := s.acquireCachedSourceFile(params.File) if err != nil { return nil, err } defer lease.Release() return s.encodeSourceFileResponse(lease.SourceFile()) } // acquireCachedSourceFile holds a reference to the exact ordinary cached AST identified by a // descriptor. It never parses; the caller must release the returned lease. func (s *Session) acquireCachedSourceFile(descriptor SourceFileDescriptor) (*project.SourceFileLease, error) { key, err := descriptor.parseCacheKey() if err != nil { return nil, fmt.Errorf("%w: invalid source file descriptor: %w", ErrClientError, err) } lease := s.snapshotHost.AcquireExistingSourceFile(key) if lease == nil { return nil, fmt.Errorf("%w: source file is not available", ErrClientError) } // The parse-cache key addresses a live ordinary file, but an equal key can identify a new // AST after the original entry is evicted. The node ID verifies that this is the exact AST // observed by the client; it is not used to address or retain the file. if newSourceFileDescriptor(lease.SourceFile()) != descriptor { lease.Release() return nil, fmt.Errorf("%w: source file descriptor no longer identifies the cached source file", ErrClientError) } return lease, nil } func (s *Session) registerSourceFileLease(lease *project.SourceFileLease) SourceFileLeaseID { id := SourceFileLeaseID(s.nextSourceFileLeaseID.Add(1)) s.sourceFileLeasesMu.Lock() s.sourceFileLeases[id] = lease s.sourceFileLeasesMu.Unlock() return id } func newSourceFileDescriptor(sourceFile *ast.SourceFile) SourceFileDescriptor { parseOptions := sourceFile.ParseOptions() var parseOptionsKey uint32 if parseOptions.ExternalModuleIndicatorOptions.JSX { parseOptionsKey |= 1 } if parseOptions.ExternalModuleIndicatorOptions.Force { parseOptionsKey |= 2 } return SourceFileDescriptor{ FileName: parseOptions.FileName, Path: parseOptions.Path, ContentHash: encoder.SourceFileHash(sourceFile), ParseOptionsKey: strconv.FormatUint(uint64(parseOptionsKey), 10), ScriptKind: sourceFile.ScriptKind, NodeID: strconv.FormatUint(sourceFileNodeID(sourceFile), 10), } } // sourceFileNodeID is stable for one Go AST and changes when an equal parse-cache key is // recreated, making it suitable for validating remote references without introducing another // source-file identity or ownership registry. func sourceFileNodeID(sourceFile *ast.SourceFile) uint64 { return uint64(ast.GetNodeId(sourceFile.AsNode())) } func (d SourceFileDescriptor) parseCacheKey() (project.ParseCacheKey, error) { if len(d.ContentHash) != 32 { return project.ParseCacheKey{}, errors.New("content hash must contain 32 hexadecimal digits") } hi, err := strconv.ParseUint(d.ContentHash[:16], 16, 64) if err != nil { return project.ParseCacheKey{}, fmt.Errorf("invalid content hash: %w", err) } lo, err := strconv.ParseUint(d.ContentHash[16:], 16, 64) if err != nil { return project.ParseCacheKey{}, fmt.Errorf("invalid content hash: %w", err) } parseOptionsKey, err := strconv.ParseUint(d.ParseOptionsKey, 10, 32) if err != nil || parseOptionsKey&^3 != 0 { return project.ParseCacheKey{}, fmt.Errorf("invalid parse options key %q", d.ParseOptionsKey) } if !isValidCreateSourceFileScriptKind(d.ScriptKind) { return project.ParseCacheKey{}, fmt.Errorf("invalid script kind %d", d.ScriptKind) } return project.NewParseCacheKey(ast.SourceFileParseOptions{ FileName: d.FileName, Path: d.Path, ExternalModuleIndicatorOptions: ast.ExternalModuleIndicatorOptions{ JSX: parseOptionsKey&1 != 0, Force: parseOptionsKey&2 != 0, }, }, xxh3.Uint128{Hi: hi, Lo: lo}, d.ScriptKind), nil } func (s *Session) handleReleaseSourceFile(params *ReleaseSourceFileParams) (any, error) { if params == nil || params.Lease == 0 { return nil, fmt.Errorf("%w: empty source file lease", ErrClientError) } s.sourceFileLeasesMu.Lock() lease := s.sourceFileLeases[params.Lease] if lease != nil { delete(s.sourceFileLeases, params.Lease) } s.sourceFileLeasesMu.Unlock() if lease == nil { return nil, fmt.Errorf("%w: source file lease %d not found", ErrClientError, params.Lease) } lease.Release() return true, nil } func (s *Session) releaseSourceFileLeases() { s.sourceFileLeasesMu.Lock() leases := make([]*project.SourceFileLease, 0, len(s.sourceFileLeases)) for _, lease := range s.sourceFileLeases { leases = append(leases, lease) } clear(s.sourceFileLeases) s.sourceFileLeasesMu.Unlock() for _, lease := range leases { lease.Release() } } func isValidCreateSourceFileScriptKind(scriptKind core.ScriptKind) bool { switch scriptKind { case core.ScriptKindJS, core.ScriptKindJSX, core.ScriptKindTS, core.ScriptKindTSX, core.ScriptKindJSON: return true default: return false } } func (s *Session) handleTranspileFromFile(ctx context.Context, params *TranspileFromFileParams, declaration bool) (*TranspileOutputResponse, error) { fileName := tspath.GetNormalizedAbsolutePath(params.FileName, s.GetCurrentDirectory()) input, ok := s.snapshotHost.FS().ReadFile(fileName) if !ok { return nil, fmt.Errorf("%w: could not read file %q", ErrClientError, fileName) } options := params.Options options.FileName = fileName return transpileOutput(ctx, input, options, declaration) } func transpileOutput(ctx context.Context, input string, options TranspileOptions, declaration bool) (*TranspileOutputResponse, error) { transpileOptions := transpile.Options{ CompilerOptions: options.CompilerOptions, FileName: options.FileName, ReportDiagnostics: options.ReportDiagnostics, } var output *transpile.Output if declaration { output = transpile.TranspileDeclaration(ctx, input, transpileOptions) } else { output = transpile.TranspileModule(ctx, input, transpileOptions) } if output == nil { if err := ctx.Err(); err != nil { return nil, err } return nil, errors.New("transpilation produced no output") } return &TranspileOutputResponse{ OutputText: output.OutputText, Diagnostics: NewDiagnosticResponses(output.Diagnostics), SourceMapText: output.SourceMapText, }, nil } // handleGetSourceFile returns a source file from a project within a snapshot. // @gen-proto-result: SourceFileResponse // @gen-proto-nullable func (s *Session) handleGetSourceFile(ctx context.Context, params *GetSourceFileParams) (any, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } return s.encodeSourceFileResponse(program.GetSourceFile(params.File.ToFileName())) } // handleGetConfigFileNames returns tsconfig file names associated with the project's command line. // @gen-proto-nullable func (s *Session) handleGetConfigFileNames(ctx context.Context, params *GetProjectDiagnosticsParams) ([]string, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } commandLine := program.CommandLine() if commandLine == nil || commandLine.ConfigFile == nil || commandLine.ConfigFile.SourceFile == nil { return nil, nil } extendedFiles := commandLine.ExtendedSourceFiles() configFiles := make([]string, 0, len(extendedFiles)+1) configFiles = append(configFiles, commandLine.ConfigFile.SourceFile.FileName()) configFiles = append(configFiles, extendedFiles...) return configFiles, nil } // handleGetConfigSourceFile returns a tsconfig source file associated with the project's command line. // @gen-proto-result: SourceFileResponse // @gen-proto-nullable func (s *Session) handleGetConfigSourceFile(ctx context.Context, params *GetSourceFileParams) (any, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } commandLine := program.CommandLine() if commandLine == nil || commandLine.ConfigFile == nil || commandLine.ConfigFile.SourceFile == nil { return s.encodeSourceFileResponse(nil) } requestedPath := tspath.ToPath(params.File.ToFileName(), program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames()) rootConfigSourceFile := commandLine.ConfigFile.SourceFile if rootConfigSourceFile.Path() == requestedPath { return s.encodeSourceFileResponse(rootConfigSourceFile) } for _, configFileName := range commandLine.ExtendedSourceFiles() { if tspath.ToPath(configFileName, program.GetCurrentDirectory(), program.UseCaseSensitiveFileNames()) != requestedPath { continue } configFileContent, ok := sd.snapshot.ReadFile(configFileName) if !ok { return s.encodeSourceFileResponse(nil) } configSourceFile := tsoptions.NewTsconfigSourceFileFromFilePath(configFileName, requestedPath, configFileContent) return s.encodeSourceFileResponse(configSourceFile.SourceFile) } return s.encodeSourceFileResponse(nil) } func (s *Session) encodeSourceFileResponse(sourceFile *ast.SourceFile) (any, error) { if sourceFile == nil { if s.useBinaryResponses { return RawBinary(nil), nil } return nil, nil } // Encode the full source file. data, _, err := encoder.EncodeSourceFile(sourceFile) if err != nil { return nil, fmt.Errorf("failed to encode source file: %w", err) } encoder.SetSourceFileID(data, sourceFileNodeID(sourceFile)) if s.useBinaryResponses { return RawBinary(data), nil } return &SourceFileResponse{ Data: base64.StdEncoding.EncodeToString(data), }, nil } // handleGetSourceFileNames returns file names of all source files in a project. func (s *Session) handleGetSourceFileNames(ctx context.Context, params *GetSourceFileNamesParams) ([]string, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } sourceFiles := program.GetSourceFiles() result := make([]string, len(sourceFiles)) for i, sourceFile := range sourceFiles { result[i] = sourceFile.FileName() } return result, nil } // handleGetSourceFileMetadata returns program-stored metadata for a single source file. // The client fetches this lazily per file and caches it. // @gen-proto-nullable func (s *Session) handleGetSourceFileMetadata(ctx context.Context, params *GetSourceFileParams) (*SourceFileMetadata, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } sourceFile := program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, nil } metaData := program.GetSourceFileMetaData(sourceFile.Path()) return &SourceFileMetadata{ IsDefaultLibrary: program.IsSourceFileDefaultLibrary(sourceFile.Path()), IsFromExternalLibrary: program.IsSourceFileFromExternalLibrary(sourceFile), PackageJsonType: metaData.PackageJsonType, PackageJsonDirectory: metaData.PackageJsonDirectory, ImpliedNodeFormat: metaData.ImpliedNodeFormat, }, nil } func newResolvedModuleResponse(resolution *module.ResolvedModule) *ResolvedModule { if !resolution.IsResolved() { return nil } return &ResolvedModule{ ResolvedFileName: resolution.ResolvedFileName, OriginalPath: resolution.OriginalPath, Extension: resolution.Extension, ResolvedUsingTsExtension: resolution.ResolvedUsingTsExtension, ResolvedUsingExtraExtensions: resolution.ResolvedUsingExtraExtensions, PackageId: NewPackageId(resolution.PackageId), IsExternalLibraryImport: resolution.IsExternalLibraryImport, AlternateResult: resolution.AlternateResult, } } func newResolvedTypeReferenceDirectiveResponse(resolution *module.ResolvedTypeReferenceDirective) *ResolvedTypeReferenceDirective { if resolution == nil || !resolution.IsResolved() { return nil } return &ResolvedTypeReferenceDirective{ Primary: resolution.Primary, ResolvedFileName: resolution.ResolvedFileName, OriginalPath: resolution.OriginalPath, PackageId: NewPackageId(resolution.PackageId), IsExternalLibraryImport: resolution.IsExternalLibraryImport, } } func (s *Session) handleGetModeForUsageLocation(ctx context.Context, params *GetModeForUsageLocationParams) (core.ResolutionMode, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return core.ResolutionModeNone, err } program, err := sd.getProgram(params.Project) if err != nil { return core.ResolutionModeNone, err } sourceFile, err := s.resolveOptionalSourceFile(program, ¶ms.File) if err != nil { return core.ResolutionModeNone, err } usage, err := sd.resolveNodeHandle(program, params.Usage) if err != nil { return core.ResolutionModeNone, err } if !ast.IsStringLiteralLike(usage) { return core.ResolutionModeNone, fmt.Errorf("%w: usage must be a StringLiteralLike node", ErrClientError) } return program.GetModeForUsageLocation(sourceFile, usage), nil } func (s *Session) handleGetModeForResolutionAtIndex(ctx context.Context, params *GetModeForResolutionAtIndexParams) (core.ResolutionMode, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return core.ResolutionModeNone, err } program, err := sd.getProgram(params.Project) if err != nil { return core.ResolutionModeNone, err } sourceFile, err := s.resolveOptionalSourceFile(program, ¶ms.File) if err != nil { return core.ResolutionModeNone, err } resolutionCount := len(sourceFile.Imports()) for _, augmentation := range sourceFile.ModuleAugmentations { if augmentation.Kind == ast.KindStringLiteral { resolutionCount++ } } if params.Index < 0 || params.Index >= resolutionCount { return core.ResolutionModeNone, fmt.Errorf("%w: invalid resolution index", ErrClientError) } return program.GetModeForResolutionAtIndex(sourceFile, params.Index), nil } // @gen-proto-nullable func (s *Session) handleGetResolvedModule(ctx context.Context, params *GetResolvedModuleParams) (*ResolvedModule, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } sourceFile, err := s.resolveOptionalSourceFile(program, ¶ms.File) if err != nil { return nil, err } return newResolvedModuleResponse(program.GetResolvedModule(sourceFile, params.ModuleName, params.Mode)), nil } // @gen-proto-nullable func (s *Session) handleGetResolvedModuleFromModuleSpecifier(ctx context.Context, params *GetResolvedModuleFromModuleSpecifierParams) (*ResolvedModule, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } node, err := sd.resolveNodeHandle(program, params.ModuleSpecifier) if err != nil { return nil, err } if !ast.IsStringLiteralLike(node) { return nil, fmt.Errorf("%w: moduleSpecifier must be a StringLiteralLike node", ErrClientError) } sourceFile := ast.GetSourceFileOfNode(node) if params.SourceFile != nil { sourceFile, err = s.resolveOptionalSourceFile(program, params.SourceFile) if err != nil { return nil, err } } if sourceFile == nil { return nil, fmt.Errorf("%w: moduleSpecifier must have a SourceFile ancestor or sourceFile must be provided", ErrClientError) } mode := program.GetModeForUsageLocation(sourceFile, node) return newResolvedModuleResponse(program.GetResolvedModule(sourceFile, node.Text(), mode)), nil } // @gen-proto-nullable func (s *Session) handleGetResolvedTypeReferenceDirective(ctx context.Context, params *GetResolvedTypeReferenceDirectiveParams) (*ResolvedTypeReferenceDirective, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } sourceFile, err := s.resolveOptionalSourceFile(program, ¶ms.File) if err != nil { return nil, err } return newResolvedTypeReferenceDirectiveResponse(program.GetResolvedTypeReferenceDirective(sourceFile, params.TypeDirectiveName, params.Mode)), nil } // @gen-proto-nullable func (s *Session) handleGetResolvedTypeReferenceDirectiveFromReference(ctx context.Context, params *GetResolvedTypeReferenceDirectiveFromReferenceParams) (*ResolvedTypeReferenceDirective, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } sourceFile, err := s.resolveOptionalSourceFile(program, ¶ms.SourceFile) if err != nil { return nil, err } mode := params.ResolutionMode if mode == core.ResolutionModeNone { mode = program.GetDefaultResolutionModeForFile(sourceFile) } return newResolvedTypeReferenceDirectiveResponse(program.GetResolvedTypeReferenceDirective(sourceFile, params.TypeDirectiveName, mode)), nil } // handleGetSymbolAtPosition returns the symbol at a position in a file. // @gen-proto-nullable func (s *Session) handleGetSymbolAtPosition(ctx context.Context, params *GetSymbolAtPositionParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sourceFile := setup.program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } positionMap := sourceFile.GetPositionMap() node := astnav.GetTouchingPropertyName(sourceFile, positionMap.UTF16ToUTF8(int(params.Position))) if node == nil { return nil, nil } symbol := setup.checker.GetSymbolAtLocation(node) if symbol == nil { return nil, nil } return setup.newSymbolResponse(symbol), nil } // handleGetSymbolOfSourceFile returns the module symbol for a source file, if any. // For non-module (script) files, returns nil. // @gen-proto-nullable func (s *Session) handleGetSymbolOfSourceFile(ctx context.Context, params *GetSymbolOfSourceFileParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sourceFile := setup.program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } symbol := setup.checker.GetSymbolAtLocation(sourceFile.AsNode()) if symbol == nil { return nil, nil } return setup.newSymbolResponse(symbol), nil } // handleGetSymbolsOfSourceFiles returns the module symbols for multiple source files. func (s *Session) handleGetSymbolsOfSourceFiles(ctx context.Context, params *GetSymbolsOfSourceFilesParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() results := make([]*SymbolResponse, len(params.Files)) for i, file := range params.Files { sourceFile := setup.program.GetSourceFile(file.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, file) } symbol := setup.checker.GetSymbolAtLocation(sourceFile.AsNode()) if symbol != nil { results[i] = setup.newSymbolResponse(symbol) } } return results, nil } // handleGetSymbolsAtPositions returns symbols at multiple positions in a file. func (s *Session) handleGetSymbolsAtPositions(ctx context.Context, params *GetSymbolsAtPositionsParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sourceFile := setup.program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } positionMap := sourceFile.GetPositionMap() results := make([]*SymbolResponse, len(params.Positions)) for i, pos := range params.Positions { node := astnav.GetTouchingPropertyName(sourceFile, positionMap.UTF16ToUTF8(int(pos))) if node == nil { continue } symbol := setup.checker.GetSymbolAtLocation(node) if symbol != nil { results[i] = setup.newSymbolResponse(symbol) } } return results, nil } // handleGetSymbolAtLocation returns the symbol at a node location. // @gen-proto-nullable func (s *Session) handleGetSymbolAtLocation(ctx context.Context, params *GetSymbolAtLocationParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } if node == nil { return nil, nil } symbol := setup.checker.GetSymbolAtLocation(node) if symbol == nil { return nil, nil } return setup.newSymbolResponse(symbol), nil } // handleGetSymbolsAtLocations returns symbols at multiple node locations. func (s *Session) handleGetSymbolsAtLocations(ctx context.Context, params *GetSymbolsAtLocationsParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() results := make([]*SymbolResponse, len(params.Locations)) for i, loc := range params.Locations { node, err := setup.sd.resolveNodeHandle(setup.program, loc) if err != nil { return nil, err } if node == nil { continue } symbol := setup.checker.GetSymbolAtLocation(node) if symbol != nil { results[i] = setup.newSymbolResponse(symbol) } } return results, nil } // handleGetTypeOfSymbol returns the type of a symbol. func (s *Session) handleGetTypeOfSymbol(ctx context.Context, params *GetTypeOfSymbolParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeOfSymbol(symbol), setup.checker), nil } // handleGetTypesOfSymbols returns the types of multiple symbols. func (s *Session) handleGetTypesOfSymbols(ctx context.Context, params *GetTypesOfSymbolsParams) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() results := make([]*TypeResponse, len(params.Symbols)) for i, symbolReference := range params.Symbols { symbol, err := setup.resolveSymbolHandle(symbolReference) if err != nil { return nil, err } // resolveSymbolHandle errors on an unresolvable handle and GetTypeOfSymbol // never returns nil, so every element resolves to a type (error type at worst). results[i] = setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeOfSymbol(symbol), setup.checker) } return results, nil } // handleGetDeclaredTypeOfSymbol returns the declared type of a symbol (e.g. the type alias body for type alias symbols). func (s *Session) handleGetDeclaredTypeOfSymbol(ctx context.Context, params *GetTypeOfSymbolParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetDeclaredTypeOfSymbol(symbol), setup.checker), nil } // handleGetNonMissingTypeOfSymbol returns the type of a symbol, excluding the missing type. func (s *Session) handleGetNonMissingTypeOfSymbol(ctx context.Context, params *GetTypeOfSymbolParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetNonMissingTypeOfSymbol(symbol), setup.checker), nil } // handleResolveName resolves a name to a symbol at a given location. // @gen-proto-nullable func (s *Session) handleResolveName(ctx context.Context, params *ResolveNameParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() // Resolve location node - either from node handle or from fileName+position location, err := setup.resolveLocation(params.Location, params.File, params.Position) if err != nil { return nil, err } symbol := setup.checker.ResolveName(params.Name, location, ast.SymbolFlags(params.Meaning), params.ExcludeGlobals) if symbol == nil { return nil, nil } return setup.newSymbolResponse(symbol), nil } // handleGetSymbolsInScope returns all symbols with the given meaning that are visible at a location. func (s *Session) handleGetSymbolsInScope(ctx context.Context, params *GetSymbolsInScopeParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() location, err := setup.resolveLocation(params.Location, params.File, params.Position) if err != nil { return nil, err } if location == nil { return nil, fmt.Errorf("%w: getSymbolsInScope requires a location", ErrClientError) } symbols := setup.checker.GetSymbolsInScope(location, ast.SymbolFlags(params.Meaning)) results := make([]*SymbolResponse, len(symbols)) for i, symbol := range symbols { results[i] = setup.newSymbolResponse(symbol) } return results, nil } // handleGetSignaturesOfType returns the call or construct signatures of a type. func (s *Session) handleGetSignaturesOfType(ctx context.Context, params *GetSignaturesOfTypeParams) ([]*SignatureResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } sigs := setup.checker.GetSignaturesOfType(t, checker.SignatureKind(params.Kind)) results := make([]*SignatureResponse, len(sigs)) for i, sig := range sigs { results[i] = setup.newSignatureResponse(sig) } return results, nil } // handleGetResolvedSignature returns the resolved signature of a call-like expression. func (s *Session) handleGetResolvedSignature(ctx context.Context, params *GetResolvedSignatureParams) (*SignatureResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } return setup.newSignatureResponse(setup.checker.GetResolvedSignature(node)), nil } // handleGetTypeAtLocation returns the type at a node location. func (s *Session) handleGetTypeAtLocation(ctx context.Context, params *GetTypeAtLocationParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeAtLocation(node), setup.checker), nil } // handleGetTypeAtLocations returns types at multiple node locations. func (s *Session) handleGetTypeAtLocations(ctx context.Context, params *GetTypeAtLocationsParams) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() results := make([]*TypeResponse, len(params.Locations)) for i, loc := range params.Locations { node, err := setup.sd.resolveNodeHandle(setup.program, loc) if err != nil { return nil, err } // resolveNodeHandle errors on an unresolvable handle and GetTypeAtLocation // never returns nil, so every element resolves to a type (error type at worst). results[i] = setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeAtLocation(node), setup.checker) } return results, nil } // handleGetTypeAtPosition returns the type at a position in a file. // @gen-proto-nullable func (s *Session) handleGetTypeAtPosition(ctx context.Context, params *GetTypeAtPositionParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sourceFile := setup.program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } positionMap := sourceFile.GetPositionMap() node := astnav.GetTouchingPropertyName(sourceFile, positionMap.UTF16ToUTF8(int(params.Position))) if node == nil { return nil, nil } t := setup.checker.GetTypeAtLocation(node) if t == nil { return nil, nil } return setup.sd.newTypeResponse(setup.projectID, t, setup.checker), nil } // handleGetTypesAtPositions returns types at multiple positions in a file. func (s *Session) handleGetTypesAtPositions(ctx context.Context, params *GetTypesAtPositionsParams) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sourceFile := setup.program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } positionMap := sourceFile.GetPositionMap() results := make([]*TypeResponse, len(params.Positions)) for i, pos := range params.Positions { node := astnav.GetTouchingPropertyName(sourceFile, positionMap.UTF16ToUTF8(int(pos))) if node == nil { continue } t := setup.checker.GetTypeAtLocation(node) if t != nil { results[i] = setup.sd.newTypeResponse(setup.projectID, t, setup.checker) } } return results, nil } // @gen-proto-nullable func (s *Session) handleGetParentOfSymbol(_ context.Context, params *GetSymbolPropertyParams) (*SymbolResponse, error) { return s.resolveSymbolPropertyOfSymbol(params, func(sym *ast.Symbol) *ast.Symbol { return sym.Parent }) } // @gen-proto-nullable func (s *Session) handleGetMembersOfSymbol(ctx context.Context, params *GetSymbolPropertyParams) ([]*SymbolResponse, error) { return s.resolveSymbolTablePropertyOfSymbol(ctx, params, func(symbol *ast.Symbol) ast.SymbolTable { return symbol.Members }) } // @gen-proto-nullable func (s *Session) handleGetExportsOfSymbol(ctx context.Context, params *GetSymbolPropertyParams) ([]*SymbolResponse, error) { return s.resolveSymbolTablePropertyOfSymbol(ctx, params, func(symbol *ast.Symbol) ast.SymbolTable { return symbol.Exports }) } // @gen-proto-nullable func (s *Session) handleGetExportSymbolOfSymbol(_ context.Context, params *GetSymbolPropertyParams) (*SymbolResponse, error) { return s.resolveSymbolPropertyOfSymbol(params, func(sym *ast.Symbol) *ast.Symbol { return sym.ExportSymbol }) } // @gen-proto-nullable func (s *Session) handleGetSymbolOfType(_ context.Context, params *GetTypePropertyParams) (*SymbolResponse, error) { return s.resolveSymbolPropertyOfType(params, (*checker.Type).Symbol) } func (s *Session) handleGetTargetOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, (*checker.Type).Target) } // @gen-proto-nullable func (s *Session) handleGetFreshTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsLiteralType().FreshType() }) } // @gen-proto-nullable func (s *Session) handleGetRegularTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsLiteralType().RegularType() }) } // @gen-proto-nullable func (s *Session) handleGetTypesOfType(ctx context.Context, params *GetTypePropertyParams) ([]*TypeResponse, error) { return s.resolveTypeArrayPropertyOfType(ctx, params, (*checker.Type).Types) } // @gen-proto-nullable func (s *Session) handleGetTypeParametersOfType(ctx context.Context, params *GetTypePropertyParams) ([]*TypeResponse, error) { return s.resolveTypeArrayPropertyOfType(ctx, params, func(t *checker.Type) []*checker.Type { return t.AsInterfaceType().TypeParameters() }) } // @gen-proto-nullable func (s *Session) handleGetOuterTypeParametersOfType(ctx context.Context, params *GetTypePropertyParams) ([]*TypeResponse, error) { return s.resolveTypeArrayPropertyOfType(ctx, params, func(t *checker.Type) []*checker.Type { return t.AsInterfaceType().OuterTypeParameters() }) } // @gen-proto-nullable func (s *Session) handleGetLocalTypeParametersOfType(ctx context.Context, params *GetTypePropertyParams) ([]*TypeResponse, error) { return s.resolveTypeArrayPropertyOfType(ctx, params, func(t *checker.Type) []*checker.Type { return t.AsInterfaceType().LocalTypeParameters() }) } // @gen-proto-nullable func (s *Session) handleGetThisTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsInterfaceType().ThisType() }) } // @gen-proto-nullable func (s *Session) handleGetAliasTypeArgumentsOfType(ctx context.Context, params *GetTypePropertyParams) ([]*TypeResponse, error) { return s.resolveTypeArrayPropertyOfType(ctx, params, func(t *checker.Type) []*checker.Type { if t.Alias() == nil { return nil } return t.Alias().TypeArguments() }) } // @gen-proto-nullable func (s *Session) handleGetAliasSymbolOfType(_ context.Context, params *GetTypePropertyParams) (*SymbolResponse, error) { return s.resolveSymbolPropertyOfType(params, func(t *checker.Type) *ast.Symbol { if t.Alias() == nil { return nil } return t.Alias().Symbol() }) } func (s *Session) handleGetObjectTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsIndexedAccessType().ObjectType() }) } func (s *Session) handleGetIndexTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsIndexedAccessType().IndexType() }) } func (s *Session) handleGetCheckTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsConditionalType().CheckType() }) } func (s *Session) handleGetExtendsTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsConditionalType().ExtendsType() }) } func (s *Session) handleGetBaseTypeOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsSubstitutionType().BaseType() }) } // handleGetConstraintOfType returns the constraint of a substitution type. // Type parameter constraints are handled by handleGetConstraintOfTypeParameter. func (s *Session) handleGetConstraintOfType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsSubstitutionType().SubstConstraint() }) } func (s *Session) handleGetTypeParameterOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().TypeParameter() }) } func (s *Session) handleGetConstraintTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().ConstraintType() }) } // @gen-proto-nullable func (s *Session) handleGetNameTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().NameType() }) } func (s *Session) handleGetTemplateTypeOfMappedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { return s.resolveTypePropertyOfType(ctx, params, func(t *checker.Type) *checker.Type { return t.AsMappedType().TemplateType() }) } // @gen-proto-nullable func (s *Session) handleGetTypeParametersOfSignature(ctx context.Context, params *GetSignaturePropertyParams) ([]*TypeResponse, error) { return s.resolveTypeArrayPropertyOfSignature(ctx, params, (*checker.Signature).TypeParameters) } // @gen-proto-nullable func (s *Session) handleGetParametersOfSignature(_ context.Context, params *GetSignaturePropertyParams) ([]*SymbolResponse, error) { return s.resolveSymbolArrayPropertyOfSignature(params, (*checker.Signature).Parameters) } // @gen-proto-nullable func (s *Session) handleGetThisParameterOfSignature(_ context.Context, params *GetSignaturePropertyParams) (*SymbolResponse, error) { return s.resolveSymbolPropertyOfSignature(params, (*checker.Signature).ThisParameter) } // @gen-proto-nullable func (s *Session) handleGetTargetOfSignature(_ context.Context, params *GetSignaturePropertyParams) (*SignatureResponse, error) { return s.resolveSignaturePropertyOfSignature(params, (*checker.Signature).Target) } func (s *Session) handleGetImportAdderEdits(ctx context.Context, params *GetImportAdderEditsParams) ([]*TextEdit, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } projectID := params.Project workingSnapshot := sd.snapshot program, err := sd.getProgram(params.Project) if err != nil { return nil, err } sourceFile := program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } userPreferences := workingSnapshot.UserPreferences() if registry := workingSnapshot.AutoImportRegistry(); registry == nil || !registry.IsPreparedForImportingFile(sourceFile.FileName(), projectID, userPreferences) { preparedSnapshot := s.snapshotHost.CloneSnapshotWithAutoImports(ctx, workingSnapshot, params.File.ToURI(s.GetCurrentDirectory()), nil) if s.projectSession != nil { s.projectSession.TryAdoptSnapshotInBackground(workingSnapshot, preparedSnapshot) } defer preparedSnapshot.Deref() workingSnapshot = preparedSnapshot proj := workingSnapshot.ProjectCollection.GetProject(projectID) if proj == nil { return nil, fmt.Errorf("%w: project %s not found", ErrClientError, projectID) } program = proj.GetProgram() if program == nil { return nil, fmt.Errorf("%w: project has no program", ErrClientError) } sourceFile = program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } userPreferences = workingSnapshot.UserPreferences() } registry := workingSnapshot.AutoImportRegistry() if registry == nil { return []*TextEdit{}, nil } ch, done := program.GetTypeChecker(ctx) defer done() view := autoimport.NewView( registry, sourceFile, projectID, program, ch, userPreferences.ModuleSpecifierPreferences(), ) importAdder := autoimport.NewImportAdder( ctx, program, ch, sourceFile, view, workingSnapshot.GetPreferences(sourceFile.FileName()).FormatCodeSettings, workingSnapshot.Converters(), userPreferences, ) for i, action := range params.Actions { switch action.Kind { case ImportAdderActionKindImportSymbol: if action.Symbol == nil { return nil, fmt.Errorf("%w: import adder action %d missing symbol", ErrClientError, i) } symbol, err := (checkerSetup{ sd: sd, snapshot: params.Snapshot, program: program, projectID: params.Project, }).resolveSymbolHandle(*action.Symbol) if err != nil { return nil, err } isValidTypeOnlyUseSite := true if action.IsValidTypeOnlyUseSite != nil { isValidTypeOnlyUseSite = *action.IsValidTypeOnlyUseSite } importAdder.AddImportFromExportedSymbol(symbol, isValidTypeOnlyUseSite) default: return nil, fmt.Errorf("%w: unknown import adder action kind %q", ErrClientError, action.Kind) } } if !importAdder.HasFixes() { return []*TextEdit{}, nil } return toAPITextEdits(sourceFile, importAdder.Edits()), nil } func toAPITextEdits(sourceFile *ast.SourceFile, edits []*lsproto.TextEdit) []*TextEdit { originalText := sourceFile.OriginalText() lineMap := lsconv.ComputeLSPLineStarts(originalText) positionMap := ast.ComputePositionMap(originalText) result := make([]*TextEdit, len(edits)) for i, edit := range edits { start, ok := originalTextOffset(lineMap, edit.Range.Start, len(originalText)) if !ok { return nil } end, ok := originalTextOffset(lineMap, edit.Range.End, len(originalText)) if !ok { return nil } result[i] = &TextEdit{ Pos: positionMap.UTF8ToUTF16(start), End: positionMap.UTF8ToUTF16(end), NewText: edit.NewText, } } return result } func originalTextOffset(lineMap *lsconv.LSPLineMap, position lsproto.Position, textLength int) (int, bool) { line := int(position.Line) if line < 0 || line >= len(lineMap.LineStarts) { return 0, false } offset := int(lineMap.LineStarts[line]) + int(position.Character) if offset < int(lineMap.LineStarts[line]) || offset > textLength { return 0, false } return offset, true } // resolveTypePropertyOfType resolves a type property of type `Type` and returns a type response. func (s *Session) resolveTypePropertyOfType(ctx context.Context, params *GetTypePropertyParams, getter func(*checker.Type) *checker.Type) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.sd.resolveTypeHandle(params.Project, params.Type) if err != nil { return nil, err } result := getter(t) if result == nil { return nil, nil } return setup.sd.newTypeResponse(setup.projectID, result, setup.checker), nil } // resolveTypeArrayPropertyOfType resolves a type property of an array of types and returns an array of type responses. func (s *Session) resolveTypeArrayPropertyOfType(ctx context.Context, params *GetTypePropertyParams, getter func(*checker.Type) []*checker.Type) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.sd.resolveTypeHandle(params.Project, params.Type) if err != nil { return nil, err } types := getter(t) if len(types) == 0 { return nil, nil } results := make([]*TypeResponse, len(types)) for i, sub := range types { results[i] = setup.sd.newTypeResponse(setup.projectID, sub, setup.checker) } return results, nil } // resolveSymbolPropertyOfType resolves a type property of type `Symbol` and returns a symbol response. func (s *Session) resolveSymbolPropertyOfType(params *GetTypePropertyParams, getter func(*checker.Type) *ast.Symbol) (*SymbolResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } t, err := sd.resolveTypeHandle(params.Project, params.Type) if err != nil { return nil, err } result := getter(t) if result == nil { return nil, nil } return sd.newSymbolResponse(result, params.Project), nil } // resolveSymbolTablePropertyOfSymbol resolves a symbol property of type `Symbol` and returns a symbol response. func (s *Session) resolveSymbolPropertyOfSymbol(params *GetSymbolPropertyParams, getter func(*ast.Symbol) *ast.Symbol) (*SymbolResponse, error) { symbol, sd, projectID, release, err := s.resolveSymbolReference(params.Symbol) if err != nil { return nil, err } defer release() result := getter(symbol) if result == nil { return nil, nil } if sd == nil { return newFileSymbolResponse(result), nil } return sd.newSymbolResponse(result, projectID), nil } // resolveSymbolTablePropertyOfSymbol resolves a symbol property of type `SymbolTable` and returns an array of symbol responses. // Results are sorted using the checker's canonical symbol ordering so that API consumers receive // a stable, deterministic order instead of Go's randomized map iteration order. func (s *Session) resolveSymbolTablePropertyOfSymbol(ctx context.Context, params *GetSymbolPropertyParams, getter func(*ast.Symbol) ast.SymbolTable) ([]*SymbolResponse, error) { symbol, sd, projectID, release, err := s.resolveSymbolReference(params.Symbol) if err != nil { return nil, err } defer release() symbolTable := getter(symbol) if len(symbolTable) == 0 { return nil, nil } if len(symbolTable) == 1 { for _, sub := range symbolTable { if sd == nil { return []*SymbolResponse{newFileSymbolResponse(sub)}, nil } return []*SymbolResponse{sd.newSymbolResponse(sub, projectID)}, nil } } symbols := make([]*ast.Symbol, 0, len(symbolTable)) for _, sub := range symbolTable { symbols = append(symbols, sub) } if sd == nil { // Binder tables of a file-owned symbol only contain symbols from the same file, so they // can be ordered by declaration position without a checker. file := ast.GetSourceFileOfSymbol(symbol) slices.SortFunc(symbols, func(left *ast.Symbol, right *ast.Symbol) int { compilerdebug.Assert(ast.GetSourceFileOfSymbol(left) == file) compilerdebug.Assert(ast.GetSourceFileOfSymbol(right) == file) leftHasDeclaration := len(left.Declarations) != 0 rightHasDeclaration := len(right.Declarations) != 0 if leftHasDeclaration != rightHasDeclaration { if leftHasDeclaration { return -1 } return 1 } if leftHasDeclaration { if order := cmp.Compare(left.Declarations[0].Pos(), right.Declarations[0].Pos()); order != 0 { return order } } if order := cmp.Compare(left.Name, right.Name); order != 0 { return order } return cmp.Compare(ast.GetSymbolId(left), ast.GetSymbolId(right)) }) results := make([]*SymbolResponse, len(symbols)) for i, sub := range symbols { results[i] = newFileSymbolResponse(sub) } return results, nil } // Tables of snapshot-owned symbols may contain symbols from several files, so they use the // checker's ordering. setup, err := s.setupChecker(ctx, params.Symbol.Snapshot, params.Symbol.Project) if err != nil { return nil, err } defer setup.done() slices.SortFunc(symbols, setup.checker.CompareSymbols) results := make([]*SymbolResponse, len(symbols)) for i, sub := range symbols { results[i] = setup.newSymbolResponse(sub) } return results, nil } // resolveSymbolArrayPropertyOfSignature resolves a signature property of an array of symbols and returns an array of symbol responses. func (s *Session) resolveSymbolArrayPropertyOfSignature(params *GetSignaturePropertyParams, getter func(*checker.Signature) []*ast.Symbol) ([]*SymbolResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } sig, err := sd.resolveSignatureHandle(params.Project, params.Signature) if err != nil { return nil, err } symbols := getter(sig) if len(symbols) == 0 { return nil, nil } results := make([]*SymbolResponse, len(symbols)) for i, sym := range symbols { results[i] = sd.newSymbolResponse(sym, params.Project) } return results, nil } // resolveSymbolPropertyOfSignature resolves a signature property of type `Symbol` and returns a symbol response. func (s *Session) resolveSymbolPropertyOfSignature(params *GetSignaturePropertyParams, getter func(*checker.Signature) *ast.Symbol) (*SymbolResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } sig, err := sd.resolveSignatureHandle(params.Project, params.Signature) if err != nil { return nil, err } result := getter(sig) if result == nil { return nil, nil } return sd.newSymbolResponse(result, params.Project), nil } func (s *Session) resolveTypeArrayPropertyOfSignature(ctx context.Context, params *GetSignaturePropertyParams, getter func(signature *checker.Signature) []*checker.Type) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.sd.resolveSignatureHandle(params.Project, params.Signature) if err != nil { return nil, err } types := getter(sig) if len(types) == 0 { return nil, nil } results := make([]*TypeResponse, len(types)) for i, sub := range types { results[i] = setup.sd.newTypeResponse(setup.projectID, sub, setup.checker) } return results, nil } func (s *Session) resolveSignaturePropertyOfSignature(params *GetSignaturePropertyParams, getter func(*checker.Signature) *checker.Signature) (*SignatureResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } sig, err := sd.resolveSignatureHandle(params.Project, params.Signature) if err != nil { return nil, err } result := getter(sig) if result == nil { return nil, nil } return sd.newSignatureResponse(params.Project, result), nil } // handleGetContextualType returns the contextual type for a node. // @gen-proto-nullable func (s *Session) handleGetContextualType(ctx context.Context, params *GetContextualTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } if node == nil { return nil, nil } t := setup.checker.GetContextualType(node, checker.ContextFlagsNone) if t == nil { return nil, nil } return setup.sd.newTypeResponse(setup.projectID, t, setup.checker), nil } // @gen-proto-nullable func (s *Session) handleGetContextualTypeForArgument(ctx context.Context, params *GetContextualTypeForArgumentParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetContextualTypeForArgumentAtIndex(node, int(params.Index)), setup.checker), nil } // @gen-proto-nullable func (s *Session) handleGetAwaitedType(ctx context.Context, params *CheckerTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetAwaitedType(t), setup.checker), nil } // handleGetBaseTypeOfLiteralType returns the base type of a literal type (e.g. number for 42). func (s *Session) handleGetBaseTypeOfLiteralType(ctx context.Context, params *GetBaseTypeOfLiteralTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetBaseTypeOfLiteralType(t), setup.checker), nil } // handleGetNonNullableType returns the type with null and undefined removed. func (s *Session) handleGetNonNullableType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetNonNullableType(t), setup.checker), nil } // handleGetTypeFromTypeNode returns the type for a type node. func (s *Session) handleGetTypeFromTypeNode(ctx context.Context, params *GetTypeFromTypeNodeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeFromTypeNode(node), setup.checker), nil } // handleGetWidenedType returns the widened type. func (s *Session) handleGetWidenedType(ctx context.Context, params *GetWidenedTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetWidenedType(t), setup.checker), nil } // handleGetParameterType returns the type of a parameter at a given index in a signature. func (s *Session) handleGetParameterType(ctx context.Context, params *GetParameterTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.resolveSignatureHandle(params.Signature) if err != nil { return nil, err } if params.Index < 0 { return nil, fmt.Errorf("%w: invalid parameter index", ErrClientError) } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeAtPosition(sig, int(params.Index)), setup.checker), nil } func (s *Session) handleGetTypeParameterAtPosition(ctx context.Context, params *GetParameterTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.resolveSignatureHandle(params.Signature) if err != nil { return nil, err } if params.Index < 0 { return nil, fmt.Errorf("%w: invalid parameter index", ErrClientError) } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeParameterAtPosition(sig, int(params.Index)), setup.checker), nil } // handleIsArrayLikeType returns whether a type is array-like. func (s *Session) handleIsArrayLikeType(ctx context.Context, params *IsArrayLikeTypeParams) (bool, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return false, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return false, err } return setup.checker.IsArrayLikeType(t), nil } // handleIsTypeAssignableTo returns whether source is assignable to target. func (s *Session) handleIsTypeAssignableTo(ctx context.Context, params *IsTypeAssignableToParams) (bool, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return false, err } defer setup.done() source, err := setup.resolveTypeHandle(params.Source) if err != nil { return false, err } target, err := setup.resolveTypeHandle(params.Target) if err != nil { return false, err } return setup.checker.IsTypeAssignableTo(source, target), nil } // handleGetShorthandAssignmentValueSymbol returns the value symbol of a shorthand property assignment. // @gen-proto-nullable func (s *Session) handleGetShorthandAssignmentValueSymbol(ctx context.Context, params *GetTypeAtLocationParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } if node == nil { return nil, nil } symbol := setup.checker.GetShorthandAssignmentValueSymbol(node) if symbol == nil { return nil, nil } return setup.newSymbolResponse(symbol), nil } // handleGetTypeOfSymbolAtLocation returns the narrowed type of a symbol at a specific location. func (s *Session) handleGetTypeOfSymbolAtLocation(ctx context.Context, params *GetTypeOfSymbolAtLocationParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeOfSymbolAtLocation(symbol, node), setup.checker), nil } // handleTypeToTypeNode converts a Type to a TypeNode AST and returns it as binary-encoded data. // @gen-proto-result: SourceFileResponse // @gen-proto-nullable func (s *Session) handleTypeToTypeNode(ctx context.Context, params *TypeToTypeNodeParams) (any, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } var enclosingDeclaration *ast.Node if params.Location != "" { enclosingDeclaration, err = setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } } typeNode := setup.checker.TypeToTypeNode(t, enclosingDeclaration, nodebuilder.Flags(params.Flags), nil) if typeNode == nil { return nil, nil } data, _, err := encoder.EncodeNode(typeNode.AsNode(), nil) if err != nil { return nil, fmt.Errorf("failed to encode type node: %w", err) } if s.useBinaryResponses { return RawBinary(data), nil } return &SourceFileResponse{ Data: base64.StdEncoding.EncodeToString(data), }, nil } // @gen-proto-result: SourceFileResponse // @gen-proto-nullable func (s *Session) handleSignatureToSignatureDeclaration(ctx context.Context, params *SignatureToSignatureDeclarationParams) (any, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.resolveSignatureHandle(params.Signature) if err != nil { return nil, err } var enclosingDeclaration *ast.Node if params.Location != "" { enclosingDeclaration, err = setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } } node := setup.checker.SignatureToSignatureDeclaration(sig, ast.Kind(params.Kind), enclosingDeclaration, nodebuilder.Flags(params.Flags)) if node == nil { return nil, nil } data, _, err := encoder.EncodeNode(node.AsNode(), nil) if err != nil { return nil, fmt.Errorf("failed to encode signature declaration: %w", err) } if s.useBinaryResponses { return RawBinary(data), nil } return &SourceFileResponse{ Data: base64.StdEncoding.EncodeToString(data), }, nil } // handleTypeToString converts a Type to its string representation. func (s *Session) handleTypeToString(ctx context.Context, params *TypeToTypeNodeParams) (any, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } var enclosingDeclaration *ast.Node if params.Location != "" { enclosingDeclaration, err = setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } } if params.Flags != 0 { return setup.checker.TypeToStringEx(t, enclosingDeclaration, checker.TypeFormatFlags(params.Flags), nil), nil } return setup.checker.TypeToStringEx(t, enclosingDeclaration, checker.TypeFormatFlagsAllowUniqueESSymbolType|checker.TypeFormatFlagsUseAliasDefinedOutsideCurrentScope, nil), nil } // handlePrintNode decodes a binary-encoded AST node and prints it to text. func (s *Session) handlePrintNode(_ context.Context, params *PrintNodeParams) (string, error) { node, err := decodePrintNode(params.Data) if err != nil { return "", err } var sourceFile *ast.SourceFile if ast.IsSourceFile(node) { sourceFile = node.AsSourceFile() } return newPrinter(params).Emit(node, sourceFile), nil } func decodePrintNode(encoded string) (*ast.Node, error) { data, err := base64.StdEncoding.DecodeString(encoded) if err != nil { return nil, fmt.Errorf("%w: invalid base64 data: %w", ErrClientError, err) } node, err := encoder.DecodeNodes(data) if err != nil { return nil, fmt.Errorf("%w: failed to decode AST: %w", ErrClientError, err) } return node, nil } func newPrinter(params *PrintNodeParams) *printer.Printer { return printer.NewPrinter(printer.PrinterOptions{ PreserveSourceNewlines: params.PreserveSourceNewlines, NeverAsciiEscape: params.NeverAsciiEscape, TerminateUnterminatedLiterals: params.TerminateUnterminatedLiterals, }, printer.PrintHandlers{}, nil) } func (s *Session) handleEmit(ctx context.Context, params *EmitParams) (*EmitResponse, error) { program, options, err := s.getEmitOptions(params) if err != nil { return nil, err } var outputFiles map[string]string sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } if requestfilesystem.HasFullFileSystem(sd.fileSystem) { outputFiles = make(map[string]string) var outputMu sync.Mutex options.WriteFile = func(fileName string, text string, _ *compiler.WriteFileData) error { outputMu.Lock() outputFiles[fileName] = text outputMu.Unlock() return nil } } else { options.WriteFile = func(fileName string, text string, _ *compiler.WriteFileData) error { return s.snapshotHost.FS().WriteFile(fileName, text) } } result, err := emitProgram(ctx, program, options) if err != nil { return nil, err } emittedFiles := slices.Clone(result.EmittedFiles) if emittedFiles == nil { emittedFiles = []string{} } emittedFilesContents := []string{} if outputFiles != nil { emittedFilesContents = make([]string, len(emittedFiles)) for i, fileName := range emittedFiles { emittedFilesContents[i] = outputFiles[fileName] } } return &EmitResponse{ EmitSkipped: result.EmitSkipped, Diagnostics: nonNilDiagnostics(result.Diagnostics), EmittedFiles: emittedFiles, EmittedFilesContents: emittedFilesContents, }, nil } func (s *Session) handleEmitToString(ctx context.Context, params *EmitParams) (*EmitOutputResponse, error) { program, options, err := s.getEmitOptions(params) if err != nil { return nil, err } return emitToOutput(ctx, program, options) } func (s *Session) handleSelectedFilesEmit(ctx context.Context, params *SelectedFilesEmitParams, emitOnly compiler.EmitOnly) (*EmitOutputResponse, error) { program, err := s.getEmitProgram(params.Snapshot, params.Project) if err != nil { return nil, err } if params.Files == nil { return nil, fmt.Errorf("%w: files is required", ErrClientError) } targetSourceFiles := make([]*ast.SourceFile, 0, len(params.Files)) for _, file := range params.Files { sourceFile, err := s.resolveOptionalSourceFile(program, &file) if err != nil { return nil, err } targetSourceFiles = append(targetSourceFiles, sourceFile) } return emitToOutput(ctx, program, compiler.EmitOptions{ TargetSourceFiles: targetSourceFiles, EmitOnly: emitOnly, ForceEmit: true, }) } func emitToOutput(ctx context.Context, program *compiler.Program, options compiler.EmitOptions) (*EmitOutputResponse, error) { var mu sync.Mutex outputFiles := make([]*EmitOutputFile, 0) options.WriteFile = func(fileName string, text string, data *compiler.WriteFileData) error { var sourceFileName *string if data.SourceFile != nil { name := data.SourceFile.FileName() sourceFileName = &name } mu.Lock() outputFiles = append(outputFiles, &EmitOutputFile{FileName: fileName, Text: text, SourceFileName: sourceFileName}) mu.Unlock() return nil } result, err := emitProgram(ctx, program, options) if err != nil { return nil, err } slices.SortFunc(outputFiles, func(a, b *EmitOutputFile) int { return strings.Compare(a.FileName, b.FileName) }) return &EmitOutputResponse{ EmitSkipped: result.EmitSkipped, Diagnostics: nonNilDiagnostics(result.Diagnostics), OutputFiles: outputFiles, }, nil } func (s *Session) getEmitOptions(params *EmitParams) (*compiler.Program, compiler.EmitOptions, error) { program, err := s.getEmitProgram(params.Snapshot, params.Project) if err != nil { return nil, compiler.EmitOptions{}, err } emitOnly, err := getEmitOnly(params.EmitOnly) if err != nil { return nil, compiler.EmitOptions{}, err } return program, compiler.EmitOptions{ EmitOnly: emitOnly, }, nil } func (s *Session) getEmitProgram(snapshot SnapshotID, projectID project.ID) (*compiler.Program, error) { sd, err := s.getSnapshotData(snapshot) if err != nil { return nil, err } return sd.getProgram(projectID) } func getEmitOnly(value *uint32) (compiler.EmitOnly, error) { if value == nil { return compiler.EmitAll, nil } if *value > uint32(compiler.EmitOnlyDts) { return compiler.EmitAll, fmt.Errorf("%w: invalid emitOnly value: %d", ErrClientError, *value) } emitOnly := compiler.EmitOnly(*value) return emitOnly, nil } func emitProgram(ctx context.Context, program *compiler.Program, options compiler.EmitOptions) (*compiler.EmitResult, error) { result := program.Emit(ctx, options) if result != nil { return result, nil } if err := ctx.Err(); err != nil { return nil, err } return nil, errors.New("compiler emit returned nil result") } func nonNilDiagnostics(diags []*ast.Diagnostic) []*DiagnosticResponse { result := NewDiagnosticResponses(diags) if result == nil { return []*DiagnosticResponse{} } return result } // handleFormatNodeForInsertion formats a synthesized node with the correct indentation // for insertion at a specific position in an existing file. func (s *Session) handleFormatNodeForInsertion(ctx context.Context, params *FormatNodeForInsertionParams) (string, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return "", err } program, err := sd.getProgram(params.Project) if err != nil { return "", err } targetSourceFile, err := s.resolveOptionalSourceFile(program, ¶ms.File) if err != nil { return "", err } data, err := base64.StdEncoding.DecodeString(params.Data) if err != nil { return "", fmt.Errorf("%w: invalid base64 data: %w", ErrClientError, err) } node, err := encoder.DecodeNodes(data) if err != nil { return "", fmt.Errorf("%w: failed to decode AST: %w", ErrClientError, err) } pos := targetSourceFile.GetPositionMap().UTF16ToUTF8(int(params.Position)) formatOptions := sd.snapshot.UserPreferences().FormatCodeSettings newLine := formatOptions.NewLineCharacter factory := ast.NewNodeFactory(ast.NodeFactoryHooks{}) text, nodeWithPos := printer.PrintAndPositionNode(factory, node, nil, newLine, formatOptions.IndentSize, nil) syntheticFile := printer.CreateSyntheticSourceFile(factory, nodeWithPos, text, targetSourceFile.ParseOptions()) isAtLineStart := format.GetLineStartPositionForPosition(pos, targetSourceFile) == pos initialIndentation := format.GetIndentation(pos, targetSourceFile, formatOptions, isAtLineStart) var delta int if formatOptions.IndentSize != 0 && format.ShouldIndentChildNode(formatOptions, node, nil, nil) { delta = formatOptions.IndentSize } ctx = format.WithFormatCodeSettings(ctx, formatOptions, newLine) changes := format.FormatNodeGivenIndentation(ctx, nodeWithPos, syntheticFile, targetSourceFile.LanguageVariant, initialIndentation, delta) return core.ApplyBulkEdits(text, changes), nil } // handleGetIntrinsicType returns an intrinsic type (any, string, number, etc.). func (s *Session) handleGetIntrinsicType(ctx context.Context, params *GetIntrinsicTypeParams, getter func(*checker.Checker) *checker.Type) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t := getter(setup.checker) if t == nil { return nil, nil } return setup.sd.newTypeResponse(setup.projectID, t, setup.checker), nil } // handleGetWellKnownSymbols returns the handle ids of the per-checker singleton // symbols (unknown, undefined, arguments) so the client can identify them by id. func (s *Session) handleGetWellKnownSymbols(ctx context.Context, params *GetIntrinsicTypeParams) (*WellKnownSymbolsResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() unknownSymbol := setup.checker.GetUnknownSymbol() undefinedSymbol := setup.checker.GetUndefinedSymbol() argumentsSymbol := setup.checker.GetArgumentsSymbol() compilerdebug.Assert(unknownSymbol.Flags&ast.SymbolFlagsTransient != 0) compilerdebug.Assert(undefinedSymbol.Flags&ast.SymbolFlagsTransient != 0) compilerdebug.Assert(argumentsSymbol.Flags&ast.SymbolFlagsTransient != 0) unknown, _ := setup.sd.registerSymbol(unknownSymbol, setup.projectID) undefined, _ := setup.sd.registerSymbol(undefinedSymbol, setup.projectID) arguments, _ := setup.sd.registerSymbol(argumentsSymbol, setup.projectID) return &WellKnownSymbolsResponse{ Unknown: unknown, Undefined: undefined, Arguments: arguments, }, nil } // handleGetWellKnownSignatures returns the handle id of the per-checker unknown // signature so the client can identify it by id. func (s *Session) handleGetWellKnownSignatures(ctx context.Context, params *GetIntrinsicTypeParams) (*WellKnownSignaturesResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() return &WellKnownSignaturesResponse{ Unknown: setup.sd.registerSignature(setup.projectID, setup.checker.GetUnknownSignature()), }, nil } // handleIsContextSensitive returns whether a node is context-sensitive. func (s *Session) handleIsContextSensitive(ctx context.Context, params *GetContextualTypeParams) (bool, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return false, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return false, err } if node == nil { return false, nil } return setup.checker.IsContextSensitive(node), nil } // handleGetReturnTypeOfSignature returns the return type of a signature. func (s *Session) handleGetReturnTypeOfSignature(ctx context.Context, params *GetSignaturePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.resolveSignatureHandle(params.Signature) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetReturnTypeOfSignature(sig), setup.checker), nil } // handleGetRestTypeOfSignature returns the rest type of a signature. func (s *Session) handleGetRestTypeOfSignature(ctx context.Context, params *CheckerSignatureParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.resolveSignatureHandle(params.Signature) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetRestTypeOfSignature(sig), setup.checker), nil } // handleGetTypePredicateOfSignature returns the type predicate of a signature. // @gen-proto-nullable func (s *Session) handleGetTypePredicateOfSignature(ctx context.Context, params *CheckerSignatureParams) (*TypePredicateResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() sig, err := setup.resolveSignatureHandle(params.Signature) if err != nil { return nil, err } pred := setup.checker.GetTypePredicateOfSignature(sig) if pred == nil { return nil, nil } resp := &TypePredicateResponse{ Kind: int32(pred.Kind()), ParameterIndex: pred.ParameterIndex(), ParameterName: pred.ParameterName(), } if pred.Type() != nil { resp.Type = setup.sd.newTypeResponse(setup.projectID, pred.Type(), setup.checker) } return resp, nil } // handleIsArrayType returns whether a type is Array or ReadonlyArray. func (s *Session) handleIsArrayType(ctx context.Context, params *CheckerTypeParams) (bool, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return false, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return false, err } return setup.checker.IsArrayType(t), nil } // handleIsReadonlySymbol returns whether a symbol is a readonly symbol. func (s *Session) handleIsReadonlySymbol(ctx context.Context, params *CheckerSymbolParams) (bool, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return false, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return false, err } return setup.checker.IsReadonlySymbol(symbol), nil } // handleGetBaseTypes returns the base types of an interface/class type. // @gen-proto-nullable func (s *Session) handleGetBaseTypes(ctx context.Context, params *CheckerTypeParams) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } baseTypes := setup.checker.GetBaseTypes(t) if len(baseTypes) == 0 { return nil, nil } results := make([]*TypeResponse, len(baseTypes)) for i, bt := range baseTypes { results[i] = setup.sd.newTypeResponse(setup.projectID, bt, setup.checker) } return results, nil } // handleGetPropertiesOfType returns the properties of a type. // @gen-proto-nullable func (s *Session) handleGetPropertiesOfType(ctx context.Context, params *CheckerTypeParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } props := setup.checker.GetPropertiesOfType(t) if len(props) == 0 { return nil, nil } results := make([]*SymbolResponse, len(props)) for i, prop := range props { results[i] = setup.newSymbolResponse(prop) } return results, nil } // handleGetApparentPropertiesOfType returns the apparent properties of a type, // including CallableFunction or NewableFunction members where applicable. func (s *Session) handleGetApparentPropertiesOfType(ctx context.Context, params *GetTypePropertyParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } props := setup.checker.GetApparentProperties(t) results := make([]*SymbolResponse, len(props)) for i, prop := range props { results[i] = setup.newSymbolResponse(prop) } return results, nil } // handleGetApparentType returns the apparent type of a type. func (s *Session) handleGetApparentType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetApparentType(t), setup.checker), nil } // handleGetReducedType returns the reduced type of a type. func (s *Session) handleGetReducedType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetReducedType(t), setup.checker), nil } // handleGetIndexInfosOfType returns the index infos of a type. // @gen-proto-nullable func (s *Session) handleGetIndexInfosOfType(ctx context.Context, params *CheckerTypeParams) ([]*IndexInfoResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } infos := setup.checker.GetIndexInfosOfType(t) if len(infos) == 0 { return nil, nil } results := make([]*IndexInfoResponse, len(infos)) for i, info := range infos { results[i] = setup.newIndexInfoResponse(info) } return results, nil } func (s *Session) resolveIndexInfoRequest(ctx context.Context, params *GetIndexInfoOfTypeParams) (checkerSetup, *checker.Type, *checker.Type, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return checkerSetup{}, nil, nil, err } t, err := setup.resolveTypeHandle(params.Type) if err != nil { setup.done() return checkerSetup{}, nil, nil, err } var keyType *checker.Type switch checker.IndexKind(params.Kind) { case checker.IndexKindString: keyType = setup.checker.GetStringType() case checker.IndexKindNumber: keyType = setup.checker.GetNumberType() default: setup.done() return checkerSetup{}, nil, nil, fmt.Errorf("%w: invalid index kind %d", ErrClientError, params.Kind) } return setup, t, keyType, nil } // @gen-proto-nullable func (s *Session) handleGetIndexInfoOfType(ctx context.Context, params *GetIndexInfoOfTypeParams) (*IndexInfoResponse, error) { setup, t, keyType, err := s.resolveIndexInfoRequest(ctx, params) if err != nil { return nil, err } defer setup.done() return setup.newIndexInfoResponse(setup.checker.GetIndexInfoOfType(t, keyType)), nil } // handleGetConstraintOfTypeParameter returns the constraint of a type parameter. // @gen-proto-nullable func (s *Session) handleGetConstraintOfTypeParameter(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } constraint := setup.checker.GetConstraintOfTypeParameter(t) if constraint == nil { return nil, nil } return setup.sd.newTypeResponse(setup.projectID, constraint, setup.checker), nil } // handleGetDefaultFromTypeParameter returns the default type of a type parameter. // @gen-proto-nullable func (s *Session) handleGetDefaultFromTypeParameter(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetDefaultFromTypeParameter(t), setup.checker), nil } // handleGetBaseConstraintOfType returns the base constraint of an instantiable type. // @gen-proto-nullable func (s *Session) handleGetBaseConstraintOfType(ctx context.Context, params *CheckerTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } constraint := setup.checker.GetBaseConstraintOfType(t) if constraint == nil { return nil, nil } return setup.sd.newTypeResponse(setup.projectID, constraint, setup.checker), nil } // handleGetPropertyOfType returns a named property symbol of a type. // @gen-proto-nullable func (s *Session) handleGetPropertyOfType(ctx context.Context, params *GetPropertyOfTypeParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } prop := setup.checker.GetPropertyOfType(t, params.Name) if prop == nil { return nil, nil } return setup.newSymbolResponse(prop), nil } // @gen-proto-nullable func (s *Session) handleGetTypeOfPropertyOfType(ctx context.Context, params *GetPropertyOfTypeParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTypeOfPropertyOfType(t, params.Name), setup.checker), nil } // handleGetConstantValue returns the constant value of an enum member or const enum access. // @gen-proto-nullable func (s *Session) handleGetConstantValue(ctx context.Context, params *CheckerNodeParams) (*ConstantValueResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } if node == nil { return nil, nil } result := &ConstantValueResponse{} value := setup.checker.GetConstantValue(node) _, result.IsNumber = value.(jsnum.Number) result.Value = literalValueToJSON(value) return result, nil } // handleGetSignatureFromDeclaration returns the signature of a function-like declaration. func (s *Session) handleGetSignatureFromDeclaration(ctx context.Context, params *CheckerNodeParams) (*SignatureResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } return setup.newSignatureResponse(setup.checker.GetSignatureFromDeclaration(node)), nil } // handleGetExportSpecifierLocalTargetSymbol returns the local target symbol of an export specifier. // @gen-proto-nullable func (s *Session) handleGetExportSpecifierLocalTargetSymbol(ctx context.Context, params *CheckerNodeParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() node, err := setup.sd.resolveNodeHandle(setup.program, params.Location) if err != nil { return nil, err } if node == nil { return nil, nil } symbol := setup.checker.GetExportSpecifierLocalTargetSymbol(node) if symbol == nil { return nil, nil } return setup.newSymbolResponse(symbol), nil } // handleGetAliasedSymbol resolves an alias symbol to its target. func (s *Session) handleGetAliasedSymbol(ctx context.Context, params *CheckerSymbolParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } return setup.newSymbolResponse(setup.checker.GetAliasedSymbol(symbol)), nil } // handleGetFullyQualifiedName returns the fully qualified name of a symbol // (e.g. `"/path/to/module".Namespace.Name`). func (s *Session) handleGetFullyQualifiedName(ctx context.Context, params *CheckerSymbolParams) (string, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return "", err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return "", err } if symbol == nil { return "", nil } return setup.checker.GetFullyQualifiedName(symbol), nil } // handleGetImmediateAliasedSymbol resolves one level of alias indirection. // @gen-proto-nullable func (s *Session) handleGetImmediateAliasedSymbol(ctx context.Context, params *CheckerSymbolParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } if symbol == nil { return nil, nil } aliased := setup.checker.GetImmediateAliasedSymbol(symbol) if aliased == nil { return nil, nil } return setup.newSymbolResponse(aliased), nil } // handleGetTargetSymbol returns the target symbol if the symbol is instantiated, // otherwise returns the provided symbol. func (s *Session) handleMethodGetTargetSymbol(ctx context.Context, params *CheckerSymbolParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } return setup.newSymbolResponse(setup.checker.GetTargetSymbol(symbol)), nil } func (s *Session) handleGetExportSymbolOfSymbolForChecker(ctx context.Context, params *CheckerSymbolParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } return setup.newSymbolResponse(setup.checker.GetExportSymbolOfSymbol(symbol)), nil } // handleGetExportsOfModule returns the resolved exports of a module symbol, // including those introduced by `export *` and re-exports. // @gen-proto-nullable func (s *Session) handleGetExportsOfModule(ctx context.Context, params *CheckerSymbolParams) ([]*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } if symbol == nil { return nil, nil } exports := setup.checker.GetExportsOfModule(symbol) if len(exports) == 0 { return nil, nil } slices.SortFunc(exports, setup.checker.CompareSymbols) results := make([]*SymbolResponse, len(exports)) for i, exp := range exports { results[i] = setup.newSymbolResponse(exp) } return results, nil } // handleGetMemberInModuleExports returns an export by name from a module symbol. // @gen-proto-nullable func (s *Session) handleGetMemberInModuleExports(ctx context.Context, params *GetMemberInModuleExportsParams) (*SymbolResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } if symbol == nil { return nil, nil } member := setup.checker.TryGetMemberInModuleExports(params.Name, symbol) if member == nil { return nil, nil } return setup.newSymbolResponse(member), nil } // handleGetJSDocTags returns the JSDoc tags of a symbol as structured name/text pairs. // @gen-proto-nullable func (s *Session) handleGetJSDocTags(ctx context.Context, params *CheckerSymbolParams) ([]*JSDocTagInfo, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } if symbol == nil { return nil, nil } tags := ls.GetSymbolJSDocTags(symbol) if len(tags) == 0 { return nil, nil } results := make([]*JSDocTagInfo, len(tags)) for i, tag := range tags { results[i] = &JSDocTagInfo{Name: tag.Name, Text: tag.Text} } return results, nil } // handleGetDocumentationComment returns the rendered documentation comment of a symbol as plain text. func (s *Session) handleGetDocumentationComment(ctx context.Context, params *CheckerSymbolParams) (string, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return "", err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return "", err } if symbol == nil { return "", nil } return ls.GetSymbolDocumentationComment(setup.checker, symbol), nil } // handleGetTypeArguments returns the type arguments of a type reference. // @gen-proto-nullable func (s *Session) handleGetTypeArguments(ctx context.Context, params *CheckerTypeParams) ([]*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.resolveTypeHandle(params.Type) if err != nil { return nil, err } typeArgs := setup.checker.GetTypeArguments(t) if len(typeArgs) == 0 { return nil, nil } results := make([]*TypeResponse, len(typeArgs)) for i, ta := range typeArgs { results[i] = setup.sd.newTypeResponse(setup.projectID, ta, setup.checker) } return results, nil } func (s *Session) handleGetTrueTypeOfConditionalType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.sd.resolveTypeHandle(params.Project, params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetTrueTypeOfConditionalType(t), setup.checker), nil } func (s *Session) handleGetFalseTypeOfConditionalType(ctx context.Context, params *GetTypePropertyParams) (*TypeResponse, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() t, err := setup.sd.resolveTypeHandle(params.Project, params.Type) if err != nil { return nil, err } return setup.sd.newTypeResponse(setup.projectID, setup.checker.GetFalseTypeOfConditionalType(t), setup.checker), nil } func (sd *snapshotData) resolveNodeHandle(program *compiler.Program, handle NodeHandle) (*ast.Node, error) { s := string(handle) // Format: "index.kind.path" — we need index and path, kind is informational only. firstDot := strings.IndexByte(s, '.') if firstDot == -1 { return nil, fmt.Errorf("%w: invalid node handle %q", ErrClientError, handle) } secondDot := strings.IndexByte(s[firstDot+1:], '.') if secondDot == -1 { return nil, fmt.Errorf("%w: invalid node handle %q", ErrClientError, handle) } secondDot += firstDot + 1 // adjust to absolute index idx, err := strconv.ParseUint(s[:firstDot], 10, 32) if err != nil { return nil, fmt.Errorf("%w: invalid node handle %q: %w", ErrClientError, handle, err) } path := tspath.Path(s[secondDot+1:]) sourceFile := program.GetSourceFileByPath(path) if sourceFile == nil { return nil, fmt.Errorf("%w: node handle %q could not be resolved (file may not be loaded or handle may be stale)", ErrClientError, handle) } table := encoder.GetNodeIndexTable(sourceFile) if table != nil && idx < uint64(len(table.Nodes)) { node := table.Nodes[idx] if node != nil { return node, nil } } return nil, fmt.Errorf("%w: node handle %q could not be resolved (file may not be loaded or handle may be stale)", ErrClientError, handle) } // computeSnapshotChanges computes the per-project source file differences between // two snapshots. It uses DiffOrderedMaps on projects to find changed/removed projects, // then DiffMaps on FilesByPath for each changed project to collect file-level changes. func computeSnapshotChanges(prev *project.Snapshot, next *project.Snapshot) *SnapshotChanges { prevProjects := prev.ProjectCollection.ProjectsByID() nextProjects := next.ProjectCollection.ProjectsByID() var changes SnapshotChanges collections.DiffOrderedMaps( prevProjects, nextProjects, // onAdded: new project — nothing to retain from previous snapshot. func(_ project.ID, _ *project.Project) {}, // onRemoved: project removed entirely. func(_ project.ID, oldProj *project.Project) { changes.RemovedProjects = append(changes.RemovedProjects, oldProj.ID()) }, // onModified: project changed, diff its files. func(_ project.ID, oldProj *project.Project, newProj *project.Project) { if oldProj.GetProgram() == newProj.GetProgram() { return } var oldFiles, newFiles map[tspath.Path]*ast.SourceFile if p := oldProj.GetProgram(); p != nil { oldFiles = p.FilesByPath() } if p := newProj.GetProgram(); p != nil { newFiles = p.FilesByPath() } var projectChanges ProjectFileChanges core.DiffMaps( oldFiles, newFiles, nil, // onAdded: new file in project, not a change. func(path tspath.Path, _ *ast.SourceFile) { projectChanges.DeletedFiles = append(projectChanges.DeletedFiles, path) }, func(path tspath.Path, _ *ast.SourceFile, _ *ast.SourceFile) { projectChanges.ChangedFiles = append(projectChanges.ChangedFiles, path) }, ) if len(projectChanges.ChangedFiles) > 0 || len(projectChanges.DeletedFiles) > 0 { if changes.ChangedProjects == nil { changes.ChangedProjects = make(map[project.ID]*ProjectFileChanges) } changes.ChangedProjects[newProj.ID()] = &projectChanges } }, ) return &changes } func (s *Session) createSnapshotResponse(snapshot *project.Snapshot, base *project.Snapshot, request *SnapshotRequestChangesParams) *CreateSnapshotResponse { operation := s.createSnapshotOperationResponse(snapshot, request) if base == nil { projects := snapshot.ProjectCollection.Projects() projectResponses := make([]*ProjectResponse, 0, len(projects)) for _, proj := range projects { if proj.CommandLine != nil { projectResponses = append(projectResponses, NewProjectResponse(proj)) } } return &CreateSnapshotResponse{Snapshot: snapshotHandle(snapshot), Projects: projectResponses, Operation: operation} } projectResponses := make([]*ProjectResponse, 0) collections.DiffOrderedMaps( base.ProjectCollection.ProjectsByID(), snapshot.ProjectCollection.ProjectsByID(), func(_ project.ID, proj *project.Project) { if proj.CommandLine != nil { projectResponses = append(projectResponses, NewProjectResponse(proj)) } }, func(_ project.ID, _ *project.Project) {}, func(_ project.ID, oldProj *project.Project, newProj *project.Project) { if oldProj != newProj && newProj.CommandLine != nil { projectResponses = append(projectResponses, NewProjectResponse(newProj)) } }, ) return &CreateSnapshotResponse{ Snapshot: snapshotHandle(snapshot), Projects: projectResponses, Changes: computeSnapshotChanges(base, snapshot), Operation: operation, } } func (s *Session) createSnapshotOperationResponse(snapshot *project.Snapshot, request *SnapshotRequestChangesParams) *SnapshotOperationResponse { operation := &SnapshotOperationResponse{} if request == nil { return operation } if request.CreatePrograms != nil { createdPrograms := snapshot.CreatedPrograms() if len(createdPrograms) != len(request.CreatePrograms) { panic("created program result count does not match request") } results := make([]project.SyntheticProjectID, len(createdPrograms)) for i, createdProgram := range createdPrograms { programID, ok := createdProgram.ID().Synthetic() if !ok { panic("created program has non-synthetic project ID") } results[i] = programID } operation.CreatedPrograms = &results } if request.OpenFiles != nil { results := make([]*OpenedFileOperationResult, len(request.OpenFiles)) for i, file := range request.OpenFiles { project := snapshot.GetDefaultProject(file.ToURI(s.GetCurrentDirectory())) if project == nil { panic("no project found for opened file " + file.ToAbsoluteFileName(s.GetCurrentDirectory())) } results[i] = &OpenedFileOperationResult{Project: project.ID()} } operation.OpenedFiles = &results } return operation } // Close closes the session and releases all active snapshots, // regardless of their ref counts. func (s *Session) Close() { s.closeOnce.Do(func() { s.releaseLanguageServerRefs() s.releaseSourceFileLeases() s.snapshotsMu.Lock() snapshots := make([]*project.Snapshot, 0, len(s.snapshots)) for _, sd := range s.snapshots { snapshots = append(snapshots, sd.snapshot) } clear(s.snapshots) s.snapshotsMu.Unlock() for _, snapshot := range snapshots { snapshot.Deref() } if s.ownsSnapshotHost { s.snapshotHost.Close() } s.batchResponsePages.Clear() }) } func (s *Session) releaseLanguageServerRefs() { if s.projectSession == nil { return } s.languageServerUpdateMu.Lock() defer s.languageServerUpdateMu.Unlock() if s.openProjects.Len() == 0 && s.openFiles.Len() == 0 && s.createdPrograms.Len() == 0 { return } apiRequest := &project.APISnapshotRequest{} if s.openProjects.Len() > 0 { apiRequest.CloseProjects = s.openProjects.Clone() } if s.openFiles.Len() > 0 { apiRequest.CloseFiles = s.openFiles.Clone() } if s.createdPrograms.Len() > 0 { apiRequest.RemovePrograms = collections.NewSetWithSizeHint[project.SyntheticProjectID](s.createdPrograms.Len()) for programID := range s.createdPrograms.Keys() { apiRequest.RemovePrograms.Add(programID) } } snapshot, err := s.projectSession.APIUpdate(s.withLocale(context.Background()), project.FileChangeSummary{}, apiRequest) if err != nil { return } snapshot.Deref() s.openProjects.Clear() s.openFiles.Clear() s.createdPrograms.Clear() } func formatSessionID(id uint64) string { return fmt.Sprintf("api-session-%d", id) } // toPath converts a file name to a normalized path. func (s *Session) toPath(fileName string) tspath.Path { return tspath.ToPath(fileName, s.GetCurrentDirectory(), s.useCaseSensitiveFileNames()) } // toFileChangeSummary converts API file changes to a project.FileChangeSummary. func (s *Session) toFileChangeSummary(changes *FileNotifications) project.FileChangeSummary { if changes == nil { return project.FileChangeSummary{} } var summary project.FileChangeSummary if changes.InvalidateAll { summary.InvalidateAll = true summary.IncludesWatchChangeOutsideNodeModules = true return summary } cwd := s.GetCurrentDirectory() for _, doc := range changes.Changed { uri := doc.ToURI(cwd) summary.Changed.Add(uri) } for _, doc := range changes.Created { uri := doc.ToURI(cwd) summary.Created.Add(uri) } for _, doc := range changes.Deleted { uri := doc.ToURI(cwd) summary.Deleted.Add(uri) } if summary.Changed.Len()+summary.Created.Len()+summary.Deleted.Len() > 0 { summary.IncludesWatchChangeOutsideNodeModules = true } return summary } func (s *Session) getDiagnostics(ctx context.Context, params *GetDiagnosticsParams, getter func(*compiler.Program, context.Context, *ast.SourceFile) []*ast.Diagnostic) ([]*DiagnosticResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } if params.Files != nil { var allDiags []*ast.Diagnostic for _, file := range params.Files { sourceFile, err := s.resolveOptionalSourceFile(program, &file) if err != nil { return nil, err } allDiags = append(allDiags, getter(program, ctx, sourceFile)...) } return NewDiagnosticResponses(allDiags), nil } return NewDiagnosticResponses(getter(program, ctx, nil)), nil } // @gen-proto-nullable func (s *Session) handleGetSyntacticDiagnostics(ctx context.Context, params *GetDiagnosticsParams) ([]*DiagnosticResponse, error) { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeDiagnostics) return s.getDiagnostics(ctx, params, (*compiler.Program).GetSyntacticDiagnostics) } // @gen-proto-nullable func (s *Session) handleGetBindDiagnostics(ctx context.Context, params *GetDiagnosticsParams) ([]*DiagnosticResponse, error) { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeDiagnostics) return s.getDiagnostics(ctx, params, (*compiler.Program).GetBindDiagnostics) } // @gen-proto-nullable func (s *Session) handleGetSemanticDiagnostics(ctx context.Context, params *GetDiagnosticsParams) ([]*DiagnosticResponse, error) { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeDiagnostics) return s.getDiagnostics(ctx, params, (*compiler.Program).GetSemanticDiagnostics) } // @gen-proto-nullable func (s *Session) handleGetSuggestionDiagnostics(ctx context.Context, params *GetDiagnosticsParams) ([]*DiagnosticResponse, error) { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeDiagnostics) return s.getDiagnostics(ctx, params, (*compiler.Program).GetSuggestionDiagnostics) } // @gen-proto-nullable func (s *Session) handleGetDeclarationDiagnostics(ctx context.Context, params *GetDiagnosticsParams) ([]*DiagnosticResponse, error) { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeDiagnostics) return s.getDiagnostics(ctx, params, (*compiler.Program).GetDeclarationDiagnostics) } // handleGetConfigFileParsingDiagnostics returns config file parsing diagnostics. // @gen-proto-nullable func (s *Session) handleGetConfigFileParsingDiagnostics(ctx context.Context, params *GetProjectDiagnosticsParams) ([]*DiagnosticResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } diags := program.GetConfigFileParsingDiagnostics() return NewDiagnosticResponses(diags), nil } // handleGetProgramDiagnostics returns program-wide diagnostics, including options diagnostics. // @gen-proto-nullable func (s *Session) handleGetProgramDiagnostics(ctx context.Context, params *GetProjectDiagnosticsParams) ([]*DiagnosticResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } diags := program.GetProgramDiagnostics() return NewDiagnosticResponses(diags), nil } // handleGetGlobalDiagnostics returns global (non-file-specific) semantic diagnostics. // @gen-proto-nullable func (s *Session) handleGetGlobalDiagnostics(ctx context.Context, params *GetProjectDiagnosticsParams) ([]*DiagnosticResponse, error) { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeDiagnostics) sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } proj, err := sd.getProject(params.Project) if err != nil { return nil, err } program := proj.GetProgram() if program == nil { return nil, fmt.Errorf("%w: project has no program", ErrClientError) } // Global diagnostics are accumulated lazily by the project's checker pool as // files are checked. Force a full semantic pass so any global (non-file-specific) // diagnostics are produced; otherwise this would return an empty result for // projects using an external checker pool (the typical API case), since // compiler.Program.GetGlobalDiagnostics only reports for the internal pool. program.GetSemanticDiagnostics(ctx, nil) diags := core.Filter(proj.GetProjectDiagnostics(ctx), func(d *ast.Diagnostic) bool { return d.File() == nil }) return NewDiagnosticResponses(diags), nil } // resolveOptionalSourceFile resolves an optional DocumentIdentifier to a source file. // Returns nil if the identifier is nil (meaning all files). func (s *Session) resolveOptionalSourceFile(program *compiler.Program, file *DocumentIdentifier) (*ast.SourceFile, error) { if file == nil { return nil, nil } sourceFile := program.GetSourceFile(file.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, file) } return sourceFile, nil } // handleGetReferencesToSymbolInFile returns node handles for all identifiers in a file that reference the given symbol. func (s *Session) handleGetReferencesToSymbolInFile(ctx context.Context, params *GetReferencesToSymbolInFileParams) ([]NodeHandle, error) { setup, err := s.setupChecker(ctx, params.Snapshot, params.Project) if err != nil { return nil, err } defer setup.done() symbol, err := setup.resolveSymbolHandle(params.Symbol) if err != nil { return nil, err } if symbol == nil { return nil, nil } sourceFile := setup.program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, fmt.Errorf("%w: source file not found: %v", ErrClientError, params.File) } nodes := setup.checker.GetReferencesToSymbolInFile(sourceFile, symbol) result := make([]NodeHandle, len(nodes)) for i, node := range nodes { result[i] = setup.sd.nodeHandleFrom(node) } return result, nil } // @gen-proto-nullable func (s *Session) handleGetSignatureUsages(ctx context.Context, params *GetSignatureUsagesParams) ([]SignatureUsageResponse, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } signatureDecl, err := sd.resolveNodeHandle(program, params.SignatureDecl) if err != nil { return nil, err } if signatureDecl == nil { return nil, nil } langSvc, err := s.setupLanguageService(sd.snapshot, program, params.Project, "") if err != nil { return nil, err } usages := langSvc.GetSignatureUsages(ctx, signatureDecl) if usages == nil { return nil, nil } result := make([]SignatureUsageResponse, 0, len(usages)) for _, u := range usages { entry := SignatureUsageResponse{ Name: sd.nodeHandleFrom(u.Name), } if u.Call != nil { entry.Call = sd.nodeHandleFrom(u.Call) } result = append(result, entry) } return result, nil } // handleGetCompletionsAtPosition returns completions at a position in a document. // @gen-proto-nullable func (s *Session) handleGetCompletionsAtPosition(ctx context.Context, params *GetCompletionsAtPositionParams) (*CompletionInfoResponse, error) { if params.IncludeSymbol { ctx = core.WithCheckerLifetime(ctx, core.CheckerLifetimeAPI) } sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } run := func(snapshot *project.Snapshot, program *compiler.Program) (*ls.CompletionList, error) { sourceFile := program.GetSourceFile(params.File.ToFileName()) if sourceFile == nil { return nil, nil } langSvc, e := s.setupLanguageService(snapshot, program, params.Project, "") if e != nil { return nil, e } internalPos := sourceFile.GetPositionMap().UTF16ToUTF8(int(params.Position)) return langSvc.GetCompletionsAtPosition(ctx, sourceFile, internalPos, params.TriggerCharacter, params.IncludeSymbol) } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } result, err := run(sd.snapshot, program) if errors.Is(err, ls.ErrNeedsAutoImports) { preparedSnapshot := s.snapshotHost.CloneSnapshotWithAutoImports(ctx, sd.snapshot, params.File.ToURI(s.GetCurrentDirectory()), nil) if s.projectSession != nil { s.projectSession.TryAdoptSnapshotInBackground(sd.snapshot, preparedSnapshot) } defer preparedSnapshot.Deref() if err = ctx.Err(); err != nil { return nil, err } projectID := params.Project proj := preparedSnapshot.ProjectCollection.GetProject(projectID) if proj == nil { return nil, fmt.Errorf("%w: project %s not found", ErrClientError, projectID) } program = proj.GetProgram() if program == nil { return nil, fmt.Errorf("%w: project has no program", ErrClientError) } result, err = run(preparedSnapshot, program) } if err != nil || result == nil { return nil, err } entries := make([]*CompletionEntryResponse, 0, len(result.Items)) for _, item := range result.Items { entry := &CompletionEntryResponse{ Name: item.Label, SortText: item.SortText, InsertText: item.InsertText, FilterText: item.FilterText, Detail: item.Detail, } if item.Kind != nil { entry.Kind = uint32(*item.Kind) } if item.LabelDetails != nil { entry.LabelDetails = &CompletionEntryLabelDetailsResponse{ Detail: item.LabelDetails.Detail, Description: item.LabelDetails.Description, } } if item.Symbol != nil { entry.Symbol = sd.newSymbolResponse(item.Symbol, params.Project) } entries = append(entries, entry) } return &CompletionInfoResponse{ IsIncomplete: result.IsIncomplete, Entries: entries, }, nil } // handleGetReferencedSymbolsForNode returns node handles for all references found at a node. // @gen-proto-nullable func (s *Session) handleGetReferencedSymbolsForNode(ctx context.Context, params *GetReferencedSymbolsForNodeParams) ([]ReferencedSymbolEntry, error) { sd, err := s.getSnapshotData(params.Snapshot) if err != nil { return nil, err } program, err := sd.getProgram(params.Project) if err != nil { return nil, err } node, err := sd.resolveNodeHandle(program, params.Node) if err != nil { return nil, err } if node == nil { return nil, nil } langSvc, err := s.setupLanguageService(sd.snapshot, program, params.Project, "") if err != nil { return nil, err } sourceFiles := program.GetSourceFiles() entries := langSvc.GetReferencedSymbolsForNode(ctx, params.Position, node, sourceFiles) if entries == nil { return nil, nil } var result []ReferencedSymbolEntry for _, entry := range entries { defNode := entry.DefinitionNode() if defNode == nil { continue } var refs []NodeHandle for _, ref := range entry.References() { if ref.IsNodeEntry() { refs = append(refs, sd.nodeHandleFrom(ref.Node())) } } re := ReferencedSymbolEntry{ Definition: sd.nodeHandleFrom(defNode), References: refs, } if sym := entry.DefinitionSymbol(); sym != nil { re.Symbol = sd.newSymbolResponse(sym, params.Project) } result = append(result, re) } return result, nil }