Update and fix staticcheck

vendor/honnef.co/go/tools/ir/irutil/load.go

@@ -0,0 +1,183 @@
+// Copyright 2015 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 irutil
+
+// This file defines utility functions for constructing programs in IR form.
+
+import (
+	"go/ast"
+	"go/token"
+	"go/types"
+
+	"golang.org/x/tools/go/loader"
+	"golang.org/x/tools/go/packages"
+	"honnef.co/go/tools/ir"
+)
+
+type Options struct {
+	// Which function, if any, to print in HTML form
+	PrintFunc string
+}
+
+// Packages creates an IR program for a set of packages.
+//
+// The packages must have been loaded from source syntax using the
+// golang.org/x/tools/go/packages.Load function in LoadSyntax or
+// LoadAllSyntax mode.
+//
+// Packages creates an IR package for each well-typed package in the
+// initial list, plus all their dependencies. The resulting list of
+// packages corresponds to the list of initial packages, and may contain
+// a nil if IR code could not be constructed for the corresponding initial
+// package due to type errors.
+//
+// Code for bodies of functions is not built until Build is called on
+// the resulting Program. IR code is constructed only for the initial
+// packages with well-typed syntax trees.
+//
+// The mode parameter controls diagnostics and checking during IR construction.
+//
+func Packages(initial []*packages.Package, mode ir.BuilderMode, opts *Options) (*ir.Program, []*ir.Package) {
+	return doPackages(initial, mode, false, opts)
+}
+
+// AllPackages creates an IR program for a set of packages plus all
+// their dependencies.
+//
+// The packages must have been loaded from source syntax using the
+// golang.org/x/tools/go/packages.Load function in LoadAllSyntax mode.
+//
+// AllPackages creates an IR package for each well-typed package in the
+// initial list, plus all their dependencies. The resulting list of
+// packages corresponds to the list of initial packages, and may contain
+// a nil if IR code could not be constructed for the corresponding
+// initial package due to type errors.
+//
+// Code for bodies of functions is not built until Build is called on
+// the resulting Program. IR code is constructed for all packages with
+// well-typed syntax trees.
+//
+// The mode parameter controls diagnostics and checking during IR construction.
+//
+func AllPackages(initial []*packages.Package, mode ir.BuilderMode, opts *Options) (*ir.Program, []*ir.Package) {
+	return doPackages(initial, mode, true, opts)
+}
+
+func doPackages(initial []*packages.Package, mode ir.BuilderMode, deps bool, opts *Options) (*ir.Program, []*ir.Package) {
+
+	var fset *token.FileSet
+	if len(initial) > 0 {
+		fset = initial[0].Fset
+	}
+
+	prog := ir.NewProgram(fset, mode)
+	if opts != nil {
+		prog.PrintFunc = opts.PrintFunc
+	}
+
+	isInitial := make(map[*packages.Package]bool, len(initial))
+	for _, p := range initial {
+		isInitial[p] = true
+	}
+
+	irmap := make(map[*packages.Package]*ir.Package)
+	packages.Visit(initial, nil, func(p *packages.Package) {
+		if p.Types != nil && !p.IllTyped {
+			var files []*ast.File
+			if deps || isInitial[p] {
+				files = p.Syntax
+			}
+			irmap[p] = prog.CreatePackage(p.Types, files, p.TypesInfo, true)
+		}
+	})
+
+	var irpkgs []*ir.Package
+	for _, p := range initial {
+		irpkgs = append(irpkgs, irmap[p]) // may be nil
+	}
+	return prog, irpkgs
+}
+
+// CreateProgram returns a new program in IR form, given a program
+// loaded from source.  An IR package is created for each transitively
+// error-free package of lprog.
+//
+// Code for bodies of functions is not built until Build is called
+// on the result.
+//
+// The mode parameter controls diagnostics and checking during IR construction.
+//
+// Deprecated: use golang.org/x/tools/go/packages and the Packages
+// function instead; see ir.ExampleLoadPackages.
+//
+func CreateProgram(lprog *loader.Program, mode ir.BuilderMode) *ir.Program {
+	prog := ir.NewProgram(lprog.Fset, mode)
+
+	for _, info := range lprog.AllPackages {
+		if info.TransitivelyErrorFree {
+			prog.CreatePackage(info.Pkg, info.Files, &info.Info, info.Importable)
+		}
+	}
+
+	return prog
+}
+
+// BuildPackage builds an IR program with IR for a single package.
+//
+// It populates pkg by type-checking the specified file ASTs.  All
+// dependencies are loaded using the importer specified by tc, which
+// typically loads compiler export data; IR code cannot be built for
+// those packages.  BuildPackage then constructs an ir.Program with all
+// dependency packages created, and builds and returns the IR package
+// corresponding to pkg.
+//
+// The caller must have set pkg.Path() to the import path.
+//
+// The operation fails if there were any type-checking or import errors.
+//
+// See ../ir/example_test.go for an example.
+//
+func BuildPackage(tc *types.Config, fset *token.FileSet, pkg *types.Package, files []*ast.File, mode ir.BuilderMode) (*ir.Package, *types.Info, error) {
+	if fset == nil {
+		panic("no token.FileSet")
+	}
+	if pkg.Path() == "" {
+		panic("package has no import path")
+	}
+
+	info := &types.Info{
+		Types:      make(map[ast.Expr]types.TypeAndValue),
+		Defs:       make(map[*ast.Ident]types.Object),
+		Uses:       make(map[*ast.Ident]types.Object),
+		Implicits:  make(map[ast.Node]types.Object),
+		Scopes:     make(map[ast.Node]*types.Scope),
+		Selections: make(map[*ast.SelectorExpr]*types.Selection),
+	}
+	if err := types.NewChecker(tc, fset, pkg, info).Files(files); err != nil {
+		return nil, nil, err
+	}
+
+	prog := ir.NewProgram(fset, mode)
+
+	// Create IR packages for all imports.
+	// Order is not significant.
+	created := make(map[*types.Package]bool)
+	var createAll func(pkgs []*types.Package)
+	createAll = func(pkgs []*types.Package) {
+		for _, p := range pkgs {
+			if !created[p] {
+				created[p] = true
+				prog.CreatePackage(p, nil, nil, true)
+				createAll(p.Imports())
+			}
+		}
+	}
+	createAll(pkg.Imports())
+
+	// Create and build the primary package.
+	irpkg := prog.CreatePackage(pkg, files, info, false)
+	irpkg.Build()
+	return irpkg, info, nil
+}

