+++ /dev/null
-// Package lint provides the foundation for tools like staticcheck
-package lint // import "honnef.co/go/tools/lint"
-
-import (
- "bytes"
- "encoding/gob"
- "fmt"
- "go/scanner"
- "go/token"
- "go/types"
- "path/filepath"
- "sort"
- "strings"
- "sync"
- "sync/atomic"
- "unicode"
-
- "golang.org/x/tools/go/analysis"
- "golang.org/x/tools/go/packages"
- "honnef.co/go/tools/config"
- "honnef.co/go/tools/internal/cache"
-)
-
-type Documentation struct {
- Title string
- Text string
- Since string
- NonDefault bool
- Options []string
-}
-
-func (doc *Documentation) String() string {
- b := &strings.Builder{}
- fmt.Fprintf(b, "%s\n\n", doc.Title)
- if doc.Text != "" {
- fmt.Fprintf(b, "%s\n\n", doc.Text)
- }
- fmt.Fprint(b, "Available since\n ")
- if doc.Since == "" {
- fmt.Fprint(b, "unreleased")
- } else {
- fmt.Fprintf(b, "%s", doc.Since)
- }
- if doc.NonDefault {
- fmt.Fprint(b, ", non-default")
- }
- fmt.Fprint(b, "\n")
- if len(doc.Options) > 0 {
- fmt.Fprintf(b, "\nOptions\n")
- for _, opt := range doc.Options {
- fmt.Fprintf(b, " %s", opt)
- }
- fmt.Fprint(b, "\n")
- }
- return b.String()
-}
-
-type Ignore interface {
- Match(p Problem) bool
-}
-
-type LineIgnore struct {
- File string
- Line int
- Checks []string
- Matched bool
- Pos token.Position
-}
-
-func (li *LineIgnore) Match(p Problem) bool {
- pos := p.Pos
- if pos.Filename != li.File || pos.Line != li.Line {
- return false
- }
- for _, c := range li.Checks {
- if m, _ := filepath.Match(c, p.Check); m {
- li.Matched = true
- return true
- }
- }
- return false
-}
-
-func (li *LineIgnore) String() string {
- matched := "not matched"
- if li.Matched {
- matched = "matched"
- }
- return fmt.Sprintf("%s:%d %s (%s)", li.File, li.Line, strings.Join(li.Checks, ", "), matched)
-}
-
-type FileIgnore struct {
- File string
- Checks []string
-}
-
-func (fi *FileIgnore) Match(p Problem) bool {
- if p.Pos.Filename != fi.File {
- return false
- }
- for _, c := range fi.Checks {
- if m, _ := filepath.Match(c, p.Check); m {
- return true
- }
- }
- return false
-}
-
-type Severity uint8
-
-const (
- Error Severity = iota
- Warning
- Ignored
-)
-
-// Problem represents a problem in some source code.
-type Problem struct {
- Pos token.Position
- End token.Position
- Message string
- Check string
- Severity Severity
- Related []Related
-}
-
-type Related struct {
- Pos token.Position
- End token.Position
- Message string
-}
-
-func (p Problem) Equal(o Problem) bool {
- return p.Pos == o.Pos &&
- p.End == o.End &&
- p.Message == o.Message &&
- p.Check == o.Check &&
- p.Severity == o.Severity
-}
-
-func (p *Problem) String() string {
- return fmt.Sprintf("%s (%s)", p.Message, p.Check)
-}
-
-// A Linter lints Go source code.
-type Linter struct {
- Checkers []*analysis.Analyzer
- CumulativeCheckers []CumulativeChecker
- GoVersion int
- Config config.Config
- Stats Stats
- RepeatAnalyzers uint
-}
-
-type CumulativeChecker interface {
- Analyzer() *analysis.Analyzer
- Result() []types.Object
- ProblemObject(*token.FileSet, types.Object) Problem
-}
-
-func (l *Linter) Lint(cfg *packages.Config, patterns []string) ([]Problem, error) {
- var allAnalyzers []*analysis.Analyzer
- allAnalyzers = append(allAnalyzers, l.Checkers...)
- for _, cum := range l.CumulativeCheckers {
- allAnalyzers = append(allAnalyzers, cum.Analyzer())
- }
-
- // The -checks command line flag overrules all configuration
- // files, which means that for `-checks="foo"`, no check other
- // than foo can ever be reported to the user. Make use of this
- // fact to cull the list of analyses we need to run.
-
- // replace "inherit" with "all", as we don't want to base the
- // list of all checks on the default configuration, which
- // disables certain checks.
- checks := make([]string, len(l.Config.Checks))
- copy(checks, l.Config.Checks)
- for i, c := range checks {
- if c == "inherit" {
- checks[i] = "all"
- }
- }
-
- allowed := FilterChecks(allAnalyzers, checks)
- var allowedAnalyzers []*analysis.Analyzer
- for _, c := range l.Checkers {
- if allowed[c.Name] {
- allowedAnalyzers = append(allowedAnalyzers, c)
- }
- }
- hasCumulative := false
- for _, cum := range l.CumulativeCheckers {
- a := cum.Analyzer()
- if allowed[a.Name] {
- hasCumulative = true
- allowedAnalyzers = append(allowedAnalyzers, a)
- }
- }
-
- r, err := NewRunner(&l.Stats)
- if err != nil {
- return nil, err
- }
- r.goVersion = l.GoVersion
- r.repeatAnalyzers = l.RepeatAnalyzers
-
- pkgs, err := r.Run(cfg, patterns, allowedAnalyzers, hasCumulative)
- if err != nil {
- return nil, err
- }
-
- tpkgToPkg := map[*types.Package]*Package{}
- for _, pkg := range pkgs {
- tpkgToPkg[pkg.Types] = pkg
-
- for _, e := range pkg.errs {
- switch e := e.(type) {
- case types.Error:
- p := Problem{
- Pos: e.Fset.PositionFor(e.Pos, false),
- Message: e.Msg,
- Severity: Error,
- Check: "compile",
- }
- pkg.problems = append(pkg.problems, p)
- case packages.Error:
- msg := e.Msg
- if len(msg) != 0 && msg[0] == '\n' {
- // TODO(dh): See https://github.com/golang/go/issues/32363
- msg = msg[1:]
- }
-
- var pos token.Position
- if e.Pos == "" {
- // Under certain conditions (malformed package
- // declarations, multiple packages in the same
- // directory), go list emits an error on stderr
- // instead of JSON. Those errors do not have
- // associated position information in
- // go/packages.Error, even though the output on
- // stderr may contain it.
- if p, n, err := parsePos(msg); err == nil {
- if abs, err := filepath.Abs(p.Filename); err == nil {
- p.Filename = abs
- }
- pos = p
- msg = msg[n+2:]
- }
- } else {
- var err error
- pos, _, err = parsePos(e.Pos)
- if err != nil {
- panic(fmt.Sprintf("internal error: %s", e))
- }
- }
- p := Problem{
- Pos: pos,
- Message: msg,
- Severity: Error,
- Check: "compile",
- }
- pkg.problems = append(pkg.problems, p)
- case scanner.ErrorList:
- for _, e := range e {
- p := Problem{
- Pos: e.Pos,
- Message: e.Msg,
- Severity: Error,
- Check: "compile",
- }
- pkg.problems = append(pkg.problems, p)
- }
- case error:
- p := Problem{
- Pos: token.Position{},
- Message: e.Error(),
- Severity: Error,
- Check: "compile",
- }
- pkg.problems = append(pkg.problems, p)
- }
- }
- }
-
- atomic.StoreUint32(&r.stats.State, StateCumulative)
- for _, cum := range l.CumulativeCheckers {
- for _, res := range cum.Result() {
- pkg := tpkgToPkg[res.Pkg()]
- if pkg == nil {
- panic(fmt.Sprintf("analyzer %s flagged object %s in package %s, a package that we aren't tracking", cum.Analyzer(), res, res.Pkg()))
- }
- allowedChecks := FilterChecks(allowedAnalyzers, pkg.cfg.Merge(l.Config).Checks)
- if allowedChecks[cum.Analyzer().Name] {
- pos := DisplayPosition(pkg.Fset, res.Pos())
- // FIXME(dh): why are we ignoring generated files
- // here? Surely this is specific to 'unused', not all
- // cumulative checkers
- if _, ok := pkg.gen[pos.Filename]; ok {
- continue
- }
- p := cum.ProblemObject(pkg.Fset, res)
- pkg.problems = append(pkg.problems, p)
- }
- }
- }
-
- for _, pkg := range pkgs {
- if !pkg.fromSource {
- // Don't cache packages that we loaded from the cache
- continue
- }
- cpkg := cachedPackage{
- Problems: pkg.problems,
- Ignores: pkg.ignores,
- Config: pkg.cfg,
- }
- buf := &bytes.Buffer{}
- if err := gob.NewEncoder(buf).Encode(cpkg); err != nil {
- return nil, err
- }
- id := cache.Subkey(pkg.actionID, "data "+r.problemsCacheKey)
- if err := r.cache.PutBytes(id, buf.Bytes()); err != nil {
- return nil, err
- }
- }
-
- var problems []Problem
- // Deduplicate line ignores. When U1000 processes a package and
- // its test variant, it will only emit a single problem for an
- // unused object, not two problems. We will, however, have two
- // line ignores, one per package. Without deduplication, one line
- // ignore will be marked as matched, while the other one won't,
- // subsequently reporting a "this linter directive didn't match
- // anything" error.
- ignores := map[token.Position]Ignore{}
- for _, pkg := range pkgs {
- for _, ig := range pkg.ignores {
- if lig, ok := ig.(*LineIgnore); ok {
- ig = ignores[lig.Pos]
- if ig == nil {
- ignores[lig.Pos] = lig
- ig = lig
- }
- }
- for i := range pkg.problems {
- p := &pkg.problems[i]
- if ig.Match(*p) {
- p.Severity = Ignored
- }
- }
- }
-
- if pkg.cfg == nil {
- // The package failed to load, otherwise we would have a
- // valid config. Pass through all errors.
- problems = append(problems, pkg.problems...)
- } else {
- for _, p := range pkg.problems {
- allowedChecks := FilterChecks(allowedAnalyzers, pkg.cfg.Merge(l.Config).Checks)
- allowedChecks["compile"] = true
- if allowedChecks[p.Check] {
- problems = append(problems, p)
- }
- }
- }
-
- for _, ig := range pkg.ignores {
- ig, ok := ig.(*LineIgnore)
- if !ok {
- continue
- }
- ig = ignores[ig.Pos].(*LineIgnore)
- if ig.Matched {
- continue
- }
-
- couldveMatched := false
- allowedChecks := FilterChecks(allowedAnalyzers, pkg.cfg.Merge(l.Config).Checks)
- for _, c := range ig.Checks {
- if !allowedChecks[c] {
- continue
- }
- couldveMatched = true
- break
- }
-
- if !couldveMatched {
- // The ignored checks were disabled for the containing package.
- // Don't flag the ignore for not having matched.
- continue
- }
- p := Problem{
- Pos: ig.Pos,
- Message: "this linter directive didn't match anything; should it be removed?",
- Check: "",
- }
- problems = append(problems, p)
- }
- }
-
- if len(problems) == 0 {
- return nil, nil
- }
-
- sort.Slice(problems, func(i, j int) bool {
- pi := problems[i].Pos
- pj := problems[j].Pos
-
- if pi.Filename != pj.Filename {
- return pi.Filename < pj.Filename
- }
- if pi.Line != pj.Line {
- return pi.Line < pj.Line
- }
- if pi.Column != pj.Column {
- return pi.Column < pj.Column
- }
-
- return problems[i].Message < problems[j].Message
- })
-
- var out []Problem
- out = append(out, problems[0])
- for i, p := range problems[1:] {
- // We may encounter duplicate problems because one file
- // can be part of many packages.
- if !problems[i].Equal(p) {
- out = append(out, p)
- }
- }
- return out, nil
-}
-
-func FilterChecks(allChecks []*analysis.Analyzer, checks []string) map[string]bool {
- // OPT(dh): this entire computation could be cached per package
- allowedChecks := map[string]bool{}
-
- for _, check := range checks {
- b := true
- if len(check) > 1 && check[0] == '-' {
- b = false
- check = check[1:]
- }
- if check == "*" || check == "all" {
- // Match all
- for _, c := range allChecks {
- allowedChecks[c.Name] = b
- }
- } else if strings.HasSuffix(check, "*") {
- // Glob
- prefix := check[:len(check)-1]
- isCat := strings.IndexFunc(prefix, func(r rune) bool { return unicode.IsNumber(r) }) == -1
-
- for _, c := range allChecks {
- idx := strings.IndexFunc(c.Name, func(r rune) bool { return unicode.IsNumber(r) })
- if isCat {
- // Glob is S*, which should match S1000 but not SA1000
- cat := c.Name[:idx]
- if prefix == cat {
- allowedChecks[c.Name] = b
- }
- } else {
- // Glob is S1*
- if strings.HasPrefix(c.Name, prefix) {
- allowedChecks[c.Name] = b
- }
- }
- }
- } else {
- // Literal check name
- allowedChecks[check] = b
- }
- }
- return allowedChecks
-}
-
-func DisplayPosition(fset *token.FileSet, p token.Pos) token.Position {
- if p == token.NoPos {
- return token.Position{}
- }
-
- // Only use the adjusted position if it points to another Go file.
- // This means we'll point to the original file for cgo files, but
- // we won't point to a YACC grammar file.
- pos := fset.PositionFor(p, false)
- adjPos := fset.PositionFor(p, true)
-
- if filepath.Ext(adjPos.Filename) == ".go" {
- return adjPos
- }
- return pos
-}
-
-var bufferPool = &sync.Pool{
- New: func() interface{} {
- buf := bytes.NewBuffer(nil)
- buf.Grow(64)
- return buf
- },
-}
-
-func FuncName(f *types.Func) string {
- buf := bufferPool.Get().(*bytes.Buffer)
- buf.Reset()
- if f.Type() != nil {
- sig := f.Type().(*types.Signature)
- if recv := sig.Recv(); recv != nil {
- buf.WriteByte('(')
- if _, ok := recv.Type().(*types.Interface); ok {
- // gcimporter creates abstract methods of
- // named interfaces using the interface type
- // (not the named type) as the receiver.
- // Don't print it in full.
- buf.WriteString("interface")
- } else {
- types.WriteType(buf, recv.Type(), nil)
- }
- buf.WriteByte(')')
- buf.WriteByte('.')
- } else if f.Pkg() != nil {
- writePackage(buf, f.Pkg())
- }
- }
- buf.WriteString(f.Name())
- s := buf.String()
- bufferPool.Put(buf)
- return s
-}
-
-func writePackage(buf *bytes.Buffer, pkg *types.Package) {
- if pkg == nil {
- return
- }
- s := pkg.Path()
- if s != "" {
- buf.WriteString(s)
- buf.WriteByte('.')
- }
-}
projects / dotfiles / .git / blobdiff