+++ /dev/null
-// 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"
- "fmt"
- "go/scanner"
- "go/token"
- "go/types"
- "regexp"
- "strconv"
- "strings"
-
- "golang.org/x/tools/go/analysis"
- "golang.org/x/tools/go/packages"
- "golang.org/x/tools/internal/analysisinternal"
- "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/lsp/source"
- "golang.org/x/tools/internal/span"
- errors "golang.org/x/xerrors"
-)
-
-func sourceError(ctx context.Context, snapshot *snapshot, pkg *pkg, e interface{}) (*source.Error, error) {
- fset := snapshot.view.session.cache.fset
- var (
- spn span.Span
- err error
- msg, category string
- kind source.ErrorKind
- fixes []source.SuggestedFix
- related []source.RelatedInformation
- )
- switch e := e.(type) {
- case packages.Error:
- kind = toSourceErrorKind(e.Kind)
- var ok bool
- if msg, spn, ok = parseGoListImportCycleError(ctx, snapshot, e, pkg); ok {
- kind = source.TypeError
- break
- }
- if e.Pos == "" {
- spn = parseGoListError(e.Msg)
-
- // We may not have been able to parse a valid span.
- if _, err := spanToRange(snapshot, pkg, spn); err != nil {
- return &source.Error{
- URI: spn.URI(),
- Message: msg,
- Kind: kind,
- }, nil
- }
- } else {
- spn = span.Parse(e.Pos)
- }
- case *scanner.Error:
- msg = e.Msg
- kind = source.ParseError
- spn, err = scannerErrorRange(snapshot, pkg, e.Pos)
- if err != nil {
- if ctx.Err() != nil {
- return nil, ctx.Err()
- }
- event.Error(ctx, "no span for scanner.Error pos", err, tag.Package.Of(pkg.ID()))
- spn = span.Parse(e.Pos.String())
- }
-
- case scanner.ErrorList:
- // The first parser error is likely the root cause of the problem.
- if e.Len() <= 0 {
- return nil, errors.Errorf("no errors in %v", e)
- }
- msg = e[0].Msg
- kind = source.ParseError
- spn, err = scannerErrorRange(snapshot, pkg, e[0].Pos)
- if err != nil {
- if ctx.Err() != nil {
- return nil, ctx.Err()
- }
- event.Error(ctx, "no span for scanner.Error pos", err, tag.Package.Of(pkg.ID()))
- spn = span.Parse(e[0].Pos.String())
- }
- case types.Error:
- msg = e.Msg
- kind = source.TypeError
- if !e.Pos.IsValid() {
- return nil, fmt.Errorf("invalid position for type error %v", e)
- }
- spn, err = typeErrorRange(snapshot, fset, pkg, e.Pos)
- if err != nil {
- return nil, err
- }
- case extendedError:
- perr := e.primary
- msg = perr.Msg
- kind = source.TypeError
- if !perr.Pos.IsValid() {
- return nil, fmt.Errorf("invalid position for type error %v", e)
- }
- spn, err = typeErrorRange(snapshot, fset, pkg, perr.Pos)
- if err != nil {
- return nil, err
- }
- for _, s := range e.secondaries {
- var x source.RelatedInformation
- x.Message = s.Msg
- xspn, err := typeErrorRange(snapshot, fset, pkg, s.Pos)
- if err != nil {
- return nil, fmt.Errorf("invalid position for type error %v", s)
- }
- x.URI = xspn.URI()
- rng, err := spanToRange(snapshot, pkg, xspn)
- if err != nil {
- return nil, err
- }
- x.Range = rng
- related = append(related, x)
- }
- case *analysis.Diagnostic:
- spn, err = span.NewRange(fset, e.Pos, e.End).Span()
- if err != nil {
- return nil, err
- }
- msg = e.Message
- kind = source.Analysis
- category = e.Category
- fixes, err = suggestedFixes(snapshot, pkg, e)
- if err != nil {
- return nil, err
- }
- related, err = relatedInformation(snapshot, pkg, e)
- if err != nil {
- return nil, err
- }
- default:
- panic(fmt.Sprintf("%T unexpected", e))
- }
- rng, err := spanToRange(snapshot, pkg, spn)
- if err != nil {
- return nil, err
- }
- return &source.Error{
- URI: spn.URI(),
- Range: rng,
- Message: msg,
- Kind: kind,
- Category: category,
- SuggestedFixes: fixes,
- Related: related,
- }, nil
-}
-
-func suggestedFixes(snapshot *snapshot, pkg *pkg, diag *analysis.Diagnostic) ([]source.SuggestedFix, error) {
- var fixes []source.SuggestedFix
- for _, fix := range diag.SuggestedFixes {
- edits := make(map[span.URI][]protocol.TextEdit)
- for _, e := range fix.TextEdits {
- spn, err := span.NewRange(snapshot.view.session.cache.fset, e.Pos, e.End).Span()
- if err != nil {
- return nil, err
- }
- rng, err := spanToRange(snapshot, pkg, spn)
- if err != nil {
- return nil, err
- }
- edits[spn.URI()] = append(edits[spn.URI()], protocol.TextEdit{
- Range: rng,
- NewText: string(e.NewText),
- })
- }
- fixes = append(fixes, source.SuggestedFix{
- Title: fix.Message,
- Edits: edits,
- })
- }
- return fixes, nil
-}
-
-func relatedInformation(snapshot *snapshot, pkg *pkg, diag *analysis.Diagnostic) ([]source.RelatedInformation, error) {
- var out []source.RelatedInformation
- for _, related := range diag.Related {
- spn, err := span.NewRange(snapshot.view.session.cache.fset, related.Pos, related.End).Span()
- if err != nil {
- return nil, err
- }
- rng, err := spanToRange(snapshot, pkg, spn)
- if err != nil {
- return nil, err
- }
- out = append(out, source.RelatedInformation{
- URI: spn.URI(),
- Range: rng,
- Message: related.Message,
- })
- }
- return out, nil
-}
-
-func toSourceErrorKind(kind packages.ErrorKind) source.ErrorKind {
- switch kind {
- case packages.ListError:
- return source.ListError
- case packages.ParseError:
- return source.ParseError
- case packages.TypeError:
- return source.TypeError
- default:
- return source.UnknownError
- }
-}
-
-func typeErrorRange(snapshot *snapshot, fset *token.FileSet, pkg *pkg, pos token.Pos) (span.Span, error) {
- posn := fset.Position(pos)
- pgf, err := pkg.File(span.URIFromPath(posn.Filename))
- if err != nil {
- return span.Span{}, err
- }
- return span.Range{
- FileSet: fset,
- Start: pos,
- End: analysisinternal.TypeErrorEndPos(fset, pgf.Src, pos),
- Converter: pgf.Mapper.Converter,
- }.Span()
-}
-
-func scannerErrorRange(snapshot *snapshot, pkg *pkg, posn token.Position) (span.Span, error) {
- fset := snapshot.view.session.cache.fset
- pgf, err := pkg.File(span.URIFromPath(posn.Filename))
- if err != nil {
- return span.Span{}, err
- }
- pos := pgf.Tok.Pos(posn.Offset)
- return span.NewRange(fset, pos, pos).Span()
-}
-
-// spanToRange converts a span.Span to a protocol.Range,
-// assuming that the span belongs to the package whose diagnostics are being computed.
-func spanToRange(snapshot *snapshot, pkg *pkg, spn span.Span) (protocol.Range, error) {
- pgf, err := pkg.File(spn.URI())
- if err != nil {
- return protocol.Range{}, err
- }
- return pgf.Mapper.Range(spn)
-}
-
-// parseGoListError attempts to parse a standard `go list` error message
-// by stripping off the trailing error message.
-//
-// It works only on errors whose message is prefixed by colon,
-// followed by a space (": "). For example:
-//
-// attributes.go:13:1: expected 'package', found 'type'
-//
-func parseGoListError(input string) span.Span {
- input = strings.TrimSpace(input)
- msgIndex := strings.Index(input, ": ")
- if msgIndex < 0 {
- return span.Parse(input)
- }
- return span.Parse(input[:msgIndex])
-}
-
-func parseGoListImportCycleError(ctx context.Context, snapshot *snapshot, e packages.Error, pkg *pkg) (string, span.Span, bool) {
- re := regexp.MustCompile(`(.*): import stack: \[(.+)\]`)
- matches := re.FindStringSubmatch(strings.TrimSpace(e.Msg))
- if len(matches) < 3 {
- return e.Msg, span.Span{}, false
- }
- msg := matches[1]
- importList := strings.Split(matches[2], " ")
- // Since the error is relative to the current package. The import that is causing
- // the import cycle error is the second one in the list.
- if len(importList) < 2 {
- return msg, span.Span{}, false
- }
- // Imports have quotation marks around them.
- circImp := strconv.Quote(importList[1])
- for _, cgf := range pkg.compiledGoFiles {
- // Search file imports for the import that is causing the import cycle.
- for _, imp := range cgf.File.Imports {
- if imp.Path.Value == circImp {
- spn, err := span.NewRange(snapshot.view.session.cache.fset, imp.Pos(), imp.End()).Span()
- if err != nil {
- return msg, span.Span{}, false
- }
- return msg, spn, true
- }
- }
- }
- return msg, span.Span{}, false
-}
projects / dotfiles / .git / blobdiff