pikeman 0.0.1

data/testdata/5_test.go

@@ -0,0 +1,17 @@
+// This file ends in _test.go, so we should not warn about doc comments.
+// OK
+
+package pkg
+
+import "testing"
+
+type H int
+
+func TestSomething(t *testing.T) {
+}
+
+func TestSomething_suffix(t *testing.T) {
+}
+
+func ExampleBuffer_reader() {
+}

data/testdata/blank-import-lib.go

@@ -0,0 +1,39 @@
+// Test that blank imports in library packages are flagged.
+
+// Package foo ...
+package foo
+
+// The instructions need to go before the imports below so they will not be
+// mistaken for documentation.
+
+/* MATCH /blank import/ */ import _ "encoding/json"
+
+import (
+	"fmt"
+
+	/* MATCH /blank import/ */ _ "os"
+
+	/* MATCH /blank import/ */ _ "net/http"
+	_ "path"
+)
+
+import _ "encoding/base64" // Don't gripe about this
+
+import (
+	// Don't gripe about these next two lines.
+	_ "compress/zlib"
+	_ "syscall"
+
+	/* MATCH /blank import/ */ _ "path/filepath"
+)
+
+import (
+	"go/ast"
+	_ "go/scanner" // Don't gripe about this or the following line.
+	_ "go/token"
+)
+
+var (
+	_ fmt.Stringer // for "fmt"
+	_ ast.Node     // for "go/ast"
+)

data/testdata/blank-import-lib_test.go

@@ -0,0 +1,25 @@
+// Test that blank imports in test packages are not flagged.
+// OK
+
+// Package foo ...
+package foo
+
+// These are essentially the same imports as in the "library" package, but
+// these should not trigger the warning because this is a test.
+
+import _ "encoding/json"
+
+import (
+	"fmt"
+	"testing"
+
+	_ "os"
+
+	_ "net/http"
+	_ "path"
+)
+
+var (
+	_ fmt.Stringer // for "fmt"
+	_ testing.T    // for "testing"
+)

data/testdata/blank-import-main.go

@@ -0,0 +1,14 @@
+// Test that blank imports in package main are not flagged.
+// OK
+
+// Binary foo ...
+package main
+
+import _ "fmt"
+
+import (
+	"os"
+	_ "path"
+)
+
+var _ os.File // for "os"

data/testdata/broken.go

@@ -0,0 +1,9 @@
+// Test of code that is malformed, but accepted by go/parser.
+// See https://golang.org/issue/11271 for discussion.
+// OK
+
+// Package pkg ...
+package pkg
+
+// Foo is a method with a missing receiver.
+func () Foo() {}

data/testdata/common-methods.go

@@ -0,0 +1,16 @@
+// Test that we don't nag for comments on common methods.
+// OK
+
+// Package pkg ...
+package pkg
+
+import "net/http"
+
+// T is ...
+type T int
+
+func (T) Error() string                                    { return "" }
+func (T) String() string                                   { return "" }
+func (T) ServeHTTP(w http.ResponseWriter, r *http.Request) {}
+func (T) Read(p []byte) (n int, err error)                 { return 0, nil }
+func (T) Write(p []byte) (n int, err error)                { return 0, nil }

data/testdata/const-block.go

@@ -0,0 +1,36 @@
+// Test for docs in const blocks
+
+// Package foo ...
+package foo
+
+const (
+	// Prefix for something.
+	// MATCH /InlineWhatever.*form/
+	InlineWhatever = "blah"
+
+	Whatsit = "missing_comment" // MATCH /Whatsit.*should have comment.*block/
+
+	// We should only warn once per block for missing comments,
+	// but always complain about malformed comments.
+
+	WhosYourDaddy = "another_missing_one"
+
+	// Something
+	// MATCH /WhatDoesHeDo.*form/
+	WhatDoesHeDo = "it's not a tumor!"
+)
+
+// These shouldn't need doc comments.
+const (
+	Alpha = "a"
+	Beta  = "b"
+	Gamma = "g"
+)
+
+// The comment on the previous const block shouldn't flow through to here.
+
+const UndocAgain = 6 // MATCH /UndocAgain.*should have comment/
+
+const (
+	SomeUndocumented = 7 // MATCH /SomeUndocumented.*should have comment.*block/
+)

data/testdata/context.go

@@ -0,0 +1,24 @@
+// Test that context.Context is the first arg to a function.
+
+// Package foo ...
+package foo
+
+import (
+	"context"
+)
+
+// A proper context.Context location
+func x(ctx context.Context) { // ok
+}
+
+// A proper context.Context location
+func x(ctx context.Context, s string) { // ok
+}
+
+// An invalid context.Context location
+func y(s string, ctx context.Context) { // MATCH /context.Context should be the first parameter.*/
+}
+
+// An invalid context.Context location with more than 2 args
+func y(s string, r int, ctx context.Context, x int) { // MATCH /context.Context should be the first parameter.*/
+}

