.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.0/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                 Version: params.TextDocument.Version,
 184         }
 185         if params.Text != nil {
 186                 c.Text = []byte(*params.Text)
 187         }
 188         return s.didModifyFiles(ctx, []source.FileModification{c}, FromDidSave)
 189 }
 190
 191 func (s *Server) didClose(ctx context.Context, params *protocol.DidCloseTextDocumentParams) error {
 192         uri := params.TextDocument.URI.SpanURI()
 193         if !uri.IsFile() {
 194                 return nil
 195         }
 196         return s.didModifyFiles(ctx, []source.FileModification{
 197                 {
 198                         URI:     uri,
 199                         Action:  source.Close,
 200                         Version: -1,
 201                         Text:    nil,
 202                 },
 203         }, FromDidClose)
 204 }
 205
 206 func (s *Server) didModifyFiles(ctx context.Context, modifications []source.FileModification, cause ModificationSource) error {
 207         // diagnosticWG tracks outstanding diagnostic work as a result of this file
 208         // modification.
 209         var diagnosticWG sync.WaitGroup
 210         if s.session.Options().VerboseWorkDoneProgress {
 211                 work := s.progress.start(ctx, DiagnosticWorkTitle(cause), "Calculating file diagnostics...", nil, nil)
 212                 defer func() {
 213                         go func() {
 214                                 diagnosticWG.Wait()
 215                                 work.end("Done.")
 216                         }()
 217                 }()
 218         }
 219
 220         // If the set of changes included directories, expand those directories
 221         // to their files.
 222         modifications = s.session.ExpandModificationsToDirectories(ctx, modifications)
 223
 224         snapshots, releases, err := s.session.DidModifyFiles(ctx, modifications)
 225         if err != nil {
 226                 return err
 227         }
 228
 229         for snapshot, uris := range snapshots {
 230                 diagnosticWG.Add(1)
 231                 go func(snapshot source.Snapshot, uris []span.URI) {
 232                         defer diagnosticWG.Done()
 233                         s.diagnoseSnapshot(snapshot, uris, cause == FromDidChangeWatchedFiles)
 234                 }(snapshot, uris)
 235         }
 236
 237         go func() {
 238                 diagnosticWG.Wait()
 239                 for _, release := range releases {
 240                         release()
 241                 }
 242         }()
 243
 244         // After any file modifications, we need to update our watched files,
 245         // in case something changed. Compute the new set of directories to watch,
 246         // and if it differs from the current set, send updated registrations.
 247         return s.updateWatchedDirectories(ctx)
 248 }
 249
 250 // DiagnosticWorkTitle returns the title of the diagnostic work resulting from a
 251 // file change originating from the given cause.
 252 func DiagnosticWorkTitle(cause ModificationSource) string {
 253         return fmt.Sprintf("diagnosing %v", cause)
 254 }
 255
 256 func (s *Server) changedText(ctx context.Context, uri span.URI, changes []protocol.TextDocumentContentChangeEvent) ([]byte, error) {
 257         if len(changes) == 0 {
 258                 return nil, errors.Errorf("%w: no content changes provided", jsonrpc2.ErrInternal)
 259         }
 260
 261         // Check if the client sent the full content of the file.
 262         // We accept a full content change even if the server expected incremental changes.
 263         if len(changes) == 1 && changes[0].Range == nil && changes[0].RangeLength == 0 {
 264                 return []byte(changes[0].Text), nil
 265         }
 266         return s.applyIncrementalChanges(ctx, uri, changes)
 267 }
 268
 269 func (s *Server) applyIncrementalChanges(ctx context.Context, uri span.URI, changes []protocol.TextDocumentContentChangeEvent) ([]byte, error) {
 270         fh, err := s.session.GetFile(ctx, uri)
 271         if err != nil {
 272                 return nil, err
 273         }
 274         content, err := fh.Read()
 275         if err != nil {
 276                 return nil, errors.Errorf("%w: file not found (%v)", jsonrpc2.ErrInternal, err)
 277         }
 278         for _, change := range changes {
 279                 // Make sure to update column mapper along with the content.
 280                 converter := span.NewContentConverter(uri.Filename(), content)
 281                 m := &protocol.ColumnMapper{
 282                         URI:       uri,
 283                         Converter: converter,
 284                         Content:   content,
 285                 }
 286                 if change.Range == nil {
 287                         return nil, errors.Errorf("%w: unexpected nil range for change", jsonrpc2.ErrInternal)
 288                 }
 289                 spn, err := m.RangeSpan(*change.Range)
 290                 if err != nil {
 291                         return nil, err
 292                 }
 293                 if !spn.HasOffset() {
 294                         return nil, errors.Errorf("%w: invalid range for content change", jsonrpc2.ErrInternal)
 295                 }
 296                 start, end := spn.Start().Offset(), spn.End().Offset()
 297                 if end < start {
 298                         return nil, errors.Errorf("%w: invalid range for content change", jsonrpc2.ErrInternal)
 299                 }
 300                 var buf bytes.Buffer
 301                 buf.Write(content[:start])
 302                 buf.WriteString(change.Text)
 303                 buf.Write(content[end:])
 304                 content = buf.Bytes()
 305         }
 306         return content, nil
 307 }
 308
 309 func changeTypeToFileAction(ct protocol.FileChangeType) source.FileAction {
 310         switch ct {
 311         case protocol.Changed:
 312                 return source.Change
 313         case protocol.Created:
 314                 return source.Create
 315         case protocol.Deleted:
 316                 return source.Delete
 317         }
 318         return source.UnknownFileAction
 319 }