+++ /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 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
-}
projects / dotfiles / .git / blobdiff