vendor/honnef.co/go/tools/ir/irutil/switch.go

@@ -0,0 +1,264 @@
+// Copyright 2013 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 irutil
+
+// This file implements discovery of switch and type-switch constructs
+// from low-level control flow.
+//
+// Many techniques exist for compiling a high-level switch with
+// constant cases to efficient machine code.  The optimal choice will
+// depend on the data type, the specific case values, the code in the
+// body of each case, and the hardware.
+// Some examples:
+// - a lookup table (for a switch that maps constants to constants)
+// - a computed goto
+// - a binary tree
+// - a perfect hash
+// - a two-level switch (to partition constant strings by their first byte).
+
+import (
+	"bytes"
+	"fmt"
+	"go/token"
+	"go/types"
+
+	"honnef.co/go/tools/ir"
+)
+
+// A ConstCase represents a single constant comparison.
+// It is part of a Switch.
+type ConstCase struct {
+	Block *ir.BasicBlock // block performing the comparison
+	Body  *ir.BasicBlock // body of the case
+	Value *ir.Const      // case comparand
+}
+
+// A TypeCase represents a single type assertion.
+// It is part of a Switch.
+type TypeCase struct {
+	Block   *ir.BasicBlock // block performing the type assert
+	Body    *ir.BasicBlock // body of the case
+	Type    types.Type     // case type
+	Binding ir.Value       // value bound by this case
+}
+
+// A Switch is a logical high-level control flow operation
+// (a multiway branch) discovered by analysis of a CFG containing
+// only if/else chains.  It is not part of the ir.Instruction set.
+//
+// One of ConstCases and TypeCases has length >= 2;
+// the other is nil.
+//
+// In a value switch, the list of cases may contain duplicate constants.
+// A type switch may contain duplicate types, or types assignable
+// to an interface type also in the list.
+// TODO(adonovan): eliminate such duplicates.
+//
+type Switch struct {
+	Start      *ir.BasicBlock // block containing start of if/else chain
+	X          ir.Value       // the switch operand
+	ConstCases []ConstCase    // ordered list of constant comparisons
+	TypeCases  []TypeCase     // ordered list of type assertions
+	Default    *ir.BasicBlock // successor if all comparisons fail
+}
+
+func (sw *Switch) String() string {
+	// We represent each block by the String() of its
+	// first Instruction, e.g. "print(42:int)".
+	var buf bytes.Buffer
+	if sw.ConstCases != nil {
+		fmt.Fprintf(&buf, "switch %s {\n", sw.X.Name())
+		for _, c := range sw.ConstCases {
+			fmt.Fprintf(&buf, "case %s: %s\n", c.Value.Name(), c.Body.Instrs[0])
+		}
+	} else {
+		fmt.Fprintf(&buf, "switch %s.(type) {\n", sw.X.Name())
+		for _, c := range sw.TypeCases {
+			fmt.Fprintf(&buf, "case %s %s: %s\n",
+				c.Binding.Name(), c.Type, c.Body.Instrs[0])
+		}
+	}
+	if sw.Default != nil {
+		fmt.Fprintf(&buf, "default: %s\n", sw.Default.Instrs[0])
+	}
+	fmt.Fprintf(&buf, "}")
+	return buf.String()
+}
+
+// Switches examines the control-flow graph of fn and returns the
+// set of inferred value and type switches.  A value switch tests an
+// ir.Value for equality against two or more compile-time constant
+// values.  Switches involving link-time constants (addresses) are
+// ignored.  A type switch type-asserts an ir.Value against two or
+// more types.
+//
+// The switches are returned in dominance order.
+//
+// The resulting switches do not necessarily correspond to uses of the
+// 'switch' keyword in the source: for example, a single source-level
+// switch statement with non-constant cases may result in zero, one or
+// many Switches, one per plural sequence of constant cases.
+// Switches may even be inferred from if/else- or goto-based control flow.
+// (In general, the control flow constructs of the source program
+// cannot be faithfully reproduced from the IR.)
+//
+func Switches(fn *ir.Function) []Switch {
+	// Traverse the CFG in dominance order, so we don't
+	// enter an if/else-chain in the middle.
+	var switches []Switch
+	seen := make(map[*ir.BasicBlock]bool) // TODO(adonovan): opt: use ir.blockSet
+	for _, b := range fn.DomPreorder() {
+		if x, k := isComparisonBlock(b); x != nil {
+			// Block b starts a switch.
+			sw := Switch{Start: b, X: x}
+			valueSwitch(&sw, k, seen)
+			if len(sw.ConstCases) > 1 {
+				switches = append(switches, sw)
+			}
+		}
+
+		if y, x, T := isTypeAssertBlock(b); y != nil {
+			// Block b starts a type switch.
+			sw := Switch{Start: b, X: x}
+			typeSwitch(&sw, y, T, seen)
+			if len(sw.TypeCases) > 1 {
+				switches = append(switches, sw)
+			}
+		}
+	}
+	return switches
+}
+
+func isSameX(x1 ir.Value, x2 ir.Value) bool {
+	if x1 == x2 {
+		return true
+	}
+	if x2, ok := x2.(*ir.Sigma); ok {
+		return isSameX(x1, x2.X)
+	}
+	return false
+}
+
+func valueSwitch(sw *Switch, k *ir.Const, seen map[*ir.BasicBlock]bool) {
+	b := sw.Start
+	x := sw.X
+	for isSameX(sw.X, x) {
+		if seen[b] {
+			break
+		}
+		seen[b] = true
+
+		sw.ConstCases = append(sw.ConstCases, ConstCase{
+			Block: b,
+			Body:  b.Succs[0],
+			Value: k,
+		})
+		b = b.Succs[1]
+		n := 0
+		for _, instr := range b.Instrs {
+			switch instr.(type) {
+			case *ir.If, *ir.BinOp:
+				n++
+			case *ir.Sigma, *ir.Phi, *ir.DebugRef:
+			default:
+				n += 1000
+			}
+		}
+		if n != 2 {
+			// Block b contains not just 'if x == k' and σ/ϕ nodes,
+			// so it may have side effects that
+			// make it unsafe to elide.
+			break
+		}
+		if len(b.Preds) != 1 {
+			// Block b has multiple predecessors,
+			// so it cannot be treated as a case.
+			break
+		}
+		x, k = isComparisonBlock(b)
+	}
+	sw.Default = b
+}
+
+func typeSwitch(sw *Switch, y ir.Value, T types.Type, seen map[*ir.BasicBlock]bool) {
+	b := sw.Start
+	x := sw.X
+	for isSameX(sw.X, x) {
+		if seen[b] {
+			break
+		}
+		seen[b] = true
+
+		sw.TypeCases = append(sw.TypeCases, TypeCase{
+			Block:   b,
+			Body:    b.Succs[0],
+			Type:    T,
+			Binding: y,
+		})
+		b = b.Succs[1]
+		n := 0
+		for _, instr := range b.Instrs {
+			switch instr.(type) {
+			case *ir.TypeAssert, *ir.Extract, *ir.If:
+				n++
+			case *ir.Sigma, *ir.Phi:
+			default:
+				n += 1000
+			}
+		}
+		if n != 4 {
+			// Block b contains not just
+			//  {TypeAssert; Extract #0; Extract #1; If}
+			// so it may have side effects that
+			// make it unsafe to elide.
+			break
+		}
+		if len(b.Preds) != 1 {
+			// Block b has multiple predecessors,
+			// so it cannot be treated as a case.
+			break
+		}
+		y, x, T = isTypeAssertBlock(b)
+	}
+	sw.Default = b
+}
+
+// isComparisonBlock returns the operands (v, k) if a block ends with
+// a comparison v==k, where k is a compile-time constant.
+//
+func isComparisonBlock(b *ir.BasicBlock) (v ir.Value, k *ir.Const) {
+	if n := len(b.Instrs); n >= 2 {
+		if i, ok := b.Instrs[n-1].(*ir.If); ok {
+			if binop, ok := i.Cond.(*ir.BinOp); ok && binop.Block() == b && binop.Op == token.EQL {
+				if k, ok := binop.Y.(*ir.Const); ok {
+					return binop.X, k
+				}
+				if k, ok := binop.X.(*ir.Const); ok {
+					return binop.Y, k
+				}
+			}
+		}
+	}
+	return
+}
+
+// isTypeAssertBlock returns the operands (y, x, T) if a block ends with
+// a type assertion "if y, ok := x.(T); ok {".
+//
+func isTypeAssertBlock(b *ir.BasicBlock) (y, x ir.Value, T types.Type) {
+	if n := len(b.Instrs); n >= 4 {
+		if i, ok := b.Instrs[n-1].(*ir.If); ok {
+			if ext1, ok := i.Cond.(*ir.Extract); ok && ext1.Block() == b && ext1.Index == 1 {
+				if ta, ok := ext1.Tuple.(*ir.TypeAssert); ok && ta.Block() == b {
+					// hack: relies upon instruction ordering.
+					if ext0, ok := b.Instrs[n-3].(*ir.Extract); ok {
+						return ext0, ta.X, ta.AssertedType
+					}
+				}
+			}
+		}
+	}
+	return
+}

