1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
|
// 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"
"errors"
"fmt"
"path/filepath"
"time"
"golang.org/x/tools/gopls/internal/lsp/protocol"
"golang.org/x/tools/gopls/internal/lsp/source"
"golang.org/x/tools/gopls/internal/span"
"golang.org/x/tools/internal/event"
"golang.org/x/tools/internal/jsonrpc2"
"golang.org/x/tools/internal/xcontext"
)
// ModificationSource identifies the originating cause of a file modification.
type ModificationSource int
const (
// FromDidOpen is a file modification caused by opening a file.
FromDidOpen = ModificationSource(iota)
// FromDidChange is a file modification caused by changing a file.
FromDidChange
// FromDidChangeWatchedFiles is a file modification caused by a change to a
// watched file.
FromDidChangeWatchedFiles
// FromDidSave is a file modification caused by a file save.
FromDidSave
// FromDidClose is a file modification caused by closing a file.
FromDidClose
// TODO: add FromDidChangeConfiguration, once configuration changes cause a
// new snapshot to be created.
// FromRegenerateCgo refers to file modifications caused by regenerating
// the cgo sources for the workspace.
FromRegenerateCgo
// FromInitialWorkspaceLoad refers to the loading of all packages in the
// workspace when the view is first created.
FromInitialWorkspaceLoad
)
func (m ModificationSource) String() string {
switch m {
case FromDidOpen:
return "opened files"
case FromDidChange:
return "changed files"
case FromDidChangeWatchedFiles:
return "files changed on disk"
case FromDidSave:
return "saved files"
case FromDidClose:
return "close files"
case FromRegenerateCgo:
return "regenerate cgo"
case FromInitialWorkspaceLoad:
return "initial workspace load"
default:
return "unknown file modification"
}
}
func (s *Server) didOpen(ctx context.Context, params *protocol.DidOpenTextDocumentParams) error {
uri := params.TextDocument.URI.SpanURI()
if !uri.IsFile() {
return nil
}
// There may not be any matching view in the current session. If that's
// the case, try creating a new view based on the opened file path.
//
// TODO(rstambler): This seems like it would continuously add new
// views, but it won't because ViewOf only returns an error when there
// are no views in the session. I don't know if that logic should go
// here, or if we can continue to rely on that implementation detail.
if _, err := s.session.ViewOf(uri); err != nil {
dir := filepath.Dir(uri.Filename())
if err := s.addFolders(ctx, []protocol.WorkspaceFolder{{
URI: string(protocol.URIFromPath(dir)),
Name: filepath.Base(dir),
}}); err != nil {
return err
}
}
return s.didModifyFiles(ctx, []source.FileModification{{
URI: uri,
Action: source.Open,
Version: params.TextDocument.Version,
Text: []byte(params.TextDocument.Text),
LanguageID: params.TextDocument.LanguageID,
}}, FromDidOpen)
}
func (s *Server) didChange(ctx context.Context, params *protocol.DidChangeTextDocumentParams) error {
uri := params.TextDocument.URI.SpanURI()
if !uri.IsFile() {
return nil
}
text, err := s.changedText(ctx, uri, params.ContentChanges)
if err != nil {
return err
}
c := source.FileModification{
URI: uri,
Action: source.Change,
Version: params.TextDocument.Version,
Text: text,
}
if err := s.didModifyFiles(ctx, []source.FileModification{c}, FromDidChange); err != nil {
return err
}
return s.warnAboutModifyingGeneratedFiles(ctx, uri)
}
// warnAboutModifyingGeneratedFiles shows a warning if a user tries to edit a
// generated file for the first time.
func (s *Server) warnAboutModifyingGeneratedFiles(ctx context.Context, uri span.URI) error {
s.changedFilesMu.Lock()
_, ok := s.changedFiles[uri]
if !ok {
s.changedFiles[uri] = struct{}{}
}
s.changedFilesMu.Unlock()
// This file has already been edited before.
if ok {
return nil
}
// Ideally, we should be able to specify that a generated file should
// be opened as read-only. Tell the user that they should not be
// editing a generated file.
view, err := s.session.ViewOf(uri)
if err != nil {
return err
}
snapshot, release := view.Snapshot(ctx)
isGenerated := source.IsGenerated(ctx, snapshot, uri)
release()
if !isGenerated {
return nil
}
return s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
Message: fmt.Sprintf("Do not edit this file! %s is a generated file.", uri.Filename()),
Type: protocol.Warning,
})
}
func (s *Server) didChangeWatchedFiles(ctx context.Context, params *protocol.DidChangeWatchedFilesParams) error {
var modifications []source.FileModification
for _, change := range params.Changes {
uri := change.URI.SpanURI()
if !uri.IsFile() {
continue
}
action := changeTypeToFileAction(change.Type)
modifications = append(modifications, source.FileModification{
URI: uri,
Action: action,
OnDisk: true,
})
}
return s.didModifyFiles(ctx, modifications, FromDidChangeWatchedFiles)
}
func (s *Server) didSave(ctx context.Context, params *protocol.DidSaveTextDocumentParams) error {
uri := params.TextDocument.URI.SpanURI()
if !uri.IsFile() {
return nil
}
c := source.FileModification{
URI: uri,
Action: source.Save,
}
if params.Text != nil {
c.Text = []byte(*params.Text)
}
return s.didModifyFiles(ctx, []source.FileModification{c}, FromDidSave)
}
func (s *Server) didClose(ctx context.Context, params *protocol.DidCloseTextDocumentParams) error {
uri := params.TextDocument.URI.SpanURI()
if !uri.IsFile() {
return nil
}
return s.didModifyFiles(ctx, []source.FileModification{
{
URI: uri,
Action: source.Close,
Version: -1,
Text: nil,
},
}, FromDidClose)
}
func (s *Server) didModifyFiles(ctx context.Context, modifications []source.FileModification, cause ModificationSource) error {
diagnoseDone := make(chan struct{})
if s.session.Options().VerboseWorkDoneProgress {
work := s.progress.Start(ctx, DiagnosticWorkTitle(cause), "Calculating file diagnostics...", nil, nil)
defer func() {
go func() {
<-diagnoseDone
work.End(ctx, "Done.")
}()
}()
}
onDisk := cause == FromDidChangeWatchedFiles
delay := s.session.Options().ExperimentalWatchedFileDelay
s.fileChangeMu.Lock()
defer s.fileChangeMu.Unlock()
if !onDisk || delay == 0 {
// No delay: process the modifications immediately.
return s.processModifications(ctx, modifications, onDisk, diagnoseDone)
}
// Debounce and batch up pending modifications from watched files.
pending := &pendingModificationSet{
diagnoseDone: diagnoseDone,
changes: modifications,
}
// Invariant: changes appended to s.pendingOnDiskChanges are eventually
// handled in the order they arrive. This guarantee is only partially
// enforced here. Specifically:
// 1. s.fileChangesMu ensures that the append below happens in the order
// notifications were received, so that the changes within each batch are
// ordered properly.
// 2. The debounced func below holds s.fileChangesMu while processing all
// changes in s.pendingOnDiskChanges, ensuring that no batches are
// processed out of order.
// 3. Session.ExpandModificationsToDirectories and Session.DidModifyFiles
// process changes in order.
s.pendingOnDiskChanges = append(s.pendingOnDiskChanges, pending)
ctx = xcontext.Detach(ctx)
okc := s.watchedFileDebouncer.debounce("", 0, time.After(delay))
go func() {
if ok := <-okc; !ok {
return
}
s.fileChangeMu.Lock()
var allChanges []source.FileModification
// For accurate progress notifications, we must notify all goroutines
// waiting for the diagnose pass following a didChangeWatchedFiles
// notification. This is necessary for regtest assertions.
var dones []chan struct{}
for _, pending := range s.pendingOnDiskChanges {
allChanges = append(allChanges, pending.changes...)
dones = append(dones, pending.diagnoseDone)
}
allDone := make(chan struct{})
if err := s.processModifications(ctx, allChanges, onDisk, allDone); err != nil {
event.Error(ctx, "processing delayed file changes", err)
}
s.pendingOnDiskChanges = nil
s.fileChangeMu.Unlock()
<-allDone
for _, done := range dones {
close(done)
}
}()
return nil
}
// processModifications update server state to reflect file changes, and
// triggers diagnostics to run asynchronously. The diagnoseDone channel will be
// closed once diagnostics complete.
func (s *Server) processModifications(ctx context.Context, modifications []source.FileModification, onDisk bool, diagnoseDone chan struct{}) error {
s.stateMu.Lock()
if s.state >= serverShutDown {
// This state check does not prevent races below, and exists only to
// produce a better error message. The actual race to the cache should be
// guarded by Session.viewMu.
s.stateMu.Unlock()
close(diagnoseDone)
return errors.New("server is shut down")
}
s.stateMu.Unlock()
// If the set of changes included directories, expand those directories
// to their files.
modifications = s.session.ExpandModificationsToDirectories(ctx, modifications)
// Build a lookup map for file modifications, so that we can later join
// with the snapshot file associations.
modMap := make(map[span.URI]source.FileModification)
for _, mod := range modifications {
modMap[mod.URI] = mod
}
snapshots, release, err := s.session.DidModifyFiles(ctx, modifications)
if err != nil {
close(diagnoseDone)
return err
}
// golang/go#50267: diagnostics should be re-sent after an open or close. For
// some clients, it may be helpful to re-send after each change.
for snapshot, uris := range snapshots {
for _, uri := range uris {
mod := modMap[uri]
if snapshot.View().Options().ChattyDiagnostics || mod.Action == source.Open || mod.Action == source.Close {
s.mustPublishDiagnostics(uri)
}
}
}
go func() {
s.diagnoseSnapshots(snapshots, onDisk)
release()
close(diagnoseDone)
}()
// After any file modifications, we need to update our watched files,
// in case something changed. Compute the new set of directories to watch,
// and if it differs from the current set, send updated registrations.
return s.updateWatchedDirectories(ctx)
}
// DiagnosticWorkTitle returns the title of the diagnostic work resulting from a
// file change originating from the given cause.
func DiagnosticWorkTitle(cause ModificationSource) string {
return fmt.Sprintf("diagnosing %v", cause)
}
func (s *Server) changedText(ctx context.Context, uri span.URI, changes []protocol.TextDocumentContentChangeEvent) ([]byte, error) {
if len(changes) == 0 {
return nil, fmt.Errorf("%w: no content changes provided", jsonrpc2.ErrInternal)
}
// Check if the client sent the full content of the file.
// We accept a full content change even if the server expected incremental changes.
if len(changes) == 1 && changes[0].Range == nil && changes[0].RangeLength == 0 {
return []byte(changes[0].Text), nil
}
return s.applyIncrementalChanges(ctx, uri, changes)
}
func (s *Server) applyIncrementalChanges(ctx context.Context, uri span.URI, changes []protocol.TextDocumentContentChangeEvent) ([]byte, error) {
fh, err := s.session.GetFile(ctx, uri)
if err != nil {
return nil, err
}
content, err := fh.Read()
if err != nil {
return nil, fmt.Errorf("%w: file not found (%v)", jsonrpc2.ErrInternal, err)
}
for _, change := range changes {
// TODO(adonovan): refactor to use diff.Apply, which is robust w.r.t.
// out-of-order or overlapping changes---and much more efficient.
// Make sure to update column mapper along with the content.
m := protocol.NewColumnMapper(uri, content)
if change.Range == nil {
return nil, fmt.Errorf("%w: unexpected nil range for change", jsonrpc2.ErrInternal)
}
spn, err := m.RangeSpan(*change.Range)
if err != nil {
return nil, err
}
start, end := spn.Start().Offset(), spn.End().Offset()
if end < start {
return nil, fmt.Errorf("%w: invalid range for content change", jsonrpc2.ErrInternal)
}
var buf bytes.Buffer
buf.Write(content[:start])
buf.WriteString(change.Text)
buf.Write(content[end:])
content = buf.Bytes()
}
return content, nil
}
func changeTypeToFileAction(ct protocol.FileChangeType) source.FileAction {
switch ct {
case protocol.Changed:
return source.Change
case protocol.Created:
return source.Create
case protocol.Deleted:
return source.Delete
}
return source.UnknownFileAction
}
|