data/testdata/contextkeytypes.go

@@ -0,0 +1,38 @@
+// Package contextkeytypes verifies that correct types are used as keys in
+// calls to context.WithValue.
+package contextkeytypes
+
+import (
+	"context"
+	"fmt"
+)
+
+type ctxKey struct{}
+
+func contextKeyTypeTests() {
+	fmt.Println()                               // not in package context
+	context.TODO()                              // wrong function
+	c := context.Background()                   // wrong function
+	context.WithValue(c, "foo", "bar")          // MATCH /should not use basic type( untyped|)? string as key in context.WithValue/
+	context.WithValue(c, true, "bar")           // MATCH /should not use basic type( untyped|)? bool as key in context.WithValue/
+	context.WithValue(c, 1, "bar")              // MATCH /should not use basic type( untyped|)? int as key in context.WithValue/
+	context.WithValue(c, int8(1), "bar")        // MATCH /should not use basic type int8 as key in context.WithValue/
+	context.WithValue(c, int16(1), "bar")       // MATCH /should not use basic type int16 as key in context.WithValue/
+	context.WithValue(c, int32(1), "bar")       // MATCH /should not use basic type int32 as key in context.WithValue/
+	context.WithValue(c, rune(1), "bar")        // MATCH /should not use basic type rune as key in context.WithValue/
+	context.WithValue(c, int64(1), "bar")       // MATCH /should not use basic type int64 as key in context.WithValue/
+	context.WithValue(c, uint(1), "bar")        // MATCH /should not use basic type uint as key in context.WithValue/
+	context.WithValue(c, uint8(1), "bar")       // MATCH /should not use basic type uint8 as key in context.WithValue/
+	context.WithValue(c, byte(1), "bar")        // MATCH /should not use basic type byte as key in context.WithValue/
+	context.WithValue(c, uint16(1), "bar")      // MATCH /should not use basic type uint16 as key in context.WithValue/
+	context.WithValue(c, uint32(1), "bar")      // MATCH /should not use basic type uint32 as key in context.WithValue/
+	context.WithValue(c, uint64(1), "bar")      // MATCH /should not use basic type uint64 as key in context.WithValue/
+	context.WithValue(c, uintptr(1), "bar")     // MATCH /should not use basic type uintptr as key in context.WithValue/
+	context.WithValue(c, float32(1.0), "bar")   // MATCH /should not use basic type float32 as key in context.WithValue/
+	context.WithValue(c, float64(1.0), "bar")   // MATCH /should not use basic type float64 as key in context.WithValue/
+	context.WithValue(c, complex64(1i), "bar")  // MATCH /should not use basic type complex64 as key in context.WithValue/
+	context.WithValue(c, complex128(1i), "bar") // MATCH /should not use basic type complex128 as key in context.WithValue/
+	context.WithValue(c, ctxKey{}, "bar")       // ok
+	context.WithValue(c, &ctxKey{}, "bar")      // ok
+	context.WithValue(c, invalid{}, "bar")      // ok
+}

data/testdata/else-multi.go

@@ -0,0 +1,18 @@
+// Test of return+else warning; should not trigger on multi-branch if/else.
+// OK
+
+// Package pkg ...
+package pkg
+
+import "log"
+
+func f(x int) bool {
+	if x == 0 {
+		log.Print("x is zero")
+	} else if x > 0 {
+		return true
+	} else {
+		log.Printf("non-positive x: %d", x)
+	}
+	return false
+}

data/testdata/else.go

@@ -0,0 +1,23 @@
+// Test of return+else warning.
+
+// Package pkg ...
+package pkg
+
+import "log"
+
+func f(x int) bool {
+	if x > 0 {
+		return true
+	} else { // MATCH /if.*return.*else.*outdent/
+		log.Printf("non-positive x: %d", x)
+	}
+	return false
+}
+
+func g(f func() bool) string {
+	if ok := f(); ok {
+		return "it's okay"
+	} else { // MATCH /if.*return.*else.*outdent.*short.*var.*declaration/
+		return "it's NOT okay!"
+	}
+}

data/testdata/error-return.go

@@ -0,0 +1,43 @@
+// Test for returning errors.
+
+// Package foo ...
+package foo
+
+// Returns nothing
+func f() { // ok
+}
+
+// Check for a single error return
+func g() error { // ok
+	return nil
+}
+
+// Check for a single other return type
+func h() int { // ok
+	return 0
+}
+
+// Check for multiple return but error at end.
+func i() (int, error) { // ok
+	return 0, nil
+}
+
+// Check for multiple return but error at end with named variables.
+func j() (x int, err error) { // ok
+	return 0, nil
+}
+
+// Check for error in the wrong location on 2 types
+func k() (error, int) { // MATCH /error should be the last type/
+	return nil, 0
+}
+
+// Check for error in the wrong location for > 2 types
+func l() (int, error, int) { // MATCH /error should be the last type/
+	return 0, nil, 0
+}
+
+// Check for error in the wrong location with named variables.
+func m() (x int, err error, y int) { // MATCH /error should be the last type/
+	return 0, nil, 0
+}