vendor/honnef.co/go/tools/ir/irutil/util.go

@@ -0,0 +1,70 @@
+package irutil
+
+import (
+	"honnef.co/go/tools/ir"
+)
+
+func Reachable(from, to *ir.BasicBlock) bool {
+	if from == to {
+		return true
+	}
+	if from.Dominates(to) {
+		return true
+	}
+
+	found := false
+	Walk(from, func(b *ir.BasicBlock) bool {
+		if b == to {
+			found = true
+			return false
+		}
+		return true
+	})
+	return found
+}
+
+func Walk(b *ir.BasicBlock, fn func(*ir.BasicBlock) bool) {
+	seen := map[*ir.BasicBlock]bool{}
+	wl := []*ir.BasicBlock{b}
+	for len(wl) > 0 {
+		b := wl[len(wl)-1]
+		wl = wl[:len(wl)-1]
+		if seen[b] {
+			continue
+		}
+		seen[b] = true
+		if !fn(b) {
+			continue
+		}
+		wl = append(wl, b.Succs...)
+	}
+}
+
+func Vararg(x *ir.Slice) ([]ir.Value, bool) {
+	var out []ir.Value
+	slice, ok := x.X.(*ir.Alloc)
+	if !ok {
+		return nil, false
+	}
+	for _, ref := range *slice.Referrers() {
+		if ref == x {
+			continue
+		}
+		if ref.Block() != x.Block() {
+			return nil, false
+		}
+		idx, ok := ref.(*ir.IndexAddr)
+		if !ok {
+			return nil, false
+		}
+		if len(*idx.Referrers()) != 1 {
+			return nil, false
+		}
+		store, ok := (*idx.Referrers())[0].(*ir.Store)
+		if !ok {
+			return nil, false
+		}
+		out = append(out, store.Val)
+	}
+	return out, true
+}

