Update and fix staticcheck

vendor/honnef.co/go/tools/functions/loops.go

@@ -1,10 +1,10 @@
 package functions
 
-import "honnef.co/go/tools/ssa"
+import "honnef.co/go/tools/ir"
 
-type Loop struct{ ssa.BlockSet }
+type Loop struct{ *ir.BlockSet }
 
-func FindLoops(fn *ssa.Function) []Loop {
+func FindLoops(fn *ir.Function) []Loop {
 	if fn.Blocks == nil {
 		return nil
 	}
@@ -18,12 +18,12 @@ func FindLoops(fn *ssa.Function) []Loop {
 			// n is a back-edge to h
 			// h is the loop header
 			if n == h {
-				set := Loop{}
+				set := Loop{ir.NewBlockSet(len(fn.Blocks))}
 				set.Add(n)
 				sets = append(sets, set)
 				continue
 			}
-			set := Loop{}
+			set := Loop{ir.NewBlockSet(len(fn.Blocks))}
 			set.Add(h)
 			set.Add(n)
 			for _, b := range allPredsBut(n, h, nil) {
@@ -35,7 +35,7 @@ func FindLoops(fn *ssa.Function) []Loop {
 	return sets
 }
 
-func allPredsBut(b, but *ssa.BasicBlock, list []*ssa.BasicBlock) []*ssa.BasicBlock {
+func allPredsBut(b, but *ir.BasicBlock, list []*ir.BasicBlock) []*ir.BasicBlock {
 outer:
 	for _, pred := range b.Preds {
 		if pred == but {

vendor/honnef.co/go/tools/functions/pure.go

@@ -1,46 +0,0 @@
-package functions
-
-import (
-	"honnef.co/go/tools/ssa"
-)
-
-func filterDebug(instr []ssa.Instruction) []ssa.Instruction {
-	var out []ssa.Instruction
-	for _, ins := range instr {
-		if _, ok := ins.(*ssa.DebugRef); !ok {
-			out = append(out, ins)
-		}
-	}
-	return out
-}
-
-// IsStub reports whether a function is a stub. A function is
-// considered a stub if it has no instructions or exactly one
-// instruction, which must be either returning only constant values or
-// a panic.
-func IsStub(fn *ssa.Function) bool {
-	if len(fn.Blocks) == 0 {
-		return true
-	}
-	if len(fn.Blocks) > 1 {
-		return false
-	}
-	instrs := filterDebug(fn.Blocks[0].Instrs)
-	if len(instrs) != 1 {
-		return false
-	}
-
-	switch instrs[0].(type) {
-	case *ssa.Return:
-		// Since this is the only instruction, the return value must
-		// be a constant. We consider all constants as stubs, not just
-		// the zero value. This does not, unfortunately, cover zero
-		// initialised structs, as these cause additional
-		// instructions.
-		return true
-	case *ssa.Panic:
-		return true
-	default:
-		return false
-	}
-}

vendor/honnef.co/go/tools/functions/stub.go

@@ -0,0 +1,32 @@
+package functions
+
+import (
+	"honnef.co/go/tools/ir"
+)
+
+// IsStub reports whether a function is a stub. A function is
+// considered a stub if it has no instructions or if all it does is
+// return a constant value.
+func IsStub(fn *ir.Function) bool {
+	for _, b := range fn.Blocks {
+		for _, instr := range b.Instrs {
+			switch instr.(type) {
+			case *ir.Const:
+				// const naturally has no side-effects
+			case *ir.Panic:
+				// panic is a stub if it only uses constants
+			case *ir.Return:
+				// return is a stub if it only uses constants
+			case *ir.DebugRef:
+			case *ir.Jump:
+				// if there are no disallowed instructions, then we're
+				// only jumping to the exit block (or possibly
+				// somewhere else that's stubby?)
+			default:
+				// all other instructions are assumed to do actual work
+				return false
+			}
+		}
+	}
+	return true
+}

vendor/honnef.co/go/tools/functions/terminates.go

@@ -1,11 +1,15 @@
 package functions
 
-import "honnef.co/go/tools/ssa"
+import (
+	"go/types"
+
+	"honnef.co/go/tools/ir"
+)
 
 // Terminates reports whether fn is supposed to return, that is if it
 // has at least one theoretic path that returns from the function.
 // Explicit panics do not count as terminating.
-func Terminates(fn *ssa.Function) bool {
+func Terminates(fn *ir.Function) bool {
 	if fn.Blocks == nil {
 		// assuming that a function terminates is the conservative
 		// choice
@@ -13,11 +17,53 @@ func Terminates(fn *ssa.Function) bool {
 	}
 
 	for _, block := range fn.Blocks {
-		if len(block.Instrs) == 0 {
-			continue
-		}
-		if _, ok := block.Instrs[len(block.Instrs)-1].(*ssa.Return); ok {
-			return true
+		if _, ok := block.Control().(*ir.Return); ok {
+			if len(block.Preds) == 0 {
+				return true
+			}
+			for _, pred := range block.Preds {
+				switch ctrl := pred.Control().(type) {
+				case *ir.Panic:
+					// explicit panics do not count as terminating
+				case *ir.If:
+					// Check if we got here by receiving from a closed
+					// time.Tick channel – this cannot happen at
+					// runtime and thus doesn't constitute termination
+					iff := ctrl
+					if !ok {
+						return true
+					}
+					ex, ok := iff.Cond.(*ir.Extract)
+					if !ok {
+						return true
+					}
+					if ex.Index != 1 {
+						return true
+					}
+					recv, ok := ex.Tuple.(*ir.Recv)
+					if !ok {
+						return true
+					}
+					call, ok := recv.Chan.(*ir.Call)
+					if !ok {
+						return true
+					}
+					fn, ok := call.Common().Value.(*ir.Function)
+					if !ok {
+						return true
+					}
+					fn2, ok := fn.Object().(*types.Func)
+					if !ok {
+						return true
+					}
+					if fn2.FullName() != "time.Tick" {
+						return true
+					}
+				default:
+					// we've reached the exit block
+					return true
+				}
+			}
 		}
 	}
 	return false