data/testdata/errorf.go

@@ -0,0 +1,40 @@
+// Test for not using fmt.Errorf or testing.Errorf.
+
+// Package foo ...
+package foo
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+func f(x int) error {
+	if x > 10 {
+		return errors.New(fmt.Sprintf("something %d", x)) // MATCH /should replace.*errors\.New\(fmt\.Sprintf\(\.\.\.\)\).*fmt\.Errorf\(\.\.\.\)/ -> `		return fmt.Errorf("something %d", x)`
+	}
+	if x > 5 {
+		return errors.New(g("blah")) // ok
+	}
+	if x > 4 {
+		return errors.New("something else") // ok
+	}
+	return nil
+}
+
+// TestF is a dummy test
+func TestF(t *testing.T) error {
+	x := 1
+	if x > 10 {
+		return t.Error(fmt.Sprintf("something %d", x)) // MATCH /should replace.*t\.Error\(fmt\.Sprintf\(\.\.\.\)\).*t\.Errorf\(\.\.\.\)/
+	}
+	if x > 5 {
+		return t.Error(g("blah")) // ok
+	}
+	if x > 4 {
+		return t.Error("something else") // ok
+	}
+	return nil
+}
+
+func g(s string) string { return "prefix: " + s }

data/testdata/errors.go

@@ -0,0 +1,38 @@
+// Test for naming errors.
+
+// Package foo ...
+package foo
+
+import (
+	"errors"
+	"fmt"
+)
+
+var unexp = errors.New("some unexported error") // MATCH /error var.*unexp.*errFoo/
+
+// Exp ...
+var Exp = errors.New("some exported error") // MATCH /error var.*Exp.*ErrFoo/
+
+var (
+	e1 = fmt.Errorf("blah %d", 4) // MATCH /error var.*e1.*errFoo/
+	// E2 ...
+	E2 = fmt.Errorf("blah %d", 5) // MATCH /error var.*E2.*ErrFoo/
+)
+
+func f() {
+	var whatever = errors.New("ok") // ok
+	_ = whatever
+}
+
+// Check for the error strings themselves.
+
+func g(x int) error {
+	var err error
+	err = fmt.Errorf("This %d is too low", x)     // MATCH /error strings.*be capitalized/
+	err = fmt.Errorf("XML time")                  // ok
+	err = fmt.Errorf("newlines are fun\n")        // MATCH /error strings.*end with punctuation/
+	err = fmt.Errorf("Newlines are really fun\n") // MATCH /error strings.+not be capitalized/
+	err = errors.New(`too much stuff.`)           // MATCH /error strings.*end with punctuation/
+	err = errors.New("This %d is too low", x)     // MATCH /error strings.*be capitalized/
+	return err
+}

data/testdata/iferr.go

@@ -0,0 +1,101 @@
+// Test of redundant if err != nil
+
+// Package pkg ...
+package pkg
+
+func f() error {
+	if err := f(); err != nil {
+		g()
+		return err
+	}
+	return nil
+}
+
+func g() error {
+	if err := f(); err != nil { // MATCH /redundant/
+		return err
+	}
+	return nil
+}
+
+func h() error {
+	if err, x := f(), 1; err != nil {
+		return err
+	}
+	return nil
+}
+
+func i() error {
+	a := 1
+	if err := f(); err != nil {
+		a++
+		return err
+	}
+	return nil
+}
+
+func j() error {
+	var a error
+	if err := f(); err != nil {
+		return err
+	}
+	return a
+}
+
+func k() error {
+	if err := f(); err != nil {
+		// TODO: handle error better
+		return err
+	}
+	return nil
+}
+
+func l() (interface{}, error) {
+	if err := f(); err != nil {
+		return nil, err
+	}
+	if err := f(); err != nil {
+		return nil, err
+	}
+	if err := f(); err != nil {
+		return nil, err
+	}
+	// Phew, it worked
+	return nil
+}
+
+func m() error {
+	if err := f(); err != nil {
+		return err
+	}
+	if err := f(); err != nil {
+		return err
+	}
+	if err := f(); err != nil {
+		return err
+	}
+	// Phew, it worked again.
+	return nil
+}
+
+func multi() error {
+	a := 0
+	var err error
+	// unreachable code after return statements is intentional to check that it
+	// doesn't confuse the linter.
+	if true {
+		a++
+		if err := f(); err != nil { // MATCH /redundant/
+			return err
+		}
+		return nil
+		a++
+	} else {
+		a++
+		if err = f(); err != nil { // MATCH /redundant/
+			return err
+		}
+		return nil
+		a++
+	}
+}