vendor/honnef.co/go/tools/ir/irutil/visit.go

@@ -0,0 +1,79 @@
+// Copyright 2013 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 irutil // import "honnef.co/go/tools/ir/irutil"
+
+import "honnef.co/go/tools/ir"
+
+// This file defines utilities for visiting the IR of
+// a Program.
+//
+// TODO(adonovan): test coverage.
+
+// AllFunctions finds and returns the set of functions potentially
+// needed by program prog, as determined by a simple linker-style
+// reachability algorithm starting from the members and method-sets of
+// each package.  The result may include anonymous functions and
+// synthetic wrappers.
+//
+// Precondition: all packages are built.
+//
+func AllFunctions(prog *ir.Program) map[*ir.Function]bool {
+	visit := visitor{
+		prog: prog,
+		seen: make(map[*ir.Function]bool),
+	}
+	visit.program()
+	return visit.seen
+}
+
+type visitor struct {
+	prog *ir.Program
+	seen map[*ir.Function]bool
+}
+
+func (visit *visitor) program() {
+	for _, pkg := range visit.prog.AllPackages() {
+		for _, mem := range pkg.Members {
+			if fn, ok := mem.(*ir.Function); ok {
+				visit.function(fn)
+			}
+		}
+	}
+	for _, T := range visit.prog.RuntimeTypes() {
+		mset := visit.prog.MethodSets.MethodSet(T)
+		for i, n := 0, mset.Len(); i < n; i++ {
+			visit.function(visit.prog.MethodValue(mset.At(i)))
+		}
+	}
+}
+
+func (visit *visitor) function(fn *ir.Function) {
+	if !visit.seen[fn] {
+		visit.seen[fn] = true
+		var buf [10]*ir.Value // avoid alloc in common case
+		for _, b := range fn.Blocks {
+			for _, instr := range b.Instrs {
+				for _, op := range instr.Operands(buf[:0]) {
+					if fn, ok := (*op).(*ir.Function); ok {
+						visit.function(fn)
+					}
+				}
+			}
+		}
+	}
+}
+
+// MainPackages returns the subset of the specified packages
+// named "main" that define a main function.
+// The result may include synthetic "testmain" packages.
+func MainPackages(pkgs []*ir.Package) []*ir.Package {
+	var mains []*ir.Package
+	for _, pkg := range pkgs {
+		if pkg.Pkg.Name() == "main" && pkg.Func("main") != nil {
+			mains = append(mains, pkg)
+		}
+	}
+	return mains
+}