+++ /dev/null
-// Copyright 2018 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 (
- "context"
- "crypto/sha256"
- "fmt"
- "os"
- "path/filepath"
- "strings"
- "sync"
-
- "golang.org/x/tools/internal/event"
- "golang.org/x/tools/internal/lsp/debug/tag"
- "golang.org/x/tools/internal/lsp/mod"
- "golang.org/x/tools/internal/lsp/protocol"
- "golang.org/x/tools/internal/lsp/source"
- "golang.org/x/tools/internal/span"
- "golang.org/x/tools/internal/xcontext"
- errors "golang.org/x/xerrors"
-)
-
-// idWithAnalysis is used to track if the diagnostics for a given file were
-// computed with analyses.
-type idWithAnalysis struct {
- id source.VersionedFileIdentity
- withAnalysis bool
-}
-
-// A reportSet collects diagnostics for publication, sorting them by file and
-// de-duplicating.
-type reportSet struct {
- mu sync.Mutex
- // lazily allocated
- reports map[idWithAnalysis]map[string]*source.Diagnostic
-}
-
-func (s *reportSet) add(id source.VersionedFileIdentity, withAnalysis bool, diags ...*source.Diagnostic) {
- s.mu.Lock()
- defer s.mu.Unlock()
- if s.reports == nil {
- s.reports = make(map[idWithAnalysis]map[string]*source.Diagnostic)
- }
- key := idWithAnalysis{
- id: id,
- withAnalysis: withAnalysis,
- }
- if _, ok := s.reports[key]; !ok {
- s.reports[key] = map[string]*source.Diagnostic{}
- }
- for _, d := range diags {
- s.reports[key][diagnosticKey(d)] = d
- }
-}
-
-// diagnosticKey creates a unique identifier for a given diagnostic, since we
-// cannot use source.Diagnostics as map keys. This is used to de-duplicate
-// diagnostics.
-func diagnosticKey(d *source.Diagnostic) string {
- var tags, related string
- for _, t := range d.Tags {
- tags += fmt.Sprintf("%s", t)
- }
- for _, r := range d.Related {
- related += fmt.Sprintf("%s%s%s", r.URI, r.Message, r.Range)
- }
- key := fmt.Sprintf("%s%s%s%s%s%s", d.Message, d.Range, d.Severity, d.Source, tags, related)
- return fmt.Sprintf("%x", sha256.Sum256([]byte(key)))
-}
-
-func (s *Server) diagnoseDetached(snapshot source.Snapshot) {
- ctx := snapshot.View().BackgroundContext()
- ctx = xcontext.Detach(ctx)
- reports, shows := s.diagnose(ctx, snapshot, false)
- if shows != nil {
- // If a view has been created or the configuration changed, warn the user.
- s.client.ShowMessage(ctx, shows)
- }
- s.publishReports(ctx, snapshot, reports)
-}
-
-func (s *Server) diagnoseSnapshot(snapshot source.Snapshot, changedURIs []span.URI) {
- ctx := snapshot.View().BackgroundContext()
-
- delay := snapshot.View().Options().ExperimentalDiagnosticsDelay
- if delay > 0 {
- // Experimental 2-phase diagnostics.
- //
- // The first phase just parses and checks packages that have been affected
- // by file modifications (no analysis).
- //
- // The second phase does everything, and is debounced by the configured delay.
- reports, err := s.diagnoseChangedFiles(ctx, snapshot, changedURIs)
- if err != nil {
- if !errors.Is(err, context.Canceled) {
- event.Error(ctx, "diagnosing changed files", err)
- }
- }
- s.publishReports(ctx, snapshot, reports)
- s.debouncer.debounce(snapshot.View().Name(), snapshot.ID(), delay, func() {
- reports, _ := s.diagnose(ctx, snapshot, false)
- s.publishReports(ctx, snapshot, reports)
- })
- return
- }
-
- // Ignore possible workspace configuration warnings in the normal flow.
- reports, _ := s.diagnose(ctx, snapshot, false)
- s.publishReports(ctx, snapshot, reports)
-}
-
-func (s *Server) diagnoseChangedFiles(ctx context.Context, snapshot source.Snapshot, uris []span.URI) (*reportSet, error) {
- ctx, done := event.Start(ctx, "Server.diagnoseChangedFiles")
- defer done()
- packages := make(map[source.Package]struct{})
- for _, uri := range uris {
- pkgs, err := snapshot.PackagesForFile(ctx, uri, source.TypecheckWorkspace)
- if err != nil {
- // TODO (rFindley): we should probably do something with the error here,
- // but as of now this can fail repeatedly if load fails, so can be too
- // noisy to log (and we'll handle things later in the slow pass).
- continue
- }
- for _, pkg := range pkgs {
- packages[pkg] = struct{}{}
- }
- }
- reports := new(reportSet)
- for pkg := range packages {
- pkgReports, _, err := source.Diagnostics(ctx, snapshot, pkg, false)
- if err != nil {
- return nil, err
- }
- for id, diags := range pkgReports {
- reports.add(id, false, diags...)
- }
- }
- return reports, nil
-}
-
-// diagnose is a helper function for running diagnostics with a given context.
-// Do not call it directly.
-func (s *Server) diagnose(ctx context.Context, snapshot source.Snapshot, alwaysAnalyze bool) (diagReports *reportSet, _ *protocol.ShowMessageParams) {
- ctx, done := event.Start(ctx, "Server.diagnose")
- defer done()
-
- // Wait for a free diagnostics slot.
- select {
- case <-ctx.Done():
- return nil, nil
- case s.diagnosticsSema <- struct{}{}:
- }
- defer func() {
- <-s.diagnosticsSema
- }()
-
- reports := new(reportSet)
-
- // First, diagnose the go.mod file.
- modReports, modErr := mod.Diagnostics(ctx, snapshot)
- if ctx.Err() != nil {
- return nil, nil
- }
- if modErr != nil {
- event.Error(ctx, "warning: diagnose go.mod", modErr, tag.Directory.Of(snapshot.View().Folder().Filename()), tag.Snapshot.Of(snapshot.ID()))
- }
- for id, diags := range modReports {
- if id.URI == "" {
- event.Error(ctx, "missing URI for module diagnostics", fmt.Errorf("empty URI"), tag.Directory.Of(snapshot.View().Folder().Filename()))
- continue
- }
- reports.add(id, true, diags...) // treat go.mod diagnostics like analyses
- }
-
- // Diagnose all of the packages in the workspace.
- wsPkgs, err := snapshot.WorkspacePackages(ctx)
- if err != nil {
- if errors.Is(err, context.Canceled) {
- return nil, nil
- }
- // Some error messages can be displayed as diagnostics.
- if errList := (*source.ErrorList)(nil); errors.As(err, &errList) {
- if err := errorsToDiagnostic(ctx, snapshot, *errList, reports); err == nil {
- return reports, nil
- }
- }
- // Try constructing a more helpful error message out of this error.
- if s.handleFatalErrors(ctx, snapshot, modErr, err) {
- return nil, nil
- }
- event.Error(ctx, "errors diagnosing workspace", err, tag.Snapshot.Of(snapshot.ID()), tag.Directory.Of(snapshot.View().Folder()))
- // Present any `go list` errors directly to the user.
- if errors.Is(err, source.PackagesLoadError) {
- if err := s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
- Type: protocol.Error,
- Message: fmt.Sprintf(`The code in the workspace failed to compile (see the error message below).
-If you believe this is a mistake, please file an issue: https://github.com/golang/go/issues/new.
-%v`, err),
- }); err != nil {
- event.Error(ctx, "ShowMessage failed", err, tag.Directory.Of(snapshot.View().Folder().Filename()))
- }
- }
- return nil, nil
- }
- var (
- showMsgMu sync.Mutex
- showMsg *protocol.ShowMessageParams
- wg sync.WaitGroup
- )
- for _, pkg := range wsPkgs {
- wg.Add(1)
- go func(pkg source.Package) {
- defer wg.Done()
-
- withAnalysis := alwaysAnalyze // only run analyses for packages with open files
- var gcDetailsDir span.URI // find the package's optimization details, if available
- for _, pgf := range pkg.CompiledGoFiles() {
- if snapshot.IsOpen(pgf.URI) {
- withAnalysis = true
- }
- if gcDetailsDir == "" {
- dirURI := span.URIFromPath(filepath.Dir(pgf.URI.Filename()))
- s.gcOptimizationDetailsMu.Lock()
- _, ok := s.gcOptimizatonDetails[dirURI]
- s.gcOptimizationDetailsMu.Unlock()
- if ok {
- gcDetailsDir = dirURI
- }
- }
- }
-
- pkgReports, warn, err := source.Diagnostics(ctx, snapshot, pkg, withAnalysis)
-
- // Check if might want to warn the user about their build configuration.
- // Our caller decides whether to send the message.
- if warn && !snapshot.ValidBuildConfiguration() {
- showMsgMu.Lock()
- showMsg = &protocol.ShowMessageParams{
- Type: protocol.Warning,
- Message: `You are neither in a module nor in your GOPATH. If you are using modules, please open your editor to a directory in your module. If you believe this warning is incorrect, please file an issue: https://github.com/golang/go/issues/new.`,
- }
- showMsgMu.Unlock()
- }
- if err != nil {
- event.Error(ctx, "warning: diagnose package", err, tag.Snapshot.Of(snapshot.ID()), tag.Package.Of(pkg.ID()))
- return
- }
-
- // Add all reports to the global map, checking for duplicates.
- for id, diags := range pkgReports {
- reports.add(id, withAnalysis, diags...)
- }
- // If gc optimization details are available, add them to the
- // diagnostic reports.
- if gcDetailsDir != "" {
- gcReports, err := source.GCOptimizationDetails(ctx, snapshot, gcDetailsDir)
- if err != nil {
- event.Error(ctx, "warning: gc details", err, tag.Snapshot.Of(snapshot.ID()))
- }
- for id, diags := range gcReports {
- reports.add(id, withAnalysis, diags...)
- }
- }
- }(pkg)
- }
- wg.Wait()
- // Confirm that every opened file belongs to a package (if any exist in
- // the workspace). Otherwise, add a diagnostic to the file.
- if len(wsPkgs) > 0 {
- for _, o := range s.session.Overlays() {
- // Check if we already have diagnostic reports for the given file,
- // meaning that we have already seen its package.
- var seen bool
- for _, withAnalysis := range []bool{true, false} {
- _, ok := reports.reports[idWithAnalysis{
- id: o.VersionedFileIdentity(),
- withAnalysis: withAnalysis,
- }]
- seen = seen || ok
- }
- if seen {
- continue
- }
- diagnostic := s.checkForOrphanedFile(ctx, snapshot, o)
- if diagnostic == nil {
- continue
- }
- reports.add(o.VersionedFileIdentity(), true, diagnostic)
- }
- }
- return reports, showMsg
-}
-
-// checkForOrphanedFile checks that the given URIs can be mapped to packages.
-// If they cannot and the workspace is not otherwise unloaded, it also surfaces
-// a warning, suggesting that the user check the file for build tags.
-func (s *Server) checkForOrphanedFile(ctx context.Context, snapshot source.Snapshot, fh source.VersionedFileHandle) *source.Diagnostic {
- if fh.Kind() != source.Go {
- return nil
- }
- pkgs, err := snapshot.PackagesForFile(ctx, fh.URI(), source.TypecheckWorkspace)
- if len(pkgs) > 0 || err == nil {
- return nil
- }
- pgf, err := snapshot.ParseGo(ctx, fh, source.ParseHeader)
- if err != nil {
- return nil
- }
- spn, err := span.NewRange(snapshot.FileSet(), pgf.File.Name.Pos(), pgf.File.Name.End()).Span()
- if err != nil {
- return nil
- }
- rng, err := pgf.Mapper.Range(spn)
- if err != nil {
- return nil
- }
- // TODO(rstambler): We should be able to parse the build tags in the
- // file and show a more specific error message. For now, put the diagnostic
- // on the package declaration.
- return &source.Diagnostic{
- Range: rng,
- Message: fmt.Sprintf(`No packages found for open file %s: %v.
-If this file contains build tags, try adding "-tags=<build tag>" to your gopls "buildFlag" configuration (see (https://github.com/golang/tools/blob/master/gopls/doc/settings.md#buildflags-string).
-Otherwise, see the troubleshooting guidelines for help investigating (https://github.com/golang/tools/blob/master/gopls/doc/troubleshooting.md).
-`, fh.URI().Filename(), err),
- Severity: protocol.SeverityWarning,
- Source: "compiler",
- }
-}
-
-func errorsToDiagnostic(ctx context.Context, snapshot source.Snapshot, errors []*source.Error, reports *reportSet) error {
- for _, e := range errors {
- diagnostic := &source.Diagnostic{
- Range: e.Range,
- Message: e.Message,
- Related: e.Related,
- Severity: protocol.SeverityError,
- Source: e.Category,
- }
- fh, err := snapshot.GetVersionedFile(ctx, e.URI)
- if err != nil {
- return err
- }
- reports.add(fh.VersionedFileIdentity(), false, diagnostic)
- }
- return nil
-}
-
-func (s *Server) publishReports(ctx context.Context, snapshot source.Snapshot, reports *reportSet) {
- // Check for context cancellation before publishing diagnostics.
- if ctx.Err() != nil || reports == nil {
- return
- }
-
- s.deliveredMu.Lock()
- defer s.deliveredMu.Unlock()
-
- for key, diagnosticsMap := range reports.reports {
- // Don't deliver diagnostics if the context has already been canceled.
- if ctx.Err() != nil {
- break
- }
- // Pre-sort diagnostics to avoid extra work when we compare them.
- var diagnostics []*source.Diagnostic
- for _, d := range diagnosticsMap {
- diagnostics = append(diagnostics, d)
- }
- source.SortDiagnostics(diagnostics)
- toSend := sentDiagnostics{
- id: key.id,
- sorted: diagnostics,
- withAnalysis: key.withAnalysis,
- snapshotID: snapshot.ID(),
- }
-
- // We use the zero values if this is an unknown file.
- delivered := s.delivered[key.id.URI]
-
- // Snapshot IDs are always increasing, so we use them instead of file
- // versions to create the correct order for diagnostics.
-
- // If we've already delivered diagnostics for a future snapshot for this file,
- // do not deliver them.
- if delivered.snapshotID > toSend.snapshotID {
- // Do not update the delivered map since it already contains newer diagnostics.
- continue
- }
-
- // Check if we should reuse the cached diagnostics.
- if equalDiagnostics(delivered.sorted, diagnostics) {
- // Make sure to update the delivered map.
- s.delivered[key.id.URI] = toSend
- continue
- }
-
- // If we've already delivered diagnostics for this file, at this
- // snapshot, with analyses, do not send diagnostics without analyses.
- if delivered.snapshotID == toSend.snapshotID && delivered.id == toSend.id &&
- delivered.withAnalysis && !toSend.withAnalysis {
- // Do not update the delivered map since it already contains better diagnostics.
- continue
- }
- if err := s.client.PublishDiagnostics(ctx, &protocol.PublishDiagnosticsParams{
- Diagnostics: toProtocolDiagnostics(diagnostics),
- URI: protocol.URIFromSpanURI(key.id.URI),
- Version: key.id.Version,
- }); err != nil {
- event.Error(ctx, "publishReports: failed to deliver diagnostic", err, tag.URI.Of(key.id.URI))
- continue
- }
- // Update the delivered map.
- s.delivered[key.id.URI] = toSend
- }
-}
-
-// equalDiagnostics returns true if the 2 lists of diagnostics are equal.
-// It assumes that both a and b are already sorted.
-func equalDiagnostics(a, b []*source.Diagnostic) bool {
- if len(a) != len(b) {
- return false
- }
- for i := 0; i < len(a); i++ {
- if source.CompareDiagnostic(a[i], b[i]) != 0 {
- return false
- }
- }
- return true
-}
-
-func toProtocolDiagnostics(diagnostics []*source.Diagnostic) []protocol.Diagnostic {
- reports := []protocol.Diagnostic{}
- for _, diag := range diagnostics {
- related := make([]protocol.DiagnosticRelatedInformation, 0, len(diag.Related))
- for _, rel := range diag.Related {
- related = append(related, protocol.DiagnosticRelatedInformation{
- Location: protocol.Location{
- URI: protocol.URIFromSpanURI(rel.URI),
- Range: rel.Range,
- },
- Message: rel.Message,
- })
- }
- reports = append(reports, protocol.Diagnostic{
- // diag.Message might start with \n or \t
- Message: strings.TrimSpace(diag.Message),
- Range: diag.Range,
- Severity: diag.Severity,
- Source: diag.Source,
- Tags: diag.Tags,
- RelatedInformation: related,
- })
- }
- return reports
-}
-
-func (s *Server) handleFatalErrors(ctx context.Context, snapshot source.Snapshot, modErr, loadErr error) bool {
- // If the folder has no Go code in it, we shouldn't spam the user with a warning.
- var hasGo bool
- _ = filepath.Walk(snapshot.View().Folder().Filename(), func(path string, info os.FileInfo, err error) error {
- if err != nil {
- return err
- }
- if !strings.HasSuffix(info.Name(), ".go") {
- return nil
- }
- hasGo = true
- return errors.New("done")
- })
- if !hasGo {
- return true
- }
-
- // All other workarounds are for errors associated with modules.
- if len(snapshot.ModFiles()) == 0 {
- return false
- }
-
- switch loadErr {
- case source.InconsistentVendoring:
- item, err := s.client.ShowMessageRequest(ctx, &protocol.ShowMessageRequestParams{
- Type: protocol.Error,
- Message: `Inconsistent vendoring detected. Please re-run "go mod vendor".
-See https://github.com/golang/go/issues/39164 for more detail on this issue.`,
- Actions: []protocol.MessageActionItem{
- {Title: "go mod vendor"},
- },
- })
- // If the user closes the pop-up, don't show them further errors.
- if item == nil {
- return true
- }
- if err != nil {
- event.Error(ctx, "go mod vendor ShowMessageRequest failed", err, tag.Directory.Of(snapshot.View().Folder().Filename()))
- return true
- }
- // Right now, we don't have a good way of mapping the error message
- // to a specific module, so this will re-run `go mod vendor` in every
- // known module with a vendor directory.
- // TODO(rstambler): Only re-run `go mod vendor` in the relevant module.
- for _, uri := range snapshot.ModFiles() {
- // Check that there is a vendor directory in the module before
- // running `go mod vendor`.
- if info, _ := os.Stat(filepath.Join(filepath.Dir(uri.Filename()), "vendor")); info == nil {
- continue
- }
- if err := s.directGoModCommand(ctx, protocol.URIFromSpanURI(uri), "mod", []string{"vendor"}...); err != nil {
- if err := s.client.ShowMessage(ctx, &protocol.ShowMessageParams{
- Type: protocol.Error,
- Message: fmt.Sprintf(`"go mod vendor" failed with %v`, err),
- }); err != nil {
- if err != nil {
- event.Error(ctx, "go mod vendor ShowMessage failed", err, tag.Directory.Of(snapshot.View().Folder().Filename()))
- }
- }
- }
- }
- return true
- }
- return false
-}
projects / dotfiles / .git / blobdiff