open-nomad/vendor/honnef.co/go/tools/lint/lint.go

// 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('.')
	}
}