+++ /dev/null
-// Copyright 2019 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package lsp
-
-import (
- "bytes"
- "context"
- "fmt"
- "io"
- "os"
- "path"
- "path/filepath"
- "strings"
- "sync"
-
- "golang.org/x/tools/internal/event"
- "golang.org/x/tools/internal/jsonrpc2"
- "golang.org/x/tools/internal/lsp/debug"
- "golang.org/x/tools/internal/lsp/protocol"
- "golang.org/x/tools/internal/lsp/source"
- "golang.org/x/tools/internal/span"
- errors "golang.org/x/xerrors"
-)
-
-func (s *Server) initialize(ctx context.Context, params *protocol.ParamInitialize) (*protocol.InitializeResult, error) {
- s.stateMu.Lock()
- if s.state >= serverInitializing {
- defer s.stateMu.Unlock()
- return nil, errors.Errorf("%w: initialize called while server in %v state", jsonrpc2.ErrInvalidRequest, s.state)
- }
- s.state = serverInitializing
- s.stateMu.Unlock()
-
- s.progress.supportsWorkDoneProgress = params.Capabilities.Window.WorkDoneProgress
-
- options := s.session.Options()
- defer func() { s.session.SetOptions(options) }()
-
- if err := s.handleOptionResults(ctx, source.SetOptions(options, params.InitializationOptions)); err != nil {
- return nil, err
- }
- options.ForClientCapabilities(params.Capabilities)
-
- folders := params.WorkspaceFolders
- if len(folders) == 0 {
- if params.RootURI != "" {
- folders = []protocol.WorkspaceFolder{{
- URI: string(params.RootURI),
- Name: path.Base(params.RootURI.SpanURI().Filename()),
- }}
- }
- }
- for _, folder := range folders {
- uri := span.URIFromURI(folder.URI)
- if !uri.IsFile() {
- continue
- }
- s.pendingFolders = append(s.pendingFolders, folder)
- }
- // gopls only supports URIs with a file:// scheme, so if we have no
- // workspace folders with a supported scheme, fail to initialize.
- if len(folders) > 0 && len(s.pendingFolders) == 0 {
- return nil, fmt.Errorf("unsupported URI schemes: %v (gopls only supports file URIs)", folders)
- }
-
- var codeActionProvider interface{} = true
- if ca := params.Capabilities.TextDocument.CodeAction; len(ca.CodeActionLiteralSupport.CodeActionKind.ValueSet) > 0 {
- // If the client has specified CodeActionLiteralSupport,
- // send the code actions we support.
- //
- // Using CodeActionOptions is only valid if codeActionLiteralSupport is set.
- codeActionProvider = &protocol.CodeActionOptions{
- CodeActionKinds: s.getSupportedCodeActions(),
- }
- }
- var renameOpts interface{} = true
- if r := params.Capabilities.TextDocument.Rename; r.PrepareSupport {
- renameOpts = protocol.RenameOptions{
- PrepareProvider: r.PrepareSupport,
- }
- }
-
- if st := params.Capabilities.TextDocument.SemanticTokens; st != nil {
- rememberToks(st.TokenTypes, st.TokenModifiers)
- }
-
- goplsVer := &bytes.Buffer{}
- debug.PrintVersionInfo(ctx, goplsVer, true, debug.PlainText)
-
- return &protocol.InitializeResult{
- Capabilities: protocol.ServerCapabilities{
- CallHierarchyProvider: true,
- CodeActionProvider: codeActionProvider,
- CompletionProvider: protocol.CompletionOptions{
- TriggerCharacters: []string{"."},
- },
- DefinitionProvider: true,
- TypeDefinitionProvider: true,
- ImplementationProvider: true,
- DocumentFormattingProvider: true,
- DocumentSymbolProvider: true,
- WorkspaceSymbolProvider: true,
- ExecuteCommandProvider: protocol.ExecuteCommandOptions{
- Commands: options.SupportedCommands,
- },
- FoldingRangeProvider: true,
- HoverProvider: true,
- DocumentHighlightProvider: true,
- DocumentLinkProvider: protocol.DocumentLinkOptions{},
- ReferencesProvider: true,
- RenameProvider: renameOpts,
- SignatureHelpProvider: protocol.SignatureHelpOptions{
- TriggerCharacters: []string{"(", ","},
- },
- TextDocumentSync: &protocol.TextDocumentSyncOptions{
- Change: protocol.Incremental,
- OpenClose: true,
- Save: protocol.SaveOptions{
- IncludeText: false,
- },
- },
- Workspace: protocol.WorkspaceGn{
- WorkspaceFolders: protocol.WorkspaceFoldersGn{
- Supported: true,
- ChangeNotifications: "workspace/didChangeWorkspaceFolders",
- },
- },
- },
- ServerInfo: struct {
- Name string `json:"name"`
- Version string `json:"version,omitempty"`
- }{
- Name: "gopls",
- Version: goplsVer.String(),
- },
- }, nil
-}
-
-func (s *Server) initialized(ctx context.Context, params *protocol.InitializedParams) error {
- s.stateMu.Lock()
- if s.state >= serverInitialized {
- defer s.stateMu.Unlock()
- return errors.Errorf("%w: initalized called while server in %v state", jsonrpc2.ErrInvalidRequest, s.state)
- }
- s.state = serverInitialized
- s.stateMu.Unlock()
-
- for _, not := range s.notifications {
- s.client.ShowMessage(ctx, not)
- }
- s.notifications = nil
-
- options := s.session.Options()
- defer func() { s.session.SetOptions(options) }()
-
- if err := s.addFolders(ctx, s.pendingFolders); err != nil {
- return err
- }
- s.pendingFolders = nil
-
- if options.ConfigurationSupported && options.DynamicConfigurationSupported {
- registrations := []protocol.Registration{
- {
- ID: "workspace/didChangeConfiguration",
- Method: "workspace/didChangeConfiguration",
- },
- {
- ID: "workspace/didChangeWorkspaceFolders",
- Method: "workspace/didChangeWorkspaceFolders",
- },
- }
- if options.SemanticTokens {
- registrations = append(registrations, semanticTokenRegistrations()...)
-
- }
- if err := s.client.RegisterCapability(ctx, &protocol.RegistrationParams{
- Registrations: registrations,
- }); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (s *Server) addFolders(ctx context.Context, folders []protocol.WorkspaceFolder) error {
- originalViews := len(s.session.Views())
- viewErrors := make(map[span.URI]error)
-
- var wg sync.WaitGroup
- if s.session.Options().VerboseWorkDoneProgress {
- work := s.progress.start(ctx, DiagnosticWorkTitle(FromInitialWorkspaceLoad), "Calculating diagnostics for initial workspace load...", nil, nil)
- defer func() {
- go func() {
- wg.Wait()
- work.end("Done.")
- }()
- }()
- }
- dirsToWatch := map[span.URI]struct{}{}
- for _, folder := range folders {
- uri := span.URIFromURI(folder.URI)
- // Ignore non-file URIs.
- if !uri.IsFile() {
- continue
- }
- work := s.progress.start(ctx, "Setting up workspace", "Loading packages...", nil, nil)
- snapshot, release, err := s.addView(ctx, folder.Name, uri)
- if err != nil {
- viewErrors[uri] = err
- work.end(fmt.Sprintf("Error loading packages: %s", err))
- continue
- }
- var swg sync.WaitGroup
- swg.Add(1)
- go func() {
- defer swg.Done()
- snapshot.AwaitInitialized(ctx)
- work.end("Finished loading packages.")
- }()
-
- for _, dir := range snapshot.WorkspaceDirectories(ctx) {
- dirsToWatch[dir] = struct{}{}
- }
-
- // Print each view's environment.
- buf := &bytes.Buffer{}
- if err := snapshot.WriteEnv(ctx, buf); err != nil {
- viewErrors[uri] = err
- continue
- }
- event.Log(ctx, buf.String())
-
- // Diagnose the newly created view.
- wg.Add(1)
- go func() {
- s.diagnoseDetached(snapshot)
- swg.Wait()
- release()
- wg.Done()
- }()
- }
- // Register for file watching notifications, if they are supported.
- s.watchedDirectoriesMu.Lock()
- err := s.registerWatchedDirectoriesLocked(ctx, dirsToWatch)
- s.watchedDirectoriesMu.Unlock()
- if err != nil {
- return err
- }
- if len(viewErrors) > 0 {
- errMsg := fmt.Sprintf("Error loading workspace folders (expected %v, got %v)\n", len(folders), len(s.session.Views())-originalViews)
- for uri, err := range viewErrors {
- errMsg += fmt.Sprintf("failed to load view for %s: %v\n", uri, err)
- }
- return s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
- Type: protocol.Error,
- Message: errMsg,
- })
- }
- return nil
-}
-
-// updateWatchedDirectories compares the current set of directories to watch
-// with the previously registered set of directories. If the set of directories
-// has changed, we unregister and re-register for file watching notifications.
-// updatedSnapshots is the set of snapshots that have been updated.
-func (s *Server) updateWatchedDirectories(ctx context.Context, updatedSnapshots map[source.View]source.Snapshot) error {
- dirsToWatch := map[span.URI]struct{}{}
- seenViews := map[source.View]struct{}{}
-
- // Collect all of the workspace directories from the updated snapshots.
- for _, snapshot := range updatedSnapshots {
- seenViews[snapshot.View()] = struct{}{}
- for _, dir := range snapshot.WorkspaceDirectories(ctx) {
- dirsToWatch[dir] = struct{}{}
- }
- }
- // Not all views were necessarily updated, so check the remaining views.
- for _, view := range s.session.Views() {
- if _, ok := seenViews[view]; ok {
- continue
- }
- snapshot, release := view.Snapshot(ctx)
- for _, dir := range snapshot.WorkspaceDirectories(ctx) {
- dirsToWatch[dir] = struct{}{}
- }
- release()
- }
-
- s.watchedDirectoriesMu.Lock()
- defer s.watchedDirectoriesMu.Unlock()
-
- // Nothing to do if the set of workspace directories is unchanged.
- if equalURISet(s.watchedDirectories, dirsToWatch) {
- return nil
- }
-
- // If the set of directories to watch has changed, register the updates and
- // unregister the previously watched directories. This ordering avoids a
- // period where no files are being watched. Still, if a user makes on-disk
- // changes before these updates are complete, we may miss them for the new
- // directories.
- if s.watchRegistrationCount > 0 {
- prevID := s.watchRegistrationCount - 1
- if err := s.registerWatchedDirectoriesLocked(ctx, dirsToWatch); err != nil {
- return err
- }
- return s.client.UnregisterCapability(ctx, &protocol.UnregistrationParams{
- Unregisterations: []protocol.Unregistration{{
- ID: watchedFilesCapabilityID(prevID),
- Method: "workspace/didChangeWatchedFiles",
- }},
- })
- }
- return nil
-}
-
-func watchedFilesCapabilityID(id uint64) string {
- return fmt.Sprintf("workspace/didChangeWatchedFiles-%d", id)
-}
-
-func equalURISet(m1, m2 map[span.URI]struct{}) bool {
- if len(m1) != len(m2) {
- return false
- }
- for k := range m1 {
- _, ok := m2[k]
- if !ok {
- return false
- }
- }
- return true
-}
-
-// registerWatchedDirectoriesLocked sends the workspace/didChangeWatchedFiles
-// registrations to the client and updates s.watchedDirectories.
-func (s *Server) registerWatchedDirectoriesLocked(ctx context.Context, dirs map[span.URI]struct{}) error {
- if !s.session.Options().DynamicWatchedFilesSupported {
- return nil
- }
- for k := range s.watchedDirectories {
- delete(s.watchedDirectories, k)
- }
- // Work-around microsoft/vscode#100870 by making sure that we are,
- // at least, watching the user's entire workspace. This will still be
- // applied to every folder in the workspace.
- watchers := []protocol.FileSystemWatcher{{
- GlobPattern: "**/*.{go,mod,sum}",
- Kind: float64(protocol.WatchChange + protocol.WatchDelete + protocol.WatchCreate),
- }}
- for dir := range dirs {
- filename := dir.Filename()
- // If the directory is within a workspace folder, we're already
- // watching it via the relative path above.
- for _, view := range s.session.Views() {
- if isSubdirectory(view.Folder().Filename(), filename) {
- continue
- }
- }
- // If microsoft/vscode#100870 is resolved before
- // microsoft/vscode#104387, we will need a work-around for Windows
- // drive letter casing.
- watchers = append(watchers, protocol.FileSystemWatcher{
- GlobPattern: fmt.Sprintf("%s/**/*.{go,mod,sum}", filename),
- Kind: float64(protocol.WatchChange + protocol.WatchDelete + protocol.WatchCreate),
- })
- }
- if err := s.client.RegisterCapability(ctx, &protocol.RegistrationParams{
- Registrations: []protocol.Registration{{
- ID: watchedFilesCapabilityID(s.watchRegistrationCount),
- Method: "workspace/didChangeWatchedFiles",
- RegisterOptions: protocol.DidChangeWatchedFilesRegistrationOptions{
- Watchers: watchers,
- },
- }},
- }); err != nil {
- return err
- }
- s.watchRegistrationCount++
-
- for dir := range dirs {
- s.watchedDirectories[dir] = struct{}{}
- }
- return nil
-}
-
-func isSubdirectory(root, leaf string) bool {
- rel, err := filepath.Rel(root, leaf)
- return err == nil && !strings.HasPrefix(rel, "..")
-}
-
-func (s *Server) fetchConfig(ctx context.Context, name string, folder span.URI, o *source.Options) error {
- if !s.session.Options().ConfigurationSupported {
- return nil
- }
- v := protocol.ParamConfiguration{
- ConfigurationParams: protocol.ConfigurationParams{
- Items: []protocol.ConfigurationItem{{
- ScopeURI: string(folder),
- Section: "gopls",
- }, {
- ScopeURI: string(folder),
- Section: fmt.Sprintf("gopls-%s", name),
- }},
- },
- }
- configs, err := s.client.Configuration(ctx, &v)
- if err != nil {
- return fmt.Errorf("failed to get workspace configuration from client (%s): %v", folder, err)
- }
- for _, config := range configs {
- if err := s.handleOptionResults(ctx, source.SetOptions(o, config)); err != nil {
- return err
- }
- }
- return nil
-}
-
-func (s *Server) eventuallyShowMessage(ctx context.Context, msg *protocol.ShowMessageParams) error {
- s.stateMu.Lock()
- defer s.stateMu.Unlock()
- if s.state == serverInitialized {
- return s.client.ShowMessage(ctx, msg)
- }
- s.notifications = append(s.notifications, msg)
- return nil
-}
-
-func (s *Server) handleOptionResults(ctx context.Context, results source.OptionResults) error {
- for _, result := range results {
- if result.Error != nil {
- msg := &protocol.ShowMessageParams{
- Type: protocol.Error,
- Message: result.Error.Error(),
- }
- if err := s.eventuallyShowMessage(ctx, msg); err != nil {
- return err
- }
- }
- switch result.State {
- case source.OptionUnexpected:
- msg := &protocol.ShowMessageParams{
- Type: protocol.Error,
- Message: fmt.Sprintf("unexpected gopls setting %q", result.Name),
- }
- if err := s.eventuallyShowMessage(ctx, msg); err != nil {
- return err
- }
- case source.OptionDeprecated:
- msg := fmt.Sprintf("gopls setting %q is deprecated", result.Name)
- if result.Replacement != "" {
- msg = fmt.Sprintf("%s, use %q instead", msg, result.Replacement)
- }
- if err := s.eventuallyShowMessage(ctx, &protocol.ShowMessageParams{
- Type: protocol.Warning,
- Message: msg,
- }); err != nil {
- return err
- }
- }
- }
- return nil
-}
-
-// beginFileRequest checks preconditions for a file-oriented request and routes
-// it to a snapshot.
-// We don't want to return errors for benign conditions like wrong file type,
-// so callers should do if !ok { return err } rather than if err != nil.
-func (s *Server) beginFileRequest(ctx context.Context, pURI protocol.DocumentURI, expectKind source.FileKind) (source.Snapshot, source.VersionedFileHandle, bool, func(), error) {
- uri := pURI.SpanURI()
- if !uri.IsFile() {
- // Not a file URI. Stop processing the request, but don't return an error.
- return nil, nil, false, func() {}, nil
- }
- view, err := s.session.ViewOf(uri)
- if err != nil {
- return nil, nil, false, func() {}, err
- }
- snapshot, release := view.Snapshot(ctx)
- fh, err := snapshot.GetVersionedFile(ctx, uri)
- if err != nil {
- release()
- return nil, nil, false, func() {}, err
- }
- if expectKind != source.UnknownKind && fh.Kind() != expectKind {
- // Wrong kind of file. Nothing to do.
- release()
- return nil, nil, false, func() {}, nil
- }
- return snapshot, fh, true, release, nil
-}
-
-func (s *Server) shutdown(ctx context.Context) error {
- s.stateMu.Lock()
- defer s.stateMu.Unlock()
- if s.state < serverInitialized {
- event.Log(ctx, "server shutdown without initialization")
- }
- if s.state != serverShutDown {
- // drop all the active views
- s.session.Shutdown(ctx)
- s.state = serverShutDown
- }
- return nil
-}
-
-func (s *Server) exit(ctx context.Context) error {
- s.stateMu.Lock()
- defer s.stateMu.Unlock()
-
- // TODO: We need a better way to find the conn close method.
- s.client.(io.Closer).Close()
-
- if s.state != serverShutDown {
- // TODO: We should be able to do better than this.
- os.Exit(1)
- }
- // we don't terminate the process on a normal exit, we just allow it to
- // close naturally if needed after the connection is closed.
- return nil
-}
projects / dotfiles / .git / blobdiff