.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/internal/lsp/workspace.go

   1 // Copyright 2019 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package lsp
   6
   7 import (
   8         "context"
   9
  10         "golang.org/x/tools/internal/lsp/protocol"
  11         "golang.org/x/tools/internal/lsp/source"
  12         "golang.org/x/tools/internal/span"
  13         errors "golang.org/x/xerrors"
  14 )
  15
  16 func (s *Server) didChangeWorkspaceFolders(ctx context.Context, params *protocol.DidChangeWorkspaceFoldersParams) error {
  17         event := params.Event
  18         for _, folder := range event.Removed {
  19                 view := s.session.View(folder.Name)
  20                 if view != nil {
  21                         view.Shutdown(ctx)
  22                 } else {
  23                         return errors.Errorf("view %s for %v not found", folder.Name, folder.URI)
  24                 }
  25         }
  26         return s.addFolders(ctx, event.Added)
  27 }
  28
  29 func (s *Server) addView(ctx context.Context, name string, uri span.URI) (source.Snapshot, func(), error) {
  30         s.stateMu.Lock()
  31         state := s.state
  32         s.stateMu.Unlock()
  33         if state < serverInitialized {
  34                 return nil, func() {}, errors.Errorf("addView called before server initialized")
  35         }
  36         options := s.session.Options().Clone()
  37         if err := s.fetchConfig(ctx, name, uri, options); err != nil {
  38                 return nil, func() {}, err
  39         }
  40         _, snapshot, release, err := s.session.NewView(ctx, name, uri, options)
  41         return snapshot, release, err
  42 }
  43
  44 func (s *Server) didChangeConfiguration(ctx context.Context, _ *protocol.DidChangeConfigurationParams) error {
  45         // Apply any changes to the session-level settings.
  46         options := s.session.Options().Clone()
  47         semanticTokensRegistered := options.SemanticTokens
  48         if err := s.fetchConfig(ctx, "", "", options); err != nil {
  49                 return err
  50         }
  51         s.session.SetOptions(options)
  52
  53         // Go through each view, getting and updating its configuration.
  54         for _, view := range s.session.Views() {
  55                 options := s.session.Options().Clone()
  56                 if err := s.fetchConfig(ctx, view.Name(), view.Folder(), options); err != nil {
  57                         return err
  58                 }
  59                 view, err := view.SetOptions(ctx, options)
  60                 if err != nil {
  61                         return err
  62                 }
  63                 go func() {
  64                         snapshot, release := view.Snapshot(ctx)
  65                         defer release()
  66                         s.diagnoseDetached(snapshot)
  67                 }()
  68         }
  69
  70         // Update any session-specific registrations or unregistrations.
  71         if !semanticTokensRegistered && options.SemanticTokens {
  72                 if err := s.client.RegisterCapability(ctx, &protocol.RegistrationParams{
  73                         Registrations: semanticTokenRegistrations(),
  74                 }); err != nil {
  75                         return err
  76                 }
  77         } else if semanticTokensRegistered && !options.SemanticTokens {
  78                 var unregistrations []protocol.Unregistration
  79                 for _, r := range semanticTokenRegistrations() {
  80                         unregistrations = append(unregistrations, protocol.Unregistration{
  81                                 ID:     r.ID,
  82                                 Method: r.Method,
  83                         })
  84                 }
  85                 if err := s.client.UnregisterCapability(ctx, &protocol.UnregistrationParams{
  86                         Unregisterations: unregistrations,
  87                 }); err != nil {
  88                         return err
  89                 }
  90         }
  91         return nil
  92 }
  93
  94 func semanticTokenRegistrations() []protocol.Registration {
  95         var registrations []protocol.Registration
  96         for _, method := range []string{
  97                 "textDocument/semanticTokens/full",
  98                 "textDocument/semanticTokens/full/delta",
  99                 "textDocument/semanticTokens/range",
 100         } {
 101                 registrations = append(registrations, protocol.Registration{
 102                         ID:     method,
 103                         Method: method,
 104                         RegisterOptions: &protocol.SemanticTokensOptions{
 105                                 Legend: protocol.SemanticTokensLegend{
 106                                         // TODO(pjw): trim these to what we use (and an unused one
 107                                         // at position 0 of TokTypes, to catch typos)
 108                                         TokenTypes:     SemanticMemo.tokTypes,
 109                                         TokenModifiers: SemanticMemo.tokMods,
 110                                 },
 111                         },
 112                 })
 113         }
 114         return registrations
 115 }