pikeman 0.0.1

data/testdata/import-dot.go

@@ -0,0 +1,8 @@
+// Test that dot imports are flagged.
+
+// Package pkg ...
+package pkg
+
+import . "fmt" // MATCH /dot import/
+
+var _ Stringer // from "fmt"

data/testdata/inc.go

@@ -0,0 +1,14 @@
+// Test for use of x++ and x--.
+
+// Package pkg ...
+package pkg
+
+func addOne(x int) int {
+	x += 1 // MATCH /x\+\+/
+	return x
+}
+
+func subOneInLoop(y int) {
+	for ; y > 0; y -= 1 { // MATCH /y--/
+	}
+}

data/testdata/names.go

@@ -0,0 +1,116 @@
+// Test for name linting.
+
+// Package pkg_with_underscores ...
+package pkg_with_underscores // MATCH /underscore.*package name/
+
+import (
+	"io"
+	"net"
+	net_http "net/http" // renamed deliberately
+	"net/url"
+)
+
+import "C"
+
+var var_name int // MATCH /underscore.*var.*var_name/
+
+type t_wow struct { // MATCH /underscore.*type.*t_wow/
+	x_damn int      // MATCH /underscore.*field.*x_damn/
+	Url    *url.URL // MATCH /struct field.*Url.*URL/
+}
+
+const fooId = "blah" // MATCH /fooId.*fooID/
+
+func f_it() { // MATCH /underscore.*func.*f_it/
+	more_underscore := 4 // MATCH /underscore.*var.*more_underscore/
+	_ = more_underscore
+	var err error
+	if isEof := (err == io.EOF); isEof { // MATCH /var.*isEof.*isEOF/
+		more_underscore = 7 // should be okay
+	}
+
+	x := net_http.Request{} // should be okay
+	_ = x
+
+	var ips []net.IP
+	for _, theIp := range ips { // MATCH /range var.*theIp.*theIP/
+		_ = theIp
+	}
+
+	switch myJson := g(); { // MATCH /var.*myJson.*myJSON/
+	default:
+		_ = myJson
+	}
+	var y net_http.ResponseWriter // an interface
+	switch tApi := y.(type) {     // MATCH /var.*tApi.*tAPI/
+	default:
+		_ = tApi
+	}
+
+	var c chan int
+	select {
+	case qId := <-c: // MATCH /var.*qId.*qID/
+		_ = qId
+	}
+}
+
+// Common styles in other languages that don't belong in Go.
+const (
+	CPP_CONST   = 1 // MATCH /ALL_CAPS.*CamelCase/
+	kLeadingKay = 2 // MATCH /k.*leadingKay/
+
+	HTML  = 3 // okay; no underscore
+	X509B = 4 // ditto
+)
+
+func f(bad_name int)                    {}            // MATCH /underscore.*func parameter.*bad_name/
+func g() (no_way int)                   { return 0 }  // MATCH /underscore.*func result.*no_way/
+func (t *t_wow) f(more_under string)    {}            // MATCH /underscore.*method parameter.*more_under/
+func (t *t_wow) g() (still_more string) { return "" } // MATCH /underscore.*method result.*still_more/
+
+type i interface {
+	CheckHtml() string // okay; interface method names are often constrained by the concrete types' method names
+
+	F(foo_bar int) // MATCH /foo_bar.*fooBar/
+}
+
+// All okay; underscore between digits
+const case1_1 = 1
+
+type case2_1 struct {
+	case2_2 int
+}
+
+func case3_1(case3_2 int) (case3_3 string) {
+	case3_4 := 4
+	_ = case3_4
+
+	return ""
+}
+
+type t struct{}
+
+func (t) LastInsertId() (int64, error) { return 0, nil } // okay because it matches a known style violation
+
+//export exported_to_c
+func exported_to_c() {} // okay: https://github.com/golang/lint/issues/144
+
+//export exported_to_c_with_arg
+func exported_to_c_with_arg(but_use_go_param_names int) // MATCH /underscore.*func parameter.*but_use_go_param_names/
+
+// This is an exported C function with a leading doc comment.
+//
+//export exported_to_c_with_comment
+func exported_to_c_with_comment() {} // okay: https://github.com/golang/lint/issues/144
+
+//export maybe_exported_to_CPlusPlusWithCamelCase
+func maybe_exported_to_CPlusPlusWithCamelCase() {} // okay: https://github.com/golang/lint/issues/144
+
+// WhyAreYouUsingCapitalLetters_InACFunctionName is a Go-exported function that
+// is also exported to C as a name with underscores.
+//
+// Don't do that. If you want to use a C-style name for a C export, make it
+// lower-case and leave it out of the Go-exported API.
+//
+//export WhyAreYouUsingCapitalLetters_InACFunctionName
+func WhyAreYouUsingCapitalLetters_InACFunctionName() {} // MATCH /underscore.*func.*Why.*CFunctionName/

data/testdata/pkg-caps.go

