blob: 2f0e7d624fd9f9c9e1faab3784bed991134bec70 [file] [log] [blame]
// 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 source
import (
"context"
"fmt"
"strings"
"golang.org/x/tools/go/analysis"
"golang.org/x/tools/internal/event"
"golang.org/x/tools/internal/lsp/debug/tag"
"golang.org/x/tools/internal/lsp/protocol"
"golang.org/x/tools/internal/span"
errors "golang.org/x/xerrors"
)
type Diagnostic struct {
Range protocol.Range
Message string
Source string
Severity protocol.DiagnosticSeverity
Tags []protocol.DiagnosticTag
Related []RelatedInformation
}
type SuggestedFix struct {
Title string
Edits map[span.URI][]protocol.TextEdit
}
type RelatedInformation struct {
URI span.URI
Range protocol.Range
Message string
}
func Diagnostics(ctx context.Context, snapshot Snapshot, pkg Package, withAnalysis bool) (map[VersionedFileIdentity][]*Diagnostic, bool, error) {
onlyIgnoredFiles := true
for _, pgf := range pkg.CompiledGoFiles() {
onlyIgnoredFiles = onlyIgnoredFiles && snapshot.IgnoredFile(pgf.URI)
}
if onlyIgnoredFiles {
return nil, false, nil
}
// If we are missing dependencies, it may because the user's workspace is
// not correctly configured. Report errors, if possible.
var warn bool
if len(pkg.MissingDependencies()) > 0 {
warn = true
}
// If we have a package with a single file and errors about "undeclared" symbols,
// we may have an ad-hoc package with multiple files. Show a warning message.
// TODO(golang/go#36416): Remove this when golang.org/cl/202277 is merged.
if len(pkg.CompiledGoFiles()) == 1 && hasUndeclaredErrors(pkg) {
warn = true
}
// Prepare the reports we will send for the files in this package.
reports := make(map[VersionedFileIdentity][]*Diagnostic)
for _, pgf := range pkg.CompiledGoFiles() {
clearReports(snapshot, reports, pgf.URI)
}
// Prepare any additional reports for the errors in this package.
for _, e := range pkg.GetErrors() {
// We only need to handle lower-level errors.
if e.Kind != ListError {
continue
}
// If no file is associated with the error, pick an open file from the package.
if e.URI.Filename() == "" {
for _, pgf := range pkg.CompiledGoFiles() {
if snapshot.IsOpen(pgf.URI) {
e.URI = pgf.URI
}
}
}
clearReports(snapshot, reports, e.URI)
}
// Run diagnostics for the package that this URI belongs to.
hadDiagnostics, hadTypeErrors, err := diagnostics(ctx, snapshot, reports, pkg, len(pkg.MissingDependencies()) > 0)
if err != nil {
return nil, warn, err
}
if hadDiagnostics || !withAnalysis {
return reports, warn, nil
}
// Exit early if the context has been canceled. This also protects us
// from a race on Options, see golang/go#36699.
if ctx.Err() != nil {
return nil, warn, ctx.Err()
}
// If we don't have any list or parse errors, run analyses.
analyzers := pickAnalyzers(snapshot, hadTypeErrors)
if err := analyses(ctx, snapshot, reports, pkg, analyzers); err != nil {
event.Error(ctx, "analyses failed", err, tag.Snapshot.Of(snapshot.ID()), tag.Package.Of(pkg.ID()))
if ctx.Err() != nil {
return nil, warn, ctx.Err()
}
}
return reports, warn, nil
}
func pickAnalyzers(snapshot Snapshot, hadTypeErrors bool) map[string]Analyzer {
analyzers := make(map[string]Analyzer)
// Always run convenience analyzers.
for k, v := range snapshot.View().Options().ConvenienceAnalyzers {
analyzers[k] = v
}
// If we had type errors, only run type error analyzers.
if hadTypeErrors {
for k, v := range snapshot.View().Options().TypeErrorAnalyzers {
analyzers[k] = v
}
return analyzers
}
for k, v := range snapshot.View().Options().DefaultAnalyzers {
analyzers[k] = v
}
for k, v := range snapshot.View().Options().StaticcheckAnalyzers {
analyzers[k] = v
}
return analyzers
}
func FileDiagnostics(ctx context.Context, snapshot Snapshot, uri span.URI) (VersionedFileIdentity, []*Diagnostic, error) {
fh, err := snapshot.GetVersionedFile(ctx, uri)
if err != nil {
return VersionedFileIdentity{}, nil, err
}
pkg, _, err := GetParsedFile(ctx, snapshot, fh, NarrowestPackage)
if err != nil {
return VersionedFileIdentity{}, nil, err
}
reports, _, err := Diagnostics(ctx, snapshot, pkg, true)
if err != nil {
return VersionedFileIdentity{}, nil, err
}
diagnostics, ok := reports[fh.VersionedFileIdentity()]
if !ok {
return VersionedFileIdentity{}, nil, errors.Errorf("no diagnostics for %s", uri)
}
return fh.VersionedFileIdentity(), diagnostics, nil
}
type diagnosticSet struct {
listErrors, parseErrors, typeErrors []*Diagnostic
}
func diagnostics(ctx context.Context, snapshot Snapshot, reports map[VersionedFileIdentity][]*Diagnostic, pkg Package, hasMissingDeps bool) (bool, bool, error) {
ctx, done := event.Start(ctx, "source.diagnostics", tag.Package.Of(pkg.ID()))
_ = ctx // circumvent SA4006
defer done()
diagSets := make(map[span.URI]*diagnosticSet)
for _, e := range pkg.GetErrors() {
diag := &Diagnostic{
Message: e.Message,
Range: e.Range,
Severity: protocol.SeverityError,
Related: e.Related,
}
set, ok := diagSets[e.URI]
if !ok {
set = &diagnosticSet{}
diagSets[e.URI] = set
}
switch e.Kind {
case ParseError:
set.parseErrors = append(set.parseErrors, diag)
diag.Source = "syntax"
case TypeError:
set.typeErrors = append(set.typeErrors, diag)
diag.Source = "compiler"
case ListError:
set.listErrors = append(set.listErrors, diag)
diag.Source = "go list"
}
}
var nonEmptyDiagnostics, hasTypeErrors bool // track if we actually send non-empty diagnostics
for uri, set := range diagSets {
// Don't report type errors if there are parse errors or list errors.
diags := set.typeErrors
if len(set.parseErrors) > 0 {
diags, nonEmptyDiagnostics = set.parseErrors, true
} else if len(set.listErrors) > 0 {
// Only show list errors if the package has missing dependencies.
if hasMissingDeps {
diags, nonEmptyDiagnostics = set.listErrors, true
}
} else if len(set.typeErrors) > 0 {
hasTypeErrors = true
}
if err := addReports(snapshot, reports, uri, diags...); err != nil {
return false, false, err
}
}
return nonEmptyDiagnostics, hasTypeErrors, nil
}
func analyses(ctx context.Context, snapshot Snapshot, reports map[VersionedFileIdentity][]*Diagnostic, pkg Package, analyses map[string]Analyzer) error {
var analyzers []*analysis.Analyzer
for _, a := range analyses {
if !a.IsEnabled(snapshot.View()) {
continue
}
analyzers = append(analyzers, a.Analyzer)
}
analysisErrors, err := snapshot.Analyze(ctx, pkg.ID(), analyzers...)
if err != nil {
return err
}
// Report diagnostics and errors from root analyzers.
for _, e := range analysisErrors {
// If the diagnostic comes from a "convenience" analyzer, it is not
// meant to provide diagnostics, but rather only suggested fixes.
// Skip these types of errors in diagnostics; we will use their
// suggested fixes when providing code actions.
if isConvenienceAnalyzer(e.Category) {
continue
}
// This is a bit of a hack, but clients > 3.15 will be able to grey out unnecessary code.
// If we are deleting code as part of all of our suggested fixes, assume that this is dead code.
// TODO(golang/go#34508): Return these codes from the diagnostics themselves.
var tags []protocol.DiagnosticTag
if onlyDeletions(e.SuggestedFixes) {
tags = append(tags, protocol.Unnecessary)
}
if err := addReports(snapshot, reports, e.URI, &Diagnostic{
Range: e.Range,
Message: e.Message,
Source: e.Category,
Severity: protocol.SeverityWarning,
Tags: tags,
Related: e.Related,
}); err != nil {
return err
}
}
return nil
}
func clearReports(snapshot Snapshot, reports map[VersionedFileIdentity][]*Diagnostic, uri span.URI) {
fh := snapshot.FindFile(uri)
if fh == nil {
return
}
reports[fh.VersionedFileIdentity()] = []*Diagnostic{}
}
func addReports(snapshot Snapshot, reports map[VersionedFileIdentity][]*Diagnostic, uri span.URI, diagnostics ...*Diagnostic) error {
fh := snapshot.FindFile(uri)
if fh == nil {
return nil
}
existingDiagnostics, ok := reports[fh.VersionedFileIdentity()]
if !ok {
return fmt.Errorf("diagnostics for unexpected file %s", uri)
}
if len(diagnostics) == 1 {
d1 := diagnostics[0]
if _, ok := snapshot.View().Options().TypeErrorAnalyzers[d1.Source]; ok {
for i, d2 := range existingDiagnostics {
if r := protocol.CompareRange(d1.Range, d2.Range); r != 0 {
continue
}
if d1.Message != d2.Message {
continue
}
reports[fh.VersionedFileIdentity()][i].Tags = append(reports[fh.VersionedFileIdentity()][i].Tags, d1.Tags...)
}
return nil
}
}
reports[fh.VersionedFileIdentity()] = append(reports[fh.VersionedFileIdentity()], diagnostics...)
return nil
}
// onlyDeletions returns true if all of the suggested fixes are deletions.
func onlyDeletions(fixes []SuggestedFix) bool {
for _, fix := range fixes {
for _, edits := range fix.Edits {
for _, edit := range edits {
if edit.NewText != "" {
return false
}
if protocol.ComparePosition(edit.Range.Start, edit.Range.End) == 0 {
return false
}
}
}
}
return len(fixes) > 0
}
// hasUndeclaredErrors returns true if a package has a type error
// about an undeclared symbol.
func hasUndeclaredErrors(pkg Package) bool {
for _, err := range pkg.GetErrors() {
if err.Kind != TypeError {
continue
}
if strings.Contains(err.Message, "undeclared name:") {
return true
}
}
return false
}
func isConvenienceAnalyzer(category string) bool {
for _, a := range DefaultOptions().ConvenienceAnalyzers {
if category == a.Analyzer.Name {
return true
}
}
return false
}