/
file.go
126 lines (115 loc) · 2.29 KB
/
file.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
package matching
func sink(args ...interface{}) {}
func expensive() {}
func multiexpr() (int, int, int) {
sink(1, 1) // want `\Qrepeated expression in list`
_ = []int{0, 1, 1} // want `\Qrepeated expression in list`
_ = []string{
"",
"x", // want `\Qrepeated expression in list`
"x",
"",
"y", "y", // want `\Qrepeated expression in list`
"",
"z",
}
return 1, 1, 0 // want `\Qrepeated expression in list`
}
func rangeClause() {
{
var xs []int
for _, x := range xs[:] { // want `\Qredundant slicing of a range expression`
println(x)
}
for _, x := range xs {
println(x)
}
for i := range xs[:] { // want `\Qredundant slicing of a range expression`
println(i)
}
for i := range xs {
println(i)
}
}
{
var arr [10]int
for _, x := range arr[:] {
println(x)
}
for _, x := range arr {
println(x)
}
for i := range arr[:] {
println(i)
}
for i := range arr {
println(i)
}
}
}
func submatchContains() {
{
type Book struct {
AuthorID int
}
var books []Book
m := make(map[int][]Book)
for _, b := range books {
m[b.AuthorID] = append(m[b.AuthorID], b) // want `\Qm[b.AuthorID] contains b`
}
}
{
var b1 []byte
var b2 []byte
copy(b1, b2)
copy(b1[:], b2) // want `\Qcopy() contains a slicing operation`
copy(b1, b2[:]) // want `\Qcopy() contains a slicing operation`
copy(b1[:], b2[:]) // want `\Qcopy() contains a slicing operation`
}
_ = func() error {
var err error
sink(err) // want `\Qsink(err) call not followed by return err`
return nil
}
_ = func() error {
var err error
sink(err)
return err
}
_ = func() error {
var err2 error
sink(err2) // want `\Qsink(err2) call not followed by return err2`
return nil
}
_ = func() error {
var err2 error
sink(err2)
return err2
}
for { // want `\Qexpensive call inside a loop`
expensive()
}
var cond bool
for { // want `\Qexpensive call inside a loop`
if cond {
expensive()
}
}
for {
if cond {
}
}
for { // want `\Qexpensive call inside a loop`
for { // want `\Qexpensive call inside a loop`
expensive()
}
}
{
type object struct {
val int
}
var objects []object
if objects != nil && objects[0].val != 0 { // want `\Qnil check may not be enough to access objects[0], check for len`
}
}
}