@@ -0,0 +1,4 @@
+// MixedCaps package name
+
+// Package PkgName ...
+package PkgName // MATCH /don't use MixedCaps in package name/

data/testdata/pkg-doc1.go

@@ -0,0 +1,3 @@
+// Test of missing package comment.
+
+package foo // MATCH /should.*package comment.*unless/

data/testdata/pkg-doc2.go

@@ -0,0 +1,5 @@
+// Test of package comment in an incorrect form.
+
+// Some random package doc that isn't in the right form.
+// MATCH /package comment should.*form.*"Package testdata .*"/
+package testdata

data/testdata/pkg-doc3.go

@@ -0,0 +1,7 @@
+// Test of block package comment.
+// OK
+
+/*
+Package foo is pretty sweet.
+*/
+package foo

data/testdata/pkg-doc4.go

@@ -0,0 +1,7 @@
+// Test of block package comment with leading space.
+
+/*
+ Package foo is pretty sweet.
+MATCH /package comment.*leading space/
+*/
+package foo

data/testdata/pkg-doc5.go

@@ -0,0 +1,9 @@
+// Test of detached package comment.
+
+/*
+Package foo is pretty sweet.
+*/
+
+package foo
+
+// MATCH:6 /package comment.*detached/

data/testdata/pkg-main.go

@@ -0,0 +1,5 @@
+// Test of package comment for package main.
+// OK
+
+// This binary does something awesome.
+package main

data/testdata/range.go

@@ -0,0 +1,43 @@
+// Test for range construction.
+
+// Package foo ...
+package foo
+
+func f() {
+	var m map[string]int
+
+	// with :=
+	for x, _ := range m { // MATCH /should omit 2nd value.*range.*equivalent.*for x := range/ -> `	for x := range m {`
+		_ = x
+	}
+	// with =
+	var y string
+	_ = y
+	for y, _ = range m { // MATCH /should omit 2nd value.*range.*equivalent.*for y = range/
+	}
+
+	for _ = range m { // MATCH /should omit values.*range.*equivalent.*for range/
+	}
+
+	for _, _ = range m { // MATCH /should omit values.*range.*equivalent.*for range/
+	}
+
+	// all OK:
+	for x := range m {
+		_ = x
+	}
+	for x, y := range m {
+		_, _ = x, y
+	}
+	for _, y := range m {
+		_ = y
+	}
+	var x int
+	_ = x
+	for y = range m {
+	}
+	for y, x = range m {
+	}
+	for _, x = range m {
+	}
+}

data/testdata/receiver-names.go

@@ -0,0 +1,49 @@
+// Test for bad receiver names.
+
+// Package foo ...
+package foo
+
+type foo struct{}
+
+func (this foo) f1() { // MATCH /should be a reflection of its identity/
+}
+
+func (self foo) f2() { // MATCH /should be a reflection of its identity/
+}
+
+func (f foo) f3() {
+}
+
+func (foo) f4() {
+}
+
+type bar struct{}
+
+func (b bar) f1() {
+}
+
+func (b bar) f2() {
+}
+
+func (a bar) f3() { // MATCH /receiver name a should be consistent with previous receiver name b for bar/
+}
+
+func (a *bar) f4() { // MATCH /receiver name a should be consistent with previous receiver name b for bar/
+}
+
+func (b *bar) f5() {
+}
+
+func (bar) f6() {
+}
+
+func (_ *bar) f7() { // MATCH /receiver name should not be an underscore/
+}
+
+type multiError struct{}
+
+func (me multiError) f8() {
+}
+
+// Regression test for a panic caused by ill-formed receiver type.
+func (recv []*x.y) f()

data/testdata/sort.go

@@ -0,0 +1,20 @@
+// Test that we don't ask for comments on sort.Interface methods.
+
+// Package pkg ...
+package pkg
+
+// T is ...
+type T []int
+
+// Len by itself should get documented.
+
+func (t T) Len() int { return len(t) } // MATCH /exported method T\.Len.*should.*comment/
+
+// U is ...
+type U []int
+
+func (u U) Len() int           { return len(u) }
+func (u U) Less(i, j int) bool { return u[i] < u[j] }
+func (u U) Swap(i, j int)      { u[i], u[j] = u[j], u[i] }
+
+func (u U) Other() {} // MATCH /exported method U\.Other.*should.*comment/

data/testdata/stutter.go

@@ -0,0 +1,25 @@
+// Test of stuttery names.
+
+// Package donut ...
+package donut
+
+// DonutMaker makes donuts.
+type DonutMaker struct{} // MATCH /donut\.DonutMaker.*stutter/
+
+// DonutRank computes the ranking of a donut.
+func DonutRank(d Donut) int { // MATCH /donut\.DonutRank.*stutter/
+	return 0
+}
+
+// Donut is a delicious treat.
+type Donut struct{} // ok because it is the whole name
+
+// Donuts are great, aren't they?
+type Donuts []Donut // ok because it didn't start a new word
+
+type donutGlaze int // ok because it is unexported
+
+// DonutMass reports the mass of a donut.
+func (d *Donut) DonutMass() (grams int) { // okay because it is a method
+	return 38
+}

