mirror of
https://github.com/golang/go
synced 2024-11-19 01:54:39 -07:00
f520afa52e
Ignore ignored the builtin package and files that start with _. The latter should already be ignored by "go list". The former seems like too much effort to me. People shouldn't edit random parts of the stdlib, and ignoring changes to (e.g.) the Error interface seems like the least of the trouble they can get themselves into. Remove it for now. If we get complains I'll re-add it, probably by rejecting the write entirely somewhere. We incidentally relied on this in the identifier functions; change those to treat the builtin package slightly more specially. Change-Id: I005b02a66b1a987c50a3074d53a2d28ff07d3324 Reviewed-on: https://go-review.googlesource.com/c/tools/+/237597 Run-TryBot: Heschi Kreinick <heschi@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Rebecca Stambler <rstambler@golang.org>
373 lines
11 KiB
Go
373 lines
11 KiB
Go
// 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"
|
|
"go/ast"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"golang.org/x/mod/modfile"
|
|
"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, ph PackageHandle, missingModules map[string]*modfile.Require, withAnalysis bool) (map[FileIdentity][]*Diagnostic, bool, error) {
|
|
// 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(ph.MissingDependencies()) > 0 {
|
|
warn = true
|
|
}
|
|
pkg, err := ph.Check(ctx)
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
// 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
|
|
}
|
|
|
|
missing := make(map[string]*modfile.Require)
|
|
for _, imp := range pkg.Imports() {
|
|
if req, ok := missingModules[imp.PkgPath()]; ok {
|
|
missing[imp.PkgPath()] = req
|
|
continue
|
|
}
|
|
for dep, req := range missingModules {
|
|
// If the import is a package of the dependency, then add the package to the map, this will
|
|
// eliminate the need to do this prefix package search on each import for each file.
|
|
// Example:
|
|
// import (
|
|
// "golang.org/x/tools/go/expect"
|
|
// "golang.org/x/tools/go/packages"
|
|
// )
|
|
// They both are related to the same module: "golang.org/x/tools"
|
|
if req != nil && strings.HasPrefix(imp.PkgPath(), dep) {
|
|
missing[imp.PkgPath()] = req
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
// Prepare the reports we will send for the files in this package.
|
|
reports := make(map[FileIdentity][]*Diagnostic)
|
|
for _, pgh := range pkg.CompiledGoFiles() {
|
|
clearReports(ctx, snapshot, reports, pgh.File().URI())
|
|
if len(missing) > 0 {
|
|
if err := missingModulesDiagnostics(ctx, snapshot, reports, missing, pgh.File().URI()); err != nil {
|
|
return nil, warn, err
|
|
}
|
|
}
|
|
}
|
|
// 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 _, pgh := range pkg.CompiledGoFiles() {
|
|
if snapshot.IsOpen(pgh.File().URI()) {
|
|
e.URI = pgh.File().URI()
|
|
}
|
|
}
|
|
}
|
|
clearReports(ctx, snapshot, reports, e.URI)
|
|
}
|
|
// Run diagnostics for the package that this URI belongs to.
|
|
hadDiagnostics, hadTypeErrors, err := diagnostics(ctx, snapshot, reports, pkg, len(ph.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 := snapshot.View().Options().DefaultAnalyzers
|
|
if hadTypeErrors {
|
|
analyzers = snapshot.View().Options().TypeErrorAnalyzers
|
|
}
|
|
if err := analyses(ctx, snapshot, reports, ph, analyzers); err != nil {
|
|
event.Error(ctx, "analyses failed", err, tag.Snapshot.Of(snapshot.ID()), tag.Package.Of(ph.ID()))
|
|
if ctx.Err() != nil {
|
|
return nil, warn, ctx.Err()
|
|
}
|
|
}
|
|
return reports, warn, nil
|
|
}
|
|
|
|
func FileDiagnostics(ctx context.Context, snapshot Snapshot, uri span.URI) (FileIdentity, []*Diagnostic, error) {
|
|
fh, err := snapshot.GetFile(ctx, uri)
|
|
if err != nil {
|
|
return FileIdentity{}, nil, err
|
|
}
|
|
phs, err := snapshot.PackageHandles(ctx, fh)
|
|
if err != nil {
|
|
return FileIdentity{}, nil, err
|
|
}
|
|
ph, err := NarrowestPackageHandle(phs)
|
|
if err != nil {
|
|
return FileIdentity{}, nil, err
|
|
}
|
|
reports, _, err := Diagnostics(ctx, snapshot, ph, nil, true)
|
|
if err != nil {
|
|
return FileIdentity{}, nil, err
|
|
}
|
|
diagnostics, ok := reports[fh.Identity()]
|
|
if !ok {
|
|
return FileIdentity{}, nil, errors.Errorf("no diagnostics for %s", uri)
|
|
}
|
|
return fh.Identity(), diagnostics, nil
|
|
}
|
|
|
|
type diagnosticSet struct {
|
|
listErrors, parseErrors, typeErrors []*Diagnostic
|
|
}
|
|
|
|
func diagnostics(ctx context.Context, snapshot Snapshot, reports map[FileIdentity][]*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,
|
|
}
|
|
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(ctx, snapshot, reports, uri, diags...); err != nil {
|
|
return false, false, err
|
|
}
|
|
}
|
|
return nonEmptyDiagnostics, hasTypeErrors, nil
|
|
}
|
|
|
|
func missingModulesDiagnostics(ctx context.Context, snapshot Snapshot, reports map[FileIdentity][]*Diagnostic, missingModules map[string]*modfile.Require, uri span.URI) error {
|
|
if len(missingModules) == 0 {
|
|
return nil
|
|
}
|
|
fh, err := snapshot.GetFile(ctx, uri)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pgh := snapshot.View().Session().Cache().ParseGoHandle(ctx, fh, ParseHeader)
|
|
file, _, m, _, err := pgh.Parse(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Make a dependency->import map to improve performance when finding missing dependencies.
|
|
imports := make(map[string]*ast.ImportSpec)
|
|
for _, imp := range file.Imports {
|
|
if imp.Path == nil {
|
|
continue
|
|
}
|
|
if target, err := strconv.Unquote(imp.Path.Value); err == nil {
|
|
imports[target] = imp
|
|
}
|
|
}
|
|
// If the go file has 0 imports, then we do not need to check for missing dependencies.
|
|
if len(imports) == 0 {
|
|
return nil
|
|
}
|
|
if reports[fh.Identity()] == nil {
|
|
reports[fh.Identity()] = []*Diagnostic{}
|
|
}
|
|
for mod, req := range missingModules {
|
|
if req.Syntax == nil {
|
|
continue
|
|
}
|
|
imp, ok := imports[mod]
|
|
if !ok {
|
|
continue
|
|
}
|
|
spn, err := span.NewRange(snapshot.View().Session().Cache().FileSet(), imp.Path.Pos(), imp.Path.End()).Span()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rng, err := m.Range(spn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
reports[fh.Identity()] = append(reports[fh.Identity()], &Diagnostic{
|
|
Message: fmt.Sprintf("%s is not in your go.mod file.", req.Mod.Path),
|
|
Range: rng,
|
|
Source: "go mod tidy",
|
|
Severity: protocol.SeverityWarning,
|
|
})
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func analyses(ctx context.Context, snapshot Snapshot, reports map[FileIdentity][]*Diagnostic, ph PackageHandle, analyses map[string]Analyzer) error {
|
|
var analyzers []*analysis.Analyzer
|
|
for _, a := range analyses {
|
|
if !a.Enabled(snapshot) {
|
|
continue
|
|
}
|
|
analyzers = append(analyzers, a.Analyzer)
|
|
}
|
|
analysisErrors, err := snapshot.Analyze(ctx, ph.ID(), analyzers...)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// Report diagnostics and errors from root analyzers.
|
|
for _, e := range analysisErrors {
|
|
// 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(ctx, 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(ctx context.Context, snapshot Snapshot, reports map[FileIdentity][]*Diagnostic, uri span.URI) {
|
|
fh := snapshot.FindFile(uri)
|
|
if fh == nil {
|
|
return
|
|
}
|
|
reports[fh.Identity()] = []*Diagnostic{}
|
|
}
|
|
|
|
func addReports(ctx context.Context, snapshot Snapshot, reports map[FileIdentity][]*Diagnostic, uri span.URI, diagnostics ...*Diagnostic) error {
|
|
fh := snapshot.FindFile(uri)
|
|
if fh == nil {
|
|
return nil
|
|
}
|
|
existingDiagnostics, ok := reports[fh.Identity()]
|
|
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.Identity()][i].Tags = append(reports[fh.Identity()][i].Tags, d1.Tags...)
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
reports[fh.Identity()] = append(reports[fh.Identity()], 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
|
|
}
|