.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/internal/lsp/text_synchronization.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         "bytes"
   9         "context"
  10         "fmt"
  11         "path/filepath"
  12         "sync"
  13
  14         "golang.org/x/tools/internal/jsonrpc2"
  15         "golang.org/x/tools/internal/lsp/protocol"
  16         "golang.org/x/tools/internal/lsp/source"
  17         "golang.org/x/tools/internal/span"
  18         errors "golang.org/x/xerrors"
  19 )
  20
  21 // ModificationSource identifies the originating cause of a file modification.
  22 type ModificationSource int
  23
  24 const (
  25         // FromDidOpen is a file modification caused by opening a file.
  26         FromDidOpen = ModificationSource(iota)
  27
  28         // FromDidChange is a file modification caused by changing a file.
  29         FromDidChange
  30
  31         // FromDidChangeWatchedFiles is a file modification caused by a change to a
  32         // watched file.
  33         FromDidChangeWatchedFiles
  34
  35         // FromDidSave is a file modification caused by a file save.
  36         FromDidSave
  37
  38         // FromDidClose is a file modification caused by closing a file.
  39         FromDidClose
  40
  41         // FromRegenerateCgo refers to file modifications caused by regenerating
  42         // the cgo sources for the workspace.
  43         FromRegenerateCgo
  44
  45         // FromInitialWorkspaceLoad refers to the loading of all packages in the
  46         // workspace when the view is first created.
  47         FromInitialWorkspaceLoad
  48 )
  49
  50 func (m ModificationSource) String() string {
  51         switch m {
  52         case FromDidOpen:
  53                 return "opened files"
  54         case FromDidChange:
  55                 return "changed files"
  56         case FromDidChangeWatchedFiles:
  57                 return "files changed on disk"
  58         case FromDidSave:
  59                 return "saved files"
  60         case FromDidClose:
  61                 return "close files"
  62         case FromRegenerateCgo:
  63                 return "regenerate cgo"
  64         case FromInitialWorkspaceLoad:
  65                 return "initial workspace load"
  66         default:
  67                 return "unknown file modification"
  68         }
  69 }
  70
  71 func (s *Server) didOpen(ctx context.Context, params *protocol.DidOpenTextDocumentParams) error {
  72         uri := params.TextDocument.URI.SpanURI()
  73         if !uri.IsFile() {
  74                 return nil
  75         }
  76         // There may not be any matching view in the current session. If that's
  77         // the case, try creating a new view based on the opened file path.
  78         //
  79         // TODO(rstambler): This seems like it would continuously add new
  80         // views, but it won't because ViewOf only returns an error when there
  81         // are no views in the session. I don't know if that logic should go
  82         // here, or if we can continue to rely on that implementation detail.
  83         if _, err := s.session.ViewOf(uri); err != nil {
  84                 dir := filepath.Dir(uri.Filename())
  85                 if err := s.addFolders(ctx, []protocol.WorkspaceFolder{{
  86                         URI:  string(protocol.URIFromPath(dir)),
  87                         Name: filepath.Base(dir),
  88                 }}); err != nil {
  89                         return err
  90                 }
  91         }
  92         return s.didModifyFiles(ctx, []source.FileModification{{
  93                 URI:        uri,
  94                 Action:     source.Open,
  95                 Version:    params.TextDocument.Version,
  96                 Text:       []byte(params.TextDocument.Text),
  97                 LanguageID: params.TextDocument.LanguageID,
  98         }}, FromDidOpen)
  99 }
 100
 101 func (s *Server) didChange(ctx context.Context, params *protocol.DidChangeTextDocumentParams) error {
 102         uri := params.TextDocument.URI.SpanURI()
 103         if !uri.IsFile() {
 104                 return nil
 105         }
 106
 107         text, err := s.changedText(ctx, uri, params.ContentChanges)
 108         if err != nil {
 109                 return err
 110         }
 111         c := source.FileModification{
 112                 URI:     uri,
 113                 Action:  source.Change,
 114                 Version: params.TextDocument.Version,
 115                 Text:    text,
 116         }
 117         if err := s.didModifyFiles(ctx, []source.FileModification{c}, FromDidChange); err != nil {
 118                 return err
 119         }
 120         return s.warnAboutModifyingGeneratedFiles(ctx, uri)
 121 }
 122
 123 // warnAboutModifyingGeneratedFiles shows a warning if a user tries to edit a
 124 // generated file for the first time.
 125 func (s *Server) warnAboutModifyingGeneratedFiles(ctx context.Context, uri span.URI) error {
 126         s.changedFilesMu.Lock()
 127         _, ok := s.changedFiles[uri]
 128         if !ok {
 129                 s.changedFiles[uri] = struct{}{}
 130         }
 131         s.changedFilesMu.Unlock()
 132
 133         // This file has already been edited before.
 134         if ok {
 135                 return nil
 136         }
 137
 138         // Ideally, we should be able to specify that a generated file should
 139         // be opened as read-only. Tell the user that they should not be
 140         // editing a generated file.
 141         view, err := s.session.ViewOf(uri)
 142         if err != nil {
 143                 return err
 144         }
 145         snapshot, release := view.Snapshot(ctx)
 146         isGenerated := source.IsGenerated(ctx, snapshot, uri)
 147         release()
 148
 149         if !isGenerated {
 150                 return nil
 151         }
 152         return s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
 153                 Message: fmt.Sprintf("Do not edit this file! %s is a generated file.", uri.Filename()),
 154                 Type:    protocol.Warning,
 155         })
 156 }
 157
 158 func (s *Server) didChangeWatchedFiles(ctx context.Context, params *protocol.DidChangeWatchedFilesParams) error {
 159         var modifications []source.FileModification
 160         for _, change := range params.Changes {
 161                 uri := change.URI.SpanURI()
 162                 if !uri.IsFile() {
 163                         continue
 164                 }
 165                 action := changeTypeToFileAction(change.Type)
 166                 modifications = append(modifications, source.FileModification{
 167                         URI:    uri,
 168                         Action: action,
 169                         OnDisk: true,
 170                 })
 171         }
 172         return s.didModifyFiles(ctx, modifications, FromDidChangeWatchedFiles)
 173 }
 174
 175 func (s *Server) didSave(ctx context.Context, params *protocol.DidSaveTextDocumentParams) error {
 176         uri := params.TextDocument.URI.SpanURI()
 177         if !uri.IsFile() {
 178                 return nil
 179         }
 180         c := source.FileModification{
 181                 URI:    uri,
 182                 Action: source.Save,
 183         }
 184         if params.Text != nil {
 185                 c.Text = []byte(*params.Text)
 186         }
 187         return s.didModifyFiles(ctx, []source.FileModification{c}, FromDidSave)
 188 }
 189
 190 func (s *Server) didClose(ctx context.Context, params *protocol.DidCloseTextDocumentParams) error {
 191         uri := params.TextDocument.URI.SpanURI()
 192         if !uri.IsFile() {
 193                 return nil
 194         }
 195         return s.didModifyFiles(ctx, []source.FileModification{
 196                 {
 197                         URI:     uri,
 198                         Action:  source.Close,
 199                         Version: -1,
 200                         Text:    nil,
 201                 },
 202         }, FromDidClose)
 203 }
 204
 205 func (s *Server) didModifyFiles(ctx context.Context, modifications []source.FileModification, cause ModificationSource) error {
 206         // diagnosticWG tracks outstanding diagnostic work as a result of this file
 207         // modification.
 208         var diagnosticWG sync.WaitGroup
 209         if s.session.Options().VerboseWorkDoneProgress {
 210                 work := s.progress.start(ctx, DiagnosticWorkTitle(cause), "Calculating file diagnostics...", nil, nil)
 211                 defer func() {
 212                         go func() {
 213                                 diagnosticWG.Wait()
 214                                 work.end("Done.")
 215                         }()
 216                 }()
 217         }
 218
 219         // If the set of changes included directories, expand those directories
 220         // to their files.
 221         modifications = s.session.ExpandModificationsToDirectories(ctx, modifications)
 222
 223         snapshots, releases, err := s.session.DidModifyFiles(ctx, modifications)
 224         if err != nil {
 225                 return err
 226         }
 227
 228         for snapshot, uris := range snapshots {
 229                 diagnosticWG.Add(1)
 230                 go func(snapshot source.Snapshot, uris []span.URI) {
 231                         defer diagnosticWG.Done()
 232                         s.diagnoseSnapshot(snapshot, uris, cause == FromDidChangeWatchedFiles)
 233                 }(snapshot, uris)
 234         }
 235
 236         go func() {
 237                 diagnosticWG.Wait()
 238                 for _, release := range releases {
 239                         release()
 240                 }
 241         }()
 242
 243         // After any file modifications, we need to update our watched files,
 244         // in case something changed. Compute the new set of directories to watch,
 245         // and if it differs from the current set, send updated registrations.
 246         return s.updateWatchedDirectories(ctx)
 247 }
 248
 249 // DiagnosticWorkTitle returns the title of the diagnostic work resulting from a
 250 // file change originating from the given cause.
 251 func DiagnosticWorkTitle(cause ModificationSource) string {
 252         return fmt.Sprintf("diagnosing %v", cause)
 253 }
 254
 255 func (s *Server) changedText(ctx context.Context, uri span.URI, changes []protocol.TextDocumentContentChangeEvent) ([]byte, error) {
 256         if len(changes) == 0 {
 257                 return nil, errors.Errorf("%w: no content changes provided", jsonrpc2.ErrInternal)
 258         }
 259
 260         // Check if the client sent the full content of the file.
 261         // We accept a full content change even if the server expected incremental changes.
 262         if len(changes) == 1 && changes[0].Range == nil && changes[0].RangeLength == 0 {
 263                 return []byte(changes[0].Text), nil
 264         }
 265         return s.applyIncrementalChanges(ctx, uri, changes)
 266 }
 267
 268 func (s *Server) applyIncrementalChanges(ctx context.Context, uri span.URI, changes []protocol.TextDocumentContentChangeEvent) ([]byte, error) {
 269         fh, err := s.session.GetFile(ctx, uri)
 270         if err != nil {
 271                 return nil, err
 272         }
 273         content, err := fh.Read()
 274         if err != nil {
 275                 return nil, errors.Errorf("%w: file not found (%v)", jsonrpc2.ErrInternal, err)
 276         }
 277         for _, change := range changes {
 278                 // Make sure to update column mapper along with the content.
 279                 converter := span.NewContentConverter(uri.Filename(), content)
 280                 m := &protocol.ColumnMapper{
 281                         URI:       uri,
 282                         Converter: converter,
 283                         Content:   content,
 284                 }
 285                 if change.Range == nil {
 286                         return nil, errors.Errorf("%w: unexpected nil range for change", jsonrpc2.ErrInternal)
 287                 }
 288                 spn, err := m.RangeSpan(*change.Range)
 289                 if err != nil {
 290                         return nil, err
 291                 }
 292                 if !spn.HasOffset() {
 293                         return nil, errors.Errorf("%w: invalid range for content change", jsonrpc2.ErrInternal)
 294                 }
 295                 start, end := spn.Start().Offset(), spn.End().Offset()
 296                 if end < start {
 297                         return nil, errors.Errorf("%w: invalid range for content change", jsonrpc2.ErrInternal)
 298                 }
 299                 var buf bytes.Buffer
 300                 buf.Write(content[:start])
 301                 buf.WriteString(change.Text)
 302                 buf.Write(content[end:])
 303                 content = buf.Bytes()
 304         }
 305         return content, nil
 306 }
 307
 308 func changeTypeToFileAction(ct protocol.FileChangeType) source.FileAction {
 309         switch ct {
 310         case protocol.Changed:
 311                 return source.Change
 312         case protocol.Created:
 313                 return source.Create
 314         case protocol.Deleted:
 315                 return source.Delete
 316         }
 317         return source.UnknownFileAction
 318 }