Add analyzer tests

Author: dtcaciuc

errcheck/analyzer.go

@@ -64,10 +64,14 @@ func runAnalyzer(pass *analysis.Pass) (interface{}, error) {
 
 		ast.Walk(v, f)
 
+		// TODO have visitor report all facts and then sort out
+		// the ones we need to report based on flags. This can
+		// likely simplify the visitor code.
+
 		for _, err := range v.errors {
 			pass.Report(analysis.Diagnostic{
 				Pos:     token.Pos(int(f.Pos()) + err.Pos.Offset),
-				Message: fmt.Sprintf("unchecked error returned by %s", err.FuncName),
+				Message: "unchecked error",
 			})
 		}
 

errcheck/errcheck.go

@@ -512,6 +512,9 @@ func (v *visitor) isRecover(call *ast.CallExpr) bool {
 	return false
 }
 
+// TODO collect token.Pos and then convert them to UncheckedErrors
+// after visitor is done running. This will allow to integrate more cleanly
+// with analyzer so that we don't have to convert Position back to Pos.
 func (v *visitor) addErrorAtPosition(position token.Pos, call *ast.CallExpr) {
 	pos := v.fset.Position(position)
 	lines, ok := v.lines[pos.Filename]

errcheck/testdata/custom_exclude.txt

@@ -0,0 +1 @@
+(custom_exclude.ErrorMakerInterfaceWrapper).MakeNilError

errcheck/testdata/src/a/main.go

@@ -0,0 +1,155 @@
+package a
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"fmt"
+	"io/ioutil"
+	"math/rand"
+	mrand "math/rand"
+)
+
+func a() error {
+	fmt.Println("this function returns an error") // ok, excluded
+	return nil
+}
+
+func b() (int, error) {
+	fmt.Println("this function returns an int and an error") // ok, excluded
+	return 0, nil
+}
+
+func c() int {
+	fmt.Println("this function returns an int") // ok, excluded
+	return 7
+}
+
+func rec() {
+	defer func() {
+		recover()     // want "unchecked error"
+		_ = recover() // ok, assigned to blank
+	}()
+	defer recover() // want "unchecked error"
+}
+
+type MyError string
+
+func (e MyError) Error() string {
+	return string(e)
+}
+
+func customError() error {
+	return MyError("an error occurred")
+}
+
+func customConcreteError() MyError {
+	return MyError("an error occurred")
+}
+
+func customConcreteErrorTuple() (int, MyError) {
+	return 0, MyError("an error occurred")
+}
+
+type MyPointerError string
+
+func (e *MyPointerError) Error() string {
+	return string(*e)
+}
+
+func customPointerError() *MyPointerError {
+	e := MyPointerError("an error occurred")
+	return &e
+}
+
+func customPointerErrorTuple() (int, *MyPointerError) {
+	e := MyPointerError("an error occurred")
+	return 0, &e
+}
+
+type ErrorMakerInterface interface {
+	MakeNilError() error
+}
+type ErrorMakerInterfaceWrapper interface {
+	ErrorMakerInterface
+}
+
+func main() {
+	// Single error return
+	_ = a() // ok, assigned to blank
+	a()     // want "unchecked error"
+
+	// Return another value and an error
+	_, _ = b() // ok, assigned to blank
+	b()        // want "unchecked error"
+
+	// Return a custom error type
+	_ = customError() // ok, assigned to blank
+	customError()     // want "unchecked error"
+
+	// Return a custom concrete error type
+	_ = customConcreteError()         // ok, assigned to blank
+	customConcreteError()             // want "unchecked error"
+	_, _ = customConcreteErrorTuple() // ok, assigned to blank
+	customConcreteErrorTuple()        // want "unchecked error"
+
+	// Return a custom pointer error type
+	_ = customPointerError()         // ok, assigned to blank
+	customPointerError()             // want "unchecked error"
+	_, _ = customPointerErrorTuple() // ok, assigned to blank
+	customPointerErrorTuple()        // want "unchecked error"
+
+	// Method with a single error return
+	x := t{}
+	_ = x.a() // ok, assigned to blank
+	x.a()     // want "unchecked error"
+
+	// Method call on a struct member
+	y := u{x}
+	_ = y.t.a() // ok, assigned to blank
+	y.t.a()     // want "unchecked error"
+
+	m1 := map[string]func() error{"a": a}
+	_ = m1["a"]() // ok, assigned to blank
+	m1["a"]()     // want "unchecked error"
+
+	// Additional cases for assigning errors to blank identifier
+	z, _ := b()    // ok, assigned to blank
+	_, w := a(), 5 // ok, assigned to blank
+
+	// Assign non error to blank identifier
+	_ = c()
+
+	_ = z + w // Avoid complaints about unused variables
+
+	// Type assertions
+	var i interface{}
+	s1 := i.(string)    // ok, would fail with -assert
+	s1 = i.(string)     // ok, would fail with -assert
+	s2, _ := i.(string) // ok, would fail with -blank
+	s2, _ = i.(string)  // ok, would fail with -blank
+	s3, ok := i.(string)
+	s3, ok = i.(string)
+	switch s4 := i.(type) {
+	case string:
+		_ = s4
+	}
+	_, _, _, _ = s1, s2, s3, ok
+
+	// Goroutine
+	go a()    // want "unchecked error"
+	defer a() // want "unchecked error"
+
+	// IO errors excluded by default
+	b1 := bytes.Buffer{}
+	b2 := &bytes.Buffer{}
+	b1.Write(nil)
+	b2.Write(nil)
+	rand.Read(nil)
+	mrand.Read(nil)
+	sha256.New().Write([]byte{})
+
+	ioutil.ReadFile("main.go") // want "unchecked error"
+
+	var emiw ErrorMakerInterfaceWrapper
+	emiw.MakeNilError() // want "unchecked error"
+}

errcheck/testdata/src/a/t.go

@@ -0,0 +1,17 @@
+// This file exists so that we can check that multi-file packages work
+package a
+
+import "fmt"
+
+type t struct{}
+
+func (x t) a() error {
+	fmt.Println("this method returns an error") // EXCLUDED
+//line myfile.txt:100
+	fmt.Println("this method also returns an error") // EXCLUDED
+	return nil
+}
+
+type u struct {
+	t t
+}

errcheck/testdata/src/assert/main.go

@@ -0,0 +1,6 @@
+package assert
+
+func main() {
+	var i interface{}
+	_ = i.(string) // want "unchecked error"
+}

errcheck/testdata/src/blank/main.go

@@ -0,0 +1,9 @@
+package blank
+
+func a() error {
+	return nil
+}
+
+func main() {
+	_ = a() // want "unchecked error"
+}

errcheck/testdata/src/custom_exclude/main.go

@@ -0,0 +1,14 @@
+package custom_excludes
+
+// Test custom excludes
+type ErrorMakerInterface interface {
+	MakeNilError() error
+}
+type ErrorMakerInterfaceWrapper interface {
+	ErrorMakerInterface
+}
+
+func main() {
+	var emiw ErrorMakerInterfaceWrapper
+	emiw.MakeNilError() // ok, custom exclude
+}