data/testdata/time.go

@@ -0,0 +1,13 @@
+// Test of time suffixes.
+
+// Package foo ...
+package foo
+
+import (
+	"flag"
+	"time"
+)
+
+var rpcTimeoutMsec = flag.Duration("rpc_timeout", 100*time.Millisecond, "some flag") // MATCH /Msec.*\*time.Duration/
+
+var timeoutSecs = 5 * time.Second // MATCH /Secs.*time.Duration/

data/testdata/unexp-return.go

@@ -0,0 +1,46 @@
+// Test for unexported return types.
+
+// Package foo ...
+package foo
+
+import ()
+
+type hidden struct{}
+
+// Exported returns a hidden type, which is annoying.
+func Exported() hidden { // MATCH /Exported.*unexported.*hidden/
+	return hidden{}
+}
+
+// ExpErr returns a builtin type.
+func ExpErr() error { // ok
+}
+
+func (hidden) ExpOnHidden() hidden { // ok
+}
+
+// T is another test type.
+type T struct{}
+
+// MethodOnT returns a hidden type, which is annoying.
+func (T) MethodOnT() hidden { // MATCH /method MethodOnT.*unexported.*hidden/
+	return hidden{}
+}
+
+// ExpT returns a T.
+func ExpT() T { // ok
+	return T{}
+}
+
+func unexp() hidden { // ok
+	return hidden{}
+}
+
+// This is slightly sneaky: we shadow the builtin "int" type.
+
+type int struct{}
+
+// ExportedIntReturner returns an unexported type from this package.
+func ExportedIntReturner() int { // MATCH /ExportedIntReturner.*unexported.*int/
+	return int{}
+}

data/testdata/var-decl.go

@@ -0,0 +1,86 @@
+// Test for redundant type declaration.
+
+// Package foo ...
+package foo
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"nosuchpkg" // export data unavailable
+	"os"
+)
+
+// Q is a test type.
+type Q bool
+
+var myInt int = 7                           // MATCH /should.*int.*myInt.*inferred/
+var mux *http.ServeMux = http.NewServeMux() // MATCH /should.*\*http\.ServeMux.*inferred/
+
+var myZeroInt int = 0         // MATCH /should.*= 0.*myZeroInt.*zero value/
+var myZeroFlt float32 = 0.    // MATCH /should.*= 0\..*myZeroFlt.*zero value/
+var myZeroF64 float64 = 0.0   // MATCH /should.*= 0\..*myZeroF64.*zero value/
+var myZeroImg complex64 = 0i  // MATCH /should.*= 0i.*myZeroImg.*zero value/
+var myZeroStr string = ""     // MATCH /should.*= "".*myZeroStr.*zero value/
+var myZeroRaw string = ``     // MATCH /should.*= ``.*myZeroRaw.*zero value/
+var myZeroPtr *Q = nil        // MATCH /should.*= nil.*myZeroPtr.*zero value/
+var myZeroRune rune = '\x00'  // MATCH /should.*= '\\x00'.*myZeroRune.*zero value/
+var myZeroRune2 rune = '\000' // MATCH /should.*= '\\000'.*myZeroRune2.*zero value/
+
+// No warning because there's no type on the LHS
+var x = 0
+
+// This shouldn't get a warning because there's no initial values.
+var str fmt.Stringer
+
+// No warning because this is a const.
+const k uint64 = 7
+
+const num = 123
+
+// No warning because the var's RHS is known to be an untyped const.
+var flags uint32 = num
+
+// No warnings because the RHS is an ideal int, and the LHS is a different int type.
+var userID int64 = 1235
+var negID int64 = -1
+var parenID int64 = (17)
+var crazyID int64 = -(-(-(-9)))
+
+// Same, but for strings and floats.
+type stringT string
+type floatT float64
+
+var stringV stringT = "abc"
+var floatV floatT = 123.45
+
+// No warning because the LHS names an interface type.
+var data interface{} = googleIPs
+var googleIPs []int
+
+// No warning because it's a common idiom for interface satisfaction.
+var _ Server = (*serverImpl)(nil)
+
+// Server is a test type.
+type Server interface{}
+type serverImpl struct{}
+
+// LHS is a different type than the RHS.
+var myStringer fmt.Stringer = q(0)
+
+// LHS is a different type than the RHS.
+var out io.Writer = os.Stdout
+
+var out2 io.Writer = newWriter() // MATCH /should omit.*io\.Writer/
+
+func newWriter() io.Writer { return nil }
+
+// We don't figure out the true types of LHS and RHS here,
+// so we suppress the check.
+var ni nosuchpkg.Interface = nosuchpkg.NewConcrete()
+
+var y string = q(1).String() // MATCH /should.*string/
+
+type q int
+
+func (q) String() string { return "I'm a q" }