blob: e2e7767183f683a26766fdb1b9167da53ac199f7 [file] [log] [blame]
// 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 cache
import (
"context"
"strconv"
"strings"
"sync"
"sync/atomic"
"golang.org/x/tools/internal/lsp/debug"
"golang.org/x/tools/internal/lsp/source"
"golang.org/x/tools/internal/lsp/telemetry"
"golang.org/x/tools/internal/span"
"golang.org/x/tools/internal/telemetry/log"
"golang.org/x/tools/internal/telemetry/trace"
"golang.org/x/tools/internal/xcontext"
errors "golang.org/x/xerrors"
)
type session struct {
cache *cache
id string
options source.Options
viewMu sync.Mutex
views []*view
viewMap map[span.URI]*view
overlayMu sync.Mutex
overlays map[span.URI]*overlay
}
func (s *session) Options() source.Options {
return s.options
}
func (s *session) SetOptions(options source.Options) {
s.options = options
}
func (s *session) Shutdown(ctx context.Context) {
s.viewMu.Lock()
defer s.viewMu.Unlock()
for _, view := range s.views {
view.shutdown(ctx)
}
s.views = nil
s.viewMap = nil
debug.DropSession(debugSession{s})
}
func (s *session) Cache() source.Cache {
return s.cache
}
func (s *session) NewView(ctx context.Context, name string, folder span.URI, options source.Options) (source.View, source.Snapshot, error) {
s.viewMu.Lock()
defer s.viewMu.Unlock()
v, snapshot, err := s.createView(ctx, name, folder, options)
if err != nil {
return nil, nil, err
}
s.views = append(s.views, v)
// we always need to drop the view map
s.viewMap = make(map[span.URI]*view)
return v, snapshot, nil
}
func (s *session) createView(ctx context.Context, name string, folder span.URI, options source.Options) (*view, *snapshot, error) {
index := atomic.AddInt64(&viewIndex, 1)
// We want a true background context and not a detached context here
// the spans need to be unrelated and no tag values should pollute it.
baseCtx := trace.Detach(xcontext.Detach(ctx))
backgroundCtx, cancel := context.WithCancel(baseCtx)
modfiles, err := getModfiles(ctx, folder.Filename(), options)
if err != nil {
log.Error(ctx, "error getting modfiles", err, telemetry.Directory.Of(folder))
}
v := &view{
session: s,
id: strconv.FormatInt(index, 10),
options: options,
baseCtx: baseCtx,
backgroundCtx: backgroundCtx,
cancel: cancel,
name: name,
modfiles: modfiles,
folder: folder,
filesByURI: make(map[span.URI]*fileBase),
filesByBase: make(map[string][]*fileBase),
snapshot: &snapshot{
packages: make(map[packageKey]*packageHandle),
ids: make(map[span.URI][]packageID),
metadata: make(map[packageID]*metadata),
files: make(map[span.URI]source.FileHandle),
importedBy: make(map[packageID][]packageID),
actions: make(map[actionKey]*actionHandle),
workspacePackages: make(map[packageID]bool),
},
ignoredURIs: make(map[span.URI]struct{}),
builtin: &builtinPkg{},
}
v.snapshot.view = v
if v.session.cache.options != nil {
v.session.cache.options(&v.options)
}
// Preemptively build the builtin package,
// so we immediately add builtin.go to the list of ignored files.
v.buildBuiltinPackage(ctx)
// Preemptively load everything in this directory.
// TODO(matloob): Determine if this can be done in parallel with something else.
// Perhaps different calls to NewView can be run in parallel?
v.snapshotMu.Lock()
defer v.snapshotMu.Unlock() // The code after the snapshot is used isn't expensive.
m, err := v.snapshot.load(ctx, source.DirectoryURI(folder))
if err != nil {
// Suppress all errors.
log.Error(ctx, "failed to load snapshot", err, telemetry.Directory.Of(folder))
return v, v.snapshot, nil
}
// Prepare CheckPackageHandles for every package that's been loaded.
// (*snapshot).CheckPackageHandle makes the assumption that every package that's
// been loaded has an existing checkPackageHandle.
if _, err := v.snapshot.checkWorkspacePackages(ctx, m); err != nil {
// Suppress all errors.
log.Error(ctx, "failed to check snapshot", err, telemetry.Directory.Of(folder))
return v, v.snapshot, nil
}
debug.AddView(debugView{v})
return v, v.snapshot, nil
}
// View returns the view by name.
func (s *session) View(name string) source.View {
s.viewMu.Lock()
defer s.viewMu.Unlock()
for _, view := range s.views {
if view.Name() == name {
return view
}
}
return nil
}
// ViewOf returns a view corresponding to the given URI.
// If the file is not already associated with a view, pick one using some heuristics.
func (s *session) ViewOf(uri span.URI) (source.View, error) {
return s.viewOf(uri)
}
func (s *session) viewOf(uri span.URI) (*view, error) {
s.viewMu.Lock()
defer s.viewMu.Unlock()
// Check if we already know this file.
if v, found := s.viewMap[uri]; found {
return v, nil
}
// Pick the best view for this file and memoize the result.
v, err := s.bestView(uri)
if err != nil {
return nil, err
}
s.viewMap[uri] = v
return v, nil
}
func (s *session) viewsOf(uri span.URI) []*view {
s.viewMu.Lock()
defer s.viewMu.Unlock()
var views []*view
for _, view := range s.views {
if strings.HasPrefix(string(uri), string(view.Folder())) {
views = append(views, view)
}
}
return views
}
func (s *session) Views() []source.View {
s.viewMu.Lock()
defer s.viewMu.Unlock()
result := make([]source.View, len(s.views))
for i, v := range s.views {
result[i] = v
}
return result
}
// bestView finds the best view to associate a given URI with.
// viewMu must be held when calling this method.
func (s *session) bestView(uri span.URI) (*view, error) {
if len(s.views) == 0 {
return nil, errors.Errorf("no views in the session")
}
// we need to find the best view for this file
var longest *view
for _, view := range s.views {
if longest != nil && len(longest.Folder()) > len(view.Folder()) {
continue
}
if strings.HasPrefix(string(uri), string(view.Folder())) {
longest = view
}
}
if longest != nil {
return longest, nil
}
// TODO: are there any more heuristics we can use?
return s.views[0], nil
}
func (s *session) removeView(ctx context.Context, view *view) error {
s.viewMu.Lock()
defer s.viewMu.Unlock()
i, err := s.dropView(ctx, view)
if err != nil {
return err
}
// delete this view... we don't care about order but we do want to make
// sure we can garbage collect the view
s.views[i] = s.views[len(s.views)-1]
s.views[len(s.views)-1] = nil
s.views = s.views[:len(s.views)-1]
return nil
}
func (s *session) updateView(ctx context.Context, view *view, options source.Options) (*view, *snapshot, error) {
s.viewMu.Lock()
defer s.viewMu.Unlock()
i, err := s.dropView(ctx, view)
if err != nil {
return nil, nil, err
}
v, snapshot, err := s.createView(ctx, view.name, view.folder, options)
if err != nil {
// we have dropped the old view, but could not create the new one
// this should not happen and is very bad, but we still need to clean
// up the view array if it happens
s.views[i] = s.views[len(s.views)-1]
s.views[len(s.views)-1] = nil
s.views = s.views[:len(s.views)-1]
}
// substitute the new view into the array where the old view was
s.views[i] = v
return v, snapshot, nil
}
func (s *session) dropView(ctx context.Context, v *view) (int, error) {
// we always need to drop the view map
s.viewMap = make(map[span.URI]*view)
for i := range s.views {
if v == s.views[i] {
// we found the view, drop it and return the index it was found at
s.views[i] = nil
v.shutdown(ctx)
return i, nil
}
}
return -1, errors.Errorf("view %s for %v not found", v.Name(), v.Folder())
}
func (s *session) DidModifyFile(ctx context.Context, c source.FileModification) ([]source.Snapshot, error) {
ctx = telemetry.URI.With(ctx, c.URI)
// Perform the session-specific updates.
if err := s.updateOverlay(ctx, c); err != nil {
return nil, err
}
var snapshots []source.Snapshot
for _, view := range s.viewsOf(c.URI) {
if view.Ignore(c.URI) {
return nil, errors.Errorf("ignored file %v", c.URI)
}
// Set the content for the file, only for didChange and didClose events.
f, err := view.getFileLocked(ctx, c.URI)
if err != nil {
return nil, err
}
snapshots = append(snapshots, view.invalidateContent(ctx, c.URI, f.kind, c.Action))
}
return snapshots, nil
}
func (s *session) IsOpen(uri span.URI) bool {
s.overlayMu.Lock()
defer s.overlayMu.Unlock()
_, open := s.overlays[uri]
return open
}
func (s *session) GetFile(uri span.URI, kind source.FileKind) source.FileHandle {
if overlay := s.readOverlay(uri); overlay != nil {
return overlay
}
// Fall back to the cache-level file system.
return s.cache.GetFile(uri, kind)
}
func (s *session) DidChangeOutOfBand(ctx context.Context, uri span.URI, action source.FileAction) bool {
view, err := s.viewOf(uri)
if err != nil {
return false
}
f, err := view.getFileLocked(ctx, uri)
if err != nil {
return false
}
view.invalidateContent(ctx, f.URI(), f.kind, action)
return true
}