+++ /dev/null
-package simple
-
-import "honnef.co/go/tools/lint"
-
-var Docs = map[string]*lint.Documentation{
- "S1000": {
- Title: `Use plain channel send or receive instead of single-case select`,
- Text: `Select statements with a single case can be replaced with a simple
-send or receive.
-
-Before:
-
- select {
- case x := <-ch:
- fmt.Println(x)
- }
-
-After:
-
- x := <-ch
- fmt.Println(x)`,
- Since: "2017.1",
- },
-
- "S1001": {
- Title: `Replace for loop with call to copy`,
- Text: `Use copy() for copying elements from one slice to another.
-
-Before:
-
- for i, x := range src {
- dst[i] = x
- }
-
-After:
-
- copy(dst, src)`,
- Since: "2017.1",
- },
-
- "S1002": {
- Title: `Omit comparison with boolean constant`,
- Text: `Before:
-
- if x == true {}
-
-After:
-
- if x {}`,
- Since: "2017.1",
- },
-
- "S1003": {
- Title: `Replace call to strings.Index with strings.Contains`,
- Text: `Before:
-
- if strings.Index(x, y) != -1 {}
-
-After:
-
- if strings.Contains(x, y) {}`,
- Since: "2017.1",
- },
-
- "S1004": {
- Title: `Replace call to bytes.Compare with bytes.Equal`,
- Text: `Before:
-
- if bytes.Compare(x, y) == 0 {}
-
-After:
-
- if bytes.Equal(x, y) {}`,
- Since: "2017.1",
- },
-
- "S1005": {
- Title: `Drop unnecessary use of the blank identifier`,
- Text: `In many cases, assigning to the blank identifier is unnecessary.
-
-Before:
-
- for _ = range s {}
- x, _ = someMap[key]
- _ = <-ch
-
-After:
-
- for range s{}
- x = someMap[key]
- <-ch`,
- Since: "2017.1",
- },
-
- "S1006": {
- Title: `Use for { ... } for infinite loops`,
- Text: `For infinite loops, using for { ... } is the most idiomatic choice.`,
- Since: "2017.1",
- },
-
- "S1007": {
- Title: `Simplify regular expression by using raw string literal`,
- Text: `Raw string literals use ` + "`" + ` instead of " and do not support
-any escape sequences. This means that the backslash (\) can be used
-freely, without the need of escaping.
-
-Since regular expressions have their own escape sequences, raw strings
-can improve their readability.
-
-Before:
-
- regexp.Compile("\\A(\\w+) profile: total \\d+\\n\\z")
-
-After:
-
- regexp.Compile(` + "`" + `\A(\w+) profile: total \d+\n\z` + "`" + `)`,
- Since: "2017.1",
- },
-
- "S1008": {
- Title: `Simplify returning boolean expression`,
- Text: `Before:
-
- if <expr> {
- return true
- }
- return false
-
-After:
-
- return <expr>`,
- Since: "2017.1",
- },
-
- "S1009": {
- Title: `Omit redundant nil check on slices`,
- Text: `The len function is defined for all slices, even nil ones, which have
-a length of zero. It is not necessary to check if a slice is not nil
-before checking that its length is not zero.
-
-Before:
-
- if x != nil && len(x) != 0 {}
-
-After:
-
- if len(x) != 0 {}`,
- Since: "2017.1",
- },
-
- "S1010": {
- Title: `Omit default slice index`,
- Text: `When slicing, the second index defaults to the length of the value,
-making s[n:len(s)] and s[n:] equivalent.`,
- Since: "2017.1",
- },
-
- "S1011": {
- Title: `Use a single append to concatenate two slices`,
- Text: `Before:
-
- for _, e := range y {
- x = append(x, e)
- }
-
-After:
-
- x = append(x, y...)`,
- Since: "2017.1",
- },
-
- "S1012": {
- Title: `Replace time.Now().Sub(x) with time.Since(x)`,
- Text: `The time.Since helper has the same effect as using time.Now().Sub(x)
-but is easier to read.
-
-Before:
-
- time.Now().Sub(x)
-
-After:
-
- time.Since(x)`,
- Since: "2017.1",
- },
-
- "S1016": {
- Title: `Use a type conversion instead of manually copying struct fields`,
- Text: `Two struct types with identical fields can be converted between each
-other. In older versions of Go, the fields had to have identical
-struct tags. Since Go 1.8, however, struct tags are ignored during
-conversions. It is thus not necessary to manually copy every field
-individually.
-
-Before:
-
- var x T1
- y := T2{
- Field1: x.Field1,
- Field2: x.Field2,
- }
-
-After:
-
- var x T1
- y := T2(x)`,
- Since: "2017.1",
- },
-
- "S1017": {
- Title: `Replace manual trimming with strings.TrimPrefix`,
- Text: `Instead of using strings.HasPrefix and manual slicing, use the
-strings.TrimPrefix function. If the string doesn't start with the
-prefix, the original string will be returned. Using strings.TrimPrefix
-reduces complexity, and avoids common bugs, such as off-by-one
-mistakes.
-
-Before:
-
- if strings.HasPrefix(str, prefix) {
- str = str[len(prefix):]
- }
-
-After:
-
- str = strings.TrimPrefix(str, prefix)`,
- Since: "2017.1",
- },
-
- "S1018": {
- Title: `Use copy for sliding elements`,
- Text: `copy() permits using the same source and destination slice, even with
-overlapping ranges. This makes it ideal for sliding elements in a
-slice.
-
-Before:
-
- for i := 0; i < n; i++ {
- bs[i] = bs[offset+i]
- }
-
-After:
-
- copy(bs[:n], bs[offset:])`,
- Since: "2017.1",
- },
-
- "S1019": {
- Title: `Simplify make call by omitting redundant arguments`,
- Text: `The make function has default values for the length and capacity
-arguments. For channels and maps, the length defaults to zero.
-Additionally, for slices the capacity defaults to the length.`,
- Since: "2017.1",
- },
-
- "S1020": {
- Title: `Omit redundant nil check in type assertion`,
- Text: `Before:
-
- if _, ok := i.(T); ok && i != nil {}
-
-After:
-
- if _, ok := i.(T); ok {}`,
- Since: "2017.1",
- },
-
- "S1021": {
- Title: `Merge variable declaration and assignment`,
- Text: `Before:
-
- var x uint
- x = 1
-
-After:
-
- var x uint = 1`,
- Since: "2017.1",
- },
-
- "S1023": {
- Title: `Omit redundant control flow`,
- Text: `Functions that have no return value do not need a return statement as
-the final statement of the function.
-
-Switches in Go do not have automatic fallthrough, unlike languages
-like C. It is not necessary to have a break statement as the final
-statement in a case block.`,
- Since: "2017.1",
- },
-
- "S1024": {
- Title: `Replace x.Sub(time.Now()) with time.Until(x)`,
- Text: `The time.Until helper has the same effect as using x.Sub(time.Now())
-but is easier to read.
-
-Before:
-
- x.Sub(time.Now())
-
-After:
-
- time.Until(x)`,
- Since: "2017.1",
- },
-
- "S1025": {
- Title: `Don't use fmt.Sprintf("%s", x) unnecessarily`,
- Text: `In many instances, there are easier and more efficient ways of getting
-a value's string representation. Whenever a value's underlying type is
-a string already, or the type has a String method, they should be used
-directly.
-
-Given the following shared definitions
-
- type T1 string
- type T2 int
-
- func (T2) String() string { return "Hello, world" }
-
- var x string
- var y T1
- var z T2
-
-we can simplify the following
-
- fmt.Sprintf("%s", x)
- fmt.Sprintf("%s", y)
- fmt.Sprintf("%s", z)
-
-to
-
- x
- string(y)
- z.String()`,
- Since: "2017.1",
- },
-
- "S1028": {
- Title: `Simplify error construction with fmt.Errorf`,
- Text: `Before:
-
- errors.New(fmt.Sprintf(...))
-
-After:
-
- fmt.Errorf(...)`,
- Since: "2017.1",
- },
-
- "S1029": {
- Title: `Range over the string directly`,
- Text: `Ranging over a string will yield byte offsets and runes. If the offset
-isn't used, this is functionally equivalent to converting the string
-to a slice of runes and ranging over that. Ranging directly over the
-string will be more performant, however, as it avoids allocating a new
-slice, the size of which depends on the length of the string.
-
-Before:
-
- for _, r := range []rune(s) {}
-
-After:
-
- for _, r := range s {}`,
- Since: "2017.1",
- },
-
- "S1030": {
- Title: `Use bytes.Buffer.String or bytes.Buffer.Bytes`,
- Text: `bytes.Buffer has both a String and a Bytes method. It is never
-necessary to use string(buf.Bytes()) or []byte(buf.String()) – simply
-use the other method.`,
- Since: "2017.1",
- },
-
- "S1031": {
- Title: `Omit redundant nil check around loop`,
- Text: `You can use range on nil slices and maps, the loop will simply never
-execute. This makes an additional nil check around the loop
-unnecessary.
-
-Before:
-
- if s != nil {
- for _, x := range s {
- ...
- }
- }
-
-After:
-
- for _, x := range s {
- ...
- }`,
- Since: "2017.1",
- },
-
- "S1032": {
- Title: `Use sort.Ints(x), sort.Float64s(x), and sort.Strings(x)`,
- Text: `The sort.Ints, sort.Float64s and sort.Strings functions are easier to
-read than sort.Sort(sort.IntSlice(x)), sort.Sort(sort.Float64Slice(x))
-and sort.Sort(sort.StringSlice(x)).
-
-Before:
-
- sort.Sort(sort.StringSlice(x))
-
-After:
-
- sort.Strings(x)`,
- Since: "2019.1",
- },
-
- "S1033": {
- Title: `Unnecessary guard around call to delete`,
- Text: `Calling delete on a nil map is a no-op.`,
- Since: "2019.2",
- },
-
- "S1034": {
- Title: `Use result of type assertion to simplify cases`,
- Since: "2019.2",
- },
-
- "S1035": {
- Title: `Redundant call to net/http.CanonicalHeaderKey in method call on net/http.Header`,
- Text: `The methods on net/http.Header, namely Add, Del, Get and Set, already
-canonicalize the given header name.`,
- Since: "2020.1",
- },
-
- "S1036": {
- Title: `Unnecessary guard around map access`,
-
- Text: `When accessing a map key that doesn't exist yet, one
-receives a zero value. Often, the zero value is a suitable value, for example when using append or doing integer math.
-
-The following
-
- if _, ok := m["foo"]; ok {
- m["foo"] = append(m["foo"], "bar")
- } else {
- m["foo"] = []string{"bar"}
- }
-
-can be simplified to
-
- m["foo"] = append(m["foo"], "bar")
-
-and
-
- if _, ok := m2["k"]; ok {
- m2["k"] += 4
- } else {
- m2["k"] = 4
- }
-
-can be simplified to
-
- m["k"] += 4
-`,
- Since: "2020.1",
- },
-
- "S1037": {
- Title: `Elaborate way of sleeping`,
- Text: `Using a select statement with a single case receiving
-from the result of time.After is a very elaborate way of sleeping that
-can much simpler be expressed with a simple call to time.Sleep.`,
- Since: "2020.1",
- },
-
- "S1038": {
- Title: "Unnecessarily complex way of printing formatted string",
- Text: `Instead of using fmt.Print(fmt.Sprintf(...)), one can use fmt.Printf(...).`,
- Since: "2020.1",
- },
-
- "S1039": {
- Title: "Unnecessary use of fmt.Sprint",
- Text: `Calling fmt.Sprint with a single string argument is unnecessary and identical to using the string directly.`,
- Since: "2020.1",
- },
-}
projects / dotfiles / .git / blobdiff