Use module's Go version as the default version

In the past, the '-go' flag defaulted to the version of Go that
Staticcheck was built with. This wasn't a great default as it was
usually too aggressive, suggesting new language features right away,
despite most people wanting to support the last N versions of Go.

Go modules themselves specify a Go version to support. This version
restricts the set of Go language features that can be used in a
module. This maps quite well to our '-go' flag, which similarly
suppresses suggestions that would depend on a newer version of Go.

The mapping isn't perfect, in particular because we conflate language
features and the version of the standard library (a Go module
targeting Go 1.0 can't use newer language features, but it can still
use parts of the stdlib that were introduced in later versions), but
it is better than our previous default.

The user is still able to override the default if needed.

Due to the design of flags in go/analysis, we can't easily specify
different versions for different packages. In theory, this should not
be a problem, as the Go build system only allows operating on one
module at a time. We may still see a mix of packages where some have a
module and others don't – this is because the synthetic "foo.test"
packages are not part of the module. We can skip those. Should we ever
see more than one module, we fall back to the old default and emit a
warning.

If the user isn't operating in module mode, we fall back to the old
default.

Closes gh-853

Author: dominikh

analysis/lint/lint.go

@@ -2,7 +2,6 @@
 package lint
 
 import (
-	"errors"
 	"flag"
 	"fmt"
 	"go/ast"
@@ -66,13 +65,13 @@ func (v *VersionFlag) String() string {
 
 func (v *VersionFlag) Set(s string) error {
 	if len(s) < 3 {
-		return errors.New("invalid Go version")
+		return fmt.Errorf("invalid Go version: %q", s)
 	}
 	if s[0] != '1' {
-		return errors.New("invalid Go version")
+		return fmt.Errorf("invalid Go version: %q", s)
 	}
 	if s[1] != '.' {
-		return errors.New("invalid Go version")
+		return fmt.Errorf("invalid Go version: %q", s)
 	}
 	i, err := strconv.Atoi(s[2:])
 	*v = VersionFlag(i)

go/loader/loader.go

@@ -37,6 +37,7 @@ type PackageSpec struct {
 	Imports         map[string]*PackageSpec
 	TypesSizes      types.Sizes
 	Hash            cache.ActionID
+	Module          *packages.Module
 
 	Config config.Config
 }
@@ -74,7 +75,8 @@ func Graph(cfg *packages.Config, patterns ...string) ([]*PackageSpec, error) {
 		packages.NeedExportsFile |
 		packages.NeedFiles |
 		packages.NeedCompiledGoFiles |
-		packages.NeedTypesSizes
+		packages.NeedTypesSizes |
+		packages.NeedModule
 	pkgs, err := packages.Load(&dcfg, patterns...)
 	if err != nil {
 		return nil, err
@@ -93,6 +95,7 @@ func Graph(cfg *packages.Config, patterns ...string) ([]*PackageSpec, error) {
 			ExportFile:      pkg.ExportFile,
 			Imports:         map[string]*PackageSpec{},
 			TypesSizes:      pkg.TypesSizes,
+			Module:          pkg.Module,
 		}
 		for path, imp := range pkg.Imports {
 			spec.Imports[path] = m[imp]

lintcmd/cmd.go

@@ -268,21 +268,24 @@ func filterIgnored(problems []problem, res runner.ResultData, allowedAnalyzers m
 	return append(problems, moreProblems...), nil
 }
 
+func defaultGoVersion() string {
+	tags := build.Default.ReleaseTags
+	v := tags[len(tags)-1][2:]
+	return v
+}
+
 func newLinter(cfg config.Config) (*linter, error) {
 	r, err := runner.New(cfg)
 	if err != nil {
 		return nil, err
 	}
+	r.FallbackGoVersion = defaultGoVersion()
 	return &linter{
 		Config: cfg,
 		Runner: r,
 	}, nil
 }
 
-func (l *linter) SetGoVersion(n int) {
-	l.Runner.GoVersion = n
-}
-
 func (l *linter) Lint(cfg *packages.Config, patterns []string) (problems []problem, warnings []string, err error) {
 	results, err := l.Runner.Run(cfg, l.Checkers, patterns)
 	if err != nil {
@@ -528,7 +531,7 @@ func FlagSet(name string) *flag.FlagSet {
 		panic(fmt.Sprintf("internal error: %s", err))
 	}
 
-	flags.Var(version, "go", "Target Go `version` in the format '1.x'")
+	flags.String("go", "module", "Target Go `version` in the format '1.x', or the literal 'module' to use the module's Go version")
 	return flags
 }
 
@@ -544,7 +547,7 @@ func findCheck(cs []*analysis.Analyzer, check string) (*analysis.Analyzer, bool)
 func ProcessFlagSet(cs []*analysis.Analyzer, fs *flag.FlagSet) {
 	tags := fs.Lookup("tags").Value.(flag.Getter).Get().(string)
 	tests := fs.Lookup("tests").Value.(flag.Getter).Get().(bool)
-	goVersion := fs.Lookup("go").Value.(flag.Getter).Get().(int)
+	goVersion := fs.Lookup("go").Value.(flag.Getter).Get().(string)
 	theFormatter := fs.Lookup("f").Value.(flag.Getter).Get().(string)
 	printVersion := fs.Lookup("version").Value.(flag.Getter).Get().(bool)
 	showIgnored := fs.Lookup("show-ignored").Value.(flag.Getter).Get().(bool)
@@ -721,7 +724,7 @@ type options struct {
 
 	Tags                     string
 	LintTests                bool
-	GoVersion                int
+	GoVersion                string
 	PrintAnalyzerMeasurement func(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration)
 }
 
@@ -761,7 +764,7 @@ func doLint(cs []*analysis.Analyzer, paths []string, opt *options) ([]problem, [
 		return nil, nil, err
 	}
 	l.Checkers = cs
-	l.SetGoVersion(opt.GoVersion)
+	l.Runner.GoVersion = opt.GoVersion
 	l.Runner.Stats.PrintAnalyzerMeasurement = opt.PrintAnalyzerMeasurement
 
 	cfg := &packages.Config{}

lintcmd/runner/runner.go

@@ -335,7 +335,13 @@ func (act *analyzerAction) String() string {
 // A Runner executes analyzers on packages.
 type Runner struct {
 	Stats     Stats
-	GoVersion int
+	GoVersion string
+	// if GoVersion == "module", and we couldn't determine the
+	// module's Go version, use this as the fallback
+	FallbackGoVersion string
+
+	// GoVersion might be "module"; actualGoVersion contains the resolved version
+	actualGoVersion string
 
 	// Config that gets merged with per-package configs
 	cfg       config.Config
@@ -499,7 +505,7 @@ func (r *subrunner) do(act action) error {
 	fmt.Fprintf(h, "cfg %#v\n", hashCfg)
 	fmt.Fprintf(h, "pkg %x\n", a.Package.Hash)
 	fmt.Fprintf(h, "analyzers %s\n", r.analyzerNames)
-	fmt.Fprintf(h, "go 1.%d\n", r.GoVersion)
+	fmt.Fprintf(h, "go %s\n", r.actualGoVersion)
 
 	// OPT(dh): do we actually need to hash vetx? can we not assume
 	// that for identical inputs, staticcheck will produce identical
@@ -1097,22 +1103,10 @@ func allAnalyzers(analyzers []*analysis.Analyzer) []*analysis.Analyzer {
 //
 // If cfg is nil, a default config will be used. Otherwise, cfg will
 // be used, with the exception of the Mode field.
-//
-// Run can be called multiple times on the same Runner and it is safe
-// for concurrent use. All runs will share the same semaphore.
 func (r *Runner) Run(cfg *packages.Config, analyzers []*analysis.Analyzer, patterns []string) ([]Result, error) {
 	analyzers = allAnalyzers(analyzers)
 	registerGobTypes(analyzers)
 
-	for _, a := range analyzers {
-		flag := a.Flags.Lookup("go")
-		if flag == nil {
-			continue
-		}
-		// OPT(dh): this is terrible
-		flag.Value.Set(fmt.Sprintf("1.%d", r.GoVersion))
-	}
-
 	r.Stats.setState(StateLoadPackageGraph)
 	lpkgs, err := loader.Graph(cfg, patterns...)
 	if err != nil {
@@ -1124,6 +1118,43 @@ func (r *Runner) Run(cfg *packages.Config, analyzers []*analysis.Analyzer, patte
 		return nil, nil
 	}
 
+	var goVersion string
+	if r.GoVersion == "module" {
+		for _, lpkg := range lpkgs {
+			if m := lpkg.Module; m != nil {
+				if goVersion == "" {
+					goVersion = m.GoVersion
+				} else if goVersion != m.GoVersion {
+					// Theoretically, we should only ever see a single Go
+					// module. At least that's currently (as of Go 1.15)
+					// true when using 'go list'.
+					fmt.Fprintln(os.Stderr, "warning: encountered multiple modules and could not deduce targeted Go version")
+					goVersion = ""
+					break
+				}
+			}
+		}
+	} else {
+		goVersion = r.GoVersion
+	}
+
+	if goVersion == "" {
+		if r.FallbackGoVersion == "" {
+			panic("could not determine Go version of module, and fallback version hasn't been set")
+		}
+		goVersion = r.FallbackGoVersion
+	}
+	r.actualGoVersion = goVersion
+	for _, a := range analyzers {
+		flag := a.Flags.Lookup("go")
+		if flag == nil {
+			continue
+		}
+		if err := flag.Value.Set(goVersion); err != nil {
+			return nil, err
+		}
+	}
+
 	r.Stats.setState(StateBuildActionGraph)
 	all := map[*loader.PackageSpec]*packageAction{}
 	root := &packageAction{}