adds tests for specific go versions

test/datarace_test.go

@@ -9,3 +9,7 @@ import (
 func TestDatarace(t *testing.T) {
 	testRule(t, "datarace", &rule.DataRaceRule{})
 }
+
+func TestDataraceAfterGo1_22(t *testing.T) {
+	testRule(t, "go1.22/datarace", &rule.DataRaceRule{})
+}

test/file-filter_test.go

@@ -38,7 +38,7 @@ func TestFileExcludeFilterAtRuleLevel(t *testing.T) {
 
 	t.Run("not called if exclude not match", func(t *testing.T) {
 		rule := &TestFileFilterRule{}
-		cfg := &lint.RuleConfig{Exclude: []string{"file-to-exclude.go"}}
+		cfg := &lint.RuleConfig{Exclude: []string{"../testdata/file-to-exclude.go"}}
 		cfg.Initialize()
 		testRule(t, "file-to-exclude", rule, cfg)
 		if rule.WasApplyed {

test/golint_test.go

@@ -64,7 +64,7 @@ func TestAll(t *testing.T) {
 				t.Fatalf("Failed reading %s: %v", fi.Name(), err)
 			}
 
-			if err := assertFailures(t, baseDir, fileInfo, src, rules, map[string]lint.RuleConfig{}); err != nil {
+			if err := assertFailures(t, path.Dir(baseDir), fileInfo, src, rules, map[string]lint.RuleConfig{}); err != nil {
 				t.Errorf("Linting %s: %v", fi.Name(), err)
 			}
 		})

test/range-val-address_test.go

@@ -10,3 +10,7 @@ import (
 func TestRangeValAddress(t *testing.T) {
 	testRule(t, "range-val-address", &rule.RangeValAddress{}, &lint.RuleConfig{})
 }
+
+func TestRangeValAddressAfterGo1_22(t *testing.T) {
+	testRule(t, "go1.22/range-val-address", &rule.RangeValAddress{}, &lint.RuleConfig{})
+}

test/range-val-in-closure_test.go

@@ -10,3 +10,7 @@ import (
 func TestRangeValInClosure(t *testing.T) {
 	testRule(t, "range-val-in-closure", &rule.RangeValInClosureRule{}, &lint.RuleConfig{})
 }
+
+func TestRangeValInClosureAfterGo1_22(t *testing.T) {
+	testRule(t, "go1.22/range-val-in-closure", &rule.RangeValInClosureRule{}, &lint.RuleConfig{})
+}

test/redefines-builtin-id_test.go

@@ -10,3 +10,7 @@ import (
 func TestRedefinesBuiltinID(t *testing.T) {
 	testRule(t, "redefines-builtin-id", &rule.RedefinesBuiltinIDRule{})
 }
+
+func TestRedefinesBuiltinIDAfterGo1_21(t *testing.T) {
+	testRule(t, "go1.21/redefines-builtin-id", &rule.RedefinesBuiltinIDRule{})
+}

test/utils_test.go

@@ -10,6 +10,7 @@ import (
 	"go/token"
 	"go/types"
 	"os"
+	"path"
 	"strconv"
 	"strings"
 	"testing"
@@ -18,21 +19,22 @@ import (
 )
 
 func testRule(t *testing.T, filename string, rule lint.Rule, config ...*lint.RuleConfig) {
-	baseDir := "../testdata/"
-	filename = filename + ".go"
-	src, err := os.ReadFile(baseDir + filename)
+	baseDir := path.Join("../testdata/" + path.Dir(filename))
+	filename = path.Base(filename) + ".go"
+	fullFilePath := path.Join(baseDir, filename)
+	src, err := os.ReadFile(fullFilePath)
 	if err != nil {
 		t.Fatalf("Bad filename path in test for %s: %v", rule.Name(), err)
 	}
-	stat, err := os.Stat(baseDir + filename)
+	stat, err := os.Stat(fullFilePath)
 	if err != nil {
 		t.Fatalf("Cannot get file info for %s: %v", rule.Name(), err)
 	}
 	c := map[string]lint.RuleConfig{}
 	if config != nil {
 		c[rule.Name()] = *config[0]
 	}
-	if parseInstructions(t, filename, src) == nil {
+	if parseInstructions(t, fullFilePath, src) == nil {
 		assertSuccess(t, baseDir, stat, []lint.Rule{rule}, c)
 		return
 	}
@@ -41,10 +43,11 @@ func testRule(t *testing.T, filename string, rule lint.Rule, config ...*lint.Rul
 
 func assertSuccess(t *testing.T, baseDir string, fi os.FileInfo, rules []lint.Rule, config map[string]lint.RuleConfig) error {
 	l := lint.New(func(file string) ([]byte, error) {
-		return os.ReadFile(baseDir + file)
+		return os.ReadFile(file)
 	}, 0)
 
-	ps, err := l.Lint([][]string{{fi.Name()}}, rules, lint.Config{
+	filePath := path.Join(baseDir, fi.Name())
+	ps, err := l.Lint([][]string{{filePath}}, rules, lint.Config{
 		Rules: config,
 	})
 	if err != nil {
@@ -63,15 +66,15 @@ func assertSuccess(t *testing.T, baseDir string, fi os.FileInfo, rules []lint.Ru
 
 func assertFailures(t *testing.T, baseDir string, fi os.FileInfo, src []byte, rules []lint.Rule, config map[string]lint.RuleConfig) error {
 	l := lint.New(func(file string) ([]byte, error) {
-		return os.ReadFile(baseDir + file)
+		return os.ReadFile(file)
 	}, 0)
 
-	ins := parseInstructions(t, fi.Name(), src)
+	ins := parseInstructions(t, path.Join(baseDir, fi.Name()), src)
 	if ins == nil {
 		return fmt.Errorf("Test file %v does not have instructions", fi.Name())
 	}
 
-	ps, err := l.Lint([][]string{{fi.Name()}}, rules, lint.Config{
+	ps, err := l.Lint([][]string{{path.Join(baseDir, fi.Name())}}, rules, lint.Config{
 		Rules: config,
 	})
 	if err != nil {

testdata/go.mod

@@ -0,0 +1,5 @@
+module github.com/mgechev/revive/testdata
+
+// set the lowest go version 
+// to trigger testing of all rules
+go 1.0

testdata/go1.21/go.mod

@@ -0,0 +1,3 @@
+module github.com/mgechev/revive/testdata
+
+go 1.21

testdata/go1.21/redefines-builtin-id.go

@@ -0,0 +1,54 @@
+package fixtures
+
+func (this data) vmethod() {
+	nil := true // MATCH /assignment creates a shadow of built-in identifier nil/
+	iota = 1    // MATCH /assignment modifies built-in identifier iota/
+}
+
+func append(i, j int) { // MATCH /redefinition of the built-in function append/
+
+}
+
+type string int16 // MATCH /redefinition of the built-in type string/
+
+func delete(set []int64, i int) (y []int64) { // MATCH /redefinition of the built-in function delete/
+	for j, v := range set {
+		if j != i {
+			y = append(y, v)
+		}
+	}
+	return
+}
+
+type any int // MATCH /redefinition of the built-in type any/
+
+func any() {} // MATCH /redefinition of the built-in type any/
+
+var any int // MATCH /redefinition of the built-in type any/
+
+const any = 1 // MATCH /redefinition of the built-in type any/
+
+var i, copy int // MATCH /redefinition of the built-in function copy/
+
+// issue #792
+type ()
+
+func foo() {
+	clear := 0 // MATCH /redefinition of the built-in function clear/
+	max := 0   // MATCH /redefinition of the built-in function max/
+	min := 0   // MATCH /redefinition of the built-in function min/
+	_ = clear
+	_ = max
+	_ = min
+}
+
+func foo1(new int) { // MATCH /redefinition of the built-in function new/
+	_ = new
+}
+
+func foo2() (new int) { // MATCH /redefinition of the built-in function new/
+	return
+}
+
+func foo3[new any]() { // MATCH /redefinition of the built-in function new/
+}

testdata/go1.22/datarace.go

@@ -0,0 +1,30 @@
+package fixtures
+
+func datarace() (r int, c char) {
+	for _, p := range []int{1, 2} {
+		go func() {
+			print(r) // MATCH /potential datarace: return value r is captured (by-reference) in goroutine/
+			print(p) // Shall not match /datarace: range value p is captured (by-reference) in goroutine/
+		}()
+		for i, p1 := range []int{1, 2} {
+			a := p1
+			go func() {
+				print(r)  // MATCH /potential datarace: return value r is captured (by-reference) in goroutine/
+				print(p)  // Shall not match /datarace: range value p is captured (by-reference) in goroutine/
+				print(p1) // Shall not match /datarace: range value p1 is captured (by-reference) in goroutine/
+				print(a)
+				print(i) // Shall not match /datarace: range value i is captured (by-reference) in goroutine/
+			}()
+			print(i)
+			print(p)
+			go func() {
+				_ = c // MATCH /potential datarace: return value c is captured (by-reference) in goroutine/
+			}()
+		}
+		print(p1)
+	}
+	go func() {
+		print(r) // MATCH /potential datarace: return value r is captured (by-reference) in goroutine/
+	}()
+	print(r)
+}

testdata/go1.22/go.mod

@@ -0,0 +1,3 @@
+module github.com/mgechev/revive/testdata
+
+go 1.22

testdata/go1.22/range-val-address.go

@@ -0,0 +1,163 @@
+package fixtures
+
+func rangeValAddress() {
+	m := map[string]*string{}
+
+	mySlice := []string{"A", "B", "C"}
+	for _, value := range mySlice {
+		m["address"] = &value // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}
+
+func rangeValAddress2() {
+	m := map[string]*string{}
+
+	mySlice := []string{"A", "B", "C"}
+	for i := range mySlice {
+		m["address"] = &mySlice[i]
+	}
+}
+
+func rangeValAddress3() {
+	m := map[string]*string{}
+
+	mySlice := []string{"A", "B", "C"}
+	for _, value := range mySlice {
+		a := &value // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+		m["address"] = a
+	}
+}
+
+func rangeValAddress4() {
+	m := []*string{}
+
+	mySlice := []string{"A", "B", "C"}
+	for _, value := range mySlice {
+		m = append(m, &value) // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}
+
+func rangeValAddress5() {
+	m := map[*string]string{}
+
+	mySlice := []string{"A", "B", "C"}
+	for _, value := range mySlice {
+		m[&value] = value // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}
+
+func rangeValAddress6() {
+	type v struct {
+		id string
+	}
+	m := []*string{}
+
+	mySlice := []v{{id: "A"}, {id: "B"}, {id: "C"}}
+	for _, value := range mySlice {
+		m = append(m, &value.id) // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}
+
+func rangeValAddress7() {
+	type v struct {
+		id string
+	}
+	m := []*string{}
+
+	for _, value := range []v{{id: "A"}, {id: "B"}, {id: "C"}} {
+		m = append(m, &value.id) // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}
+
+func rangeValAddress8() {
+	type v struct {
+		id string
+	}
+	m := []*string{}
+
+	mySlice := []*v{{id: "A"}, {id: "B"}, {id: "C"}}
+	for _, value := range mySlice {
+		m = append(m, &value.id)
+	}
+}
+
+func rangeValAddress9() {
+	type v struct {
+		id string
+	}
+	m := []*string{}
+
+	mySlice := map[string]*v{"a": {id: "A"}, "b": {id: "B"}, "c": {id: "C"}}
+	for _, value := range mySlice {
+		m = append(m, &value.id)
+	}
+}
+
+func rangeValAddress10() {
+	type v struct {
+		id string
+	}
+	m := []*string{}
+
+	for _, value := range map[string]*v{"a": {id: "A"}, "b": {id: "B"}, "c": {id: "C"}} {
+		m = append(m, &value.id)
+	}
+}
+
+func rangeValAddress11() {
+	type v struct {
+		id string
+	}
+	m := map[string]*string{}
+
+	for key, value := range map[string]*v{"a": {id: "A"}, "b": {id: "B"}, "c": {id: "C"}} {
+		m[key] = &value.id
+	}
+}
+
+func rangeValAddress12() {
+	type v struct {
+		id string
+	}
+	m := map[string]*string{}
+
+	for key, value := range map[string]v{"a": {id: "A"}, "b": {id: "B"}, "c": {id: "C"}} {
+		m[key] = &value.id // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}
+
+func rangeValAddress13() {
+	type v struct {
+		id string
+	}
+	m := []*string{}
+
+	otherSlice := map[string]*v{"a": {id: "A"}, "b": {id: "B"}, "c": {id: "C"}}
+	mySlice := otherSlice
+	for _, value := range mySlice {
+		m = append(m, &value.id)
+	}
+}
+
+func rangeValAddress14() {
+	type v struct {
+		id *string
+	}
+
+	m := []v{}
+	for _, value := range []string{"A", "B", "C"} {
+		a := v{id: &value} // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+		m = append(m, a)
+	}
+}
+
+func rangeValAddress15() {
+	type v struct {
+		id *string
+	}
+
+	m := []v{}
+	for _, value := range []string{"A", "B", "C"} {
+		m = append(m, v{id: &value}) // Shall not match /suspicious assignment of 'value'. range-loop variables always have the same address/
+	}
+}