From 9463ac154b279b610b38206521ff334d217f8a54 Mon Sep 17 00:00:00 2001 From: "Iskander (Alex) Sharipov" Date: Tue, 7 Dec 2021 19:01:44 +0300 Subject: [PATCH] checkers: add At() for httpNoBody checker (#1164) --- checkers/checkers_test.go | 2 +- checkers/rules/rules.go | 6 +- checkers/rulesdata/rulesdata.go | 1051 ++++++++++++++++--------------- 3 files changed, 532 insertions(+), 527 deletions(-) diff --git a/checkers/checkers_test.go b/checkers/checkers_test.go index a37a0237b..fa2ebb8d1 100644 --- a/checkers/checkers_test.go +++ b/checkers/checkers_test.go @@ -199,7 +199,7 @@ func TestExternal(t *testing.T) { continue } if diff := cmp.Diff(want, have); diff != "" { - t.Errorf("%s output mismatches:\n%s", proj.Name(), diff) + t.Errorf("%s output mismatches (+have -want):\n%s", proj.Name(), diff) continue } } diff --git a/checkers/rules/rules.go b/checkers/rules/rules.go index 841ff42e7..f72842c81 100644 --- a/checkers/rules/rules.go +++ b/checkers/rules/rules.go @@ -118,12 +118,14 @@ func httpNoBody(m dsl.Matcher) { m.Match("http.NewRequest($method, $url, $nil)"). Where(m["nil"].Text == "nil"). Suggest("http.NewRequest($method, $url, http.NoBody)"). - Report("http.NoBody should be preferred to the nil request body") + Report("http.NoBody should be preferred to the nil request body"). + At(m["nil"]) m.Match("http.NewRequestWithContext($ctx, $method, $url, $nil)"). Where(m["nil"].Text == "nil"). Suggest("http.NewRequestWithContext($ctx, $method, $url, http.NoBody)"). - Report("http.NoBody should be preferred to the nil request body") + Report("http.NoBody should be preferred to the nil request body"). + At(m["nil"]) } //doc:summary Detects expressions like []rune(s)[0] that may cause unwanted rune slice allocation diff --git a/checkers/rulesdata/rulesdata.go b/checkers/rulesdata/rulesdata.go index 95b3e715d..469a82393 100644 --- a/checkers/rulesdata/rulesdata.go +++ b/checkers/rulesdata/rulesdata.go @@ -436,28 +436,30 @@ var PrecompiledRules = &ir.File{ ir.FilterExpr{Line: 119, Op: ir.FilterStringOp, Src: "\"nil\"", Value: "nil"}, }, }, + LocationVar: "nil", }, ir.Rule{ - Line: 123, + Line: 124, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 123, Value: "http.NewRequestWithContext($ctx, $method, $url, $nil)"}, + ir.PatternString{Line: 124, Value: "http.NewRequestWithContext($ctx, $method, $url, $nil)"}, }, ReportTemplate: "http.NoBody should be preferred to the nil request body", SuggestTemplate: "http.NewRequestWithContext($ctx, $method, $url, http.NoBody)", WhereExpr: ir.FilterExpr{ - Line: 124, + Line: 125, Op: ir.FilterEqOp, Src: "m[\"nil\"].Text == \"nil\"", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 124, Op: ir.FilterVarTextOp, Src: "m[\"nil\"].Text", Value: "nil"}, - ir.FilterExpr{Line: 124, Op: ir.FilterStringOp, Src: "\"nil\"", Value: "nil"}, + ir.FilterExpr{Line: 125, Op: ir.FilterVarTextOp, Src: "m[\"nil\"].Text", Value: "nil"}, + ir.FilterExpr{Line: 125, Op: ir.FilterStringOp, Src: "\"nil\"", Value: "nil"}, }, }, + LocationVar: "nil", }, }, }, ir.RuleGroup{ - Line: 134, + Line: 136, Name: "preferDecodeRune", MatcherName: "m", DocTags: []string{ @@ -470,25 +472,25 @@ var PrecompiledRules = &ir.File{ DocNote: "See Go issue for details: https://github.com/golang/go/issues/45260", Rules: []ir.Rule{ ir.Rule{ - Line: 135, + Line: 137, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 135, Value: "[]rune($s)[0]"}, + ir.PatternString{Line: 137, Value: "[]rune($s)[0]"}, }, ReportTemplate: "consider replacing $$ with utf8.DecodeRuneInString($s)", WhereExpr: ir.FilterExpr{ - Line: 136, + Line: 138, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 136, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 138, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, }, }, ir.RuleGroup{ - Line: 144, + Line: 146, Name: "sloppyLen", MatcherName: "m", DocTags: []string{ @@ -499,30 +501,30 @@ var PrecompiledRules = &ir.File{ DocAfter: "len(arr) == 0", Rules: []ir.Rule{ ir.Rule{ - Line: 145, + Line: 147, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 145, Value: "len($_) >= 0"}, + ir.PatternString{Line: 147, Value: "len($_) >= 0"}, }, ReportTemplate: "$$ is always true", }, ir.Rule{ - Line: 146, + Line: 148, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 146, Value: "len($_) < 0"}, + ir.PatternString{Line: 148, Value: "len($_) < 0"}, }, ReportTemplate: "$$ is always false", }, ir.Rule{ - Line: 147, + Line: 149, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 147, Value: "len($x) <= 0"}, + ir.PatternString{Line: 149, Value: "len($x) <= 0"}, }, ReportTemplate: "$$ can be len($x) == 0", }, }, }, ir.RuleGroup{ - Line: 154, + Line: 156, Name: "valSwap", MatcherName: "m", DocTags: []string{ @@ -533,16 +535,16 @@ var PrecompiledRules = &ir.File{ DocAfter: "*x, *y = *y, *x", Rules: []ir.Rule{ ir.Rule{ - Line: 155, + Line: 157, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 155, Value: "$tmp := $y; $y = $x; $x = $tmp"}, + ir.PatternString{Line: 157, Value: "$tmp := $y; $y = $x; $x = $tmp"}, }, ReportTemplate: "can re-write as `$y, $x = $x, $y`", }, }, }, ir.RuleGroup{ - Line: 163, + Line: 165, Name: "switchTrue", MatcherName: "m", DocTags: []string{ @@ -553,23 +555,23 @@ var PrecompiledRules = &ir.File{ DocAfter: "switch {...}", Rules: []ir.Rule{ ir.Rule{ - Line: 164, + Line: 166, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 164, Value: "switch true { $*_ }"}, + ir.PatternString{Line: 166, Value: "switch true { $*_ }"}, }, ReportTemplate: "replace 'switch true {}' with 'switch {}'", }, ir.Rule{ - Line: 166, + Line: 168, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 166, Value: "switch $x; true { $*_ }"}, + ir.PatternString{Line: 168, Value: "switch $x; true { $*_ }"}, }, ReportTemplate: "replace 'switch $x; true {}' with 'switch $x; {}'", }, }, }, ir.RuleGroup{ - Line: 174, + Line: 176, Name: "flagDeref", MatcherName: "m", DocTags: []string{ @@ -580,65 +582,65 @@ var PrecompiledRules = &ir.File{ DocAfter: "var b bool; flag.BoolVar(&b, \"b\", false, \"b docs\")", Rules: []ir.Rule{ ir.Rule{ - Line: 175, + Line: 177, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 175, Value: "*flag.Bool($*_)"}, + ir.PatternString{Line: 177, Value: "*flag.Bool($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.BoolVar", }, ir.Rule{ - Line: 176, + Line: 178, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 176, Value: "*flag.Duration($*_)"}, + ir.PatternString{Line: 178, Value: "*flag.Duration($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.DurationVar", }, ir.Rule{ - Line: 177, + Line: 179, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 177, Value: "*flag.Float64($*_)"}, + ir.PatternString{Line: 179, Value: "*flag.Float64($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.Float64Var", }, ir.Rule{ - Line: 178, + Line: 180, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 178, Value: "*flag.Int($*_)"}, + ir.PatternString{Line: 180, Value: "*flag.Int($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.IntVar", }, ir.Rule{ - Line: 179, + Line: 181, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 179, Value: "*flag.Int64($*_)"}, + ir.PatternString{Line: 181, Value: "*flag.Int64($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.Int64Var", }, ir.Rule{ - Line: 180, + Line: 182, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 180, Value: "*flag.String($*_)"}, + ir.PatternString{Line: 182, Value: "*flag.String($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.StringVar", }, ir.Rule{ - Line: 181, + Line: 183, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 181, Value: "*flag.Uint($*_)"}, + ir.PatternString{Line: 183, Value: "*flag.Uint($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.UintVar", }, ir.Rule{ - Line: 182, + Line: 184, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 182, Value: "*flag.Uint64($*_)"}, + ir.PatternString{Line: 184, Value: "*flag.Uint64($*_)"}, }, ReportTemplate: "immediate deref in $$ is most likely an error; consider using flag.Uint64Var", }, }, }, ir.RuleGroup{ - Line: 189, + Line: 191, Name: "emptyStringTest", MatcherName: "m", DocTags: []string{ @@ -650,41 +652,41 @@ var PrecompiledRules = &ir.File{ DocAfter: "s == \"\"", Rules: []ir.Rule{ ir.Rule{ - Line: 190, + Line: 192, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 190, Value: "len($s) != 0"}, + ir.PatternString{Line: 192, Value: "len($s) != 0"}, }, ReportTemplate: "replace `$$` with `$s != \"\"`", WhereExpr: ir.FilterExpr{ - Line: 191, + Line: 193, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 191, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 193, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, ir.Rule{ - Line: 194, + Line: 196, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 194, Value: "len($s) == 0"}, + ir.PatternString{Line: 196, Value: "len($s) == 0"}, }, ReportTemplate: "replace `$$` with `$s == \"\"`", WhereExpr: ir.FilterExpr{ - Line: 195, + Line: 197, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 195, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 197, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, }, }, ir.RuleGroup{ - Line: 203, + Line: 205, Name: "stringXbytes", MatcherName: "m", DocTags: []string{ @@ -695,223 +697,223 @@ var PrecompiledRules = &ir.File{ DocAfter: "copy(b, s)", Rules: []ir.Rule{ ir.Rule{ - Line: 204, + Line: 206, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 204, Value: "copy($_, []byte($s))"}, + ir.PatternString{Line: 206, Value: "copy($_, []byte($s))"}, }, ReportTemplate: "can simplify `[]byte($s)` to `$s`", }, ir.Rule{ - Line: 206, + Line: 208, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 206, Value: "string($b) == \"\""}, + ir.PatternString{Line: 208, Value: "string($b) == \"\""}, }, ReportTemplate: "suggestion: len($b) == 0", SuggestTemplate: "len($b) == 0", WhereExpr: ir.FilterExpr{ - Line: 206, + Line: 208, Op: ir.FilterVarTypeIsOp, Src: "m[\"b\"].Type.Is(`[]byte`)", Value: "b", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 206, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 208, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, }, ir.Rule{ - Line: 207, + Line: 209, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 207, Value: "string($b) != \"\""}, + ir.PatternString{Line: 209, Value: "string($b) != \"\""}, }, ReportTemplate: "suggestion: len($b) != 0", SuggestTemplate: "len($b) != 0", WhereExpr: ir.FilterExpr{ - Line: 207, + Line: 209, Op: ir.FilterVarTypeIsOp, Src: "m[\"b\"].Type.Is(`[]byte`)", Value: "b", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 207, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 209, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, }, ir.Rule{ - Line: 209, + Line: 211, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 209, Value: "len(string($b))"}, + ir.PatternString{Line: 211, Value: "len(string($b))"}, }, ReportTemplate: "suggestion: len($b)", SuggestTemplate: "len($b)", WhereExpr: ir.FilterExpr{ - Line: 209, + Line: 211, Op: ir.FilterVarTypeIsOp, Src: "m[\"b\"].Type.Is(`[]byte`)", Value: "b", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 209, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 211, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, }, ir.Rule{ - Line: 211, + Line: 213, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 211, Value: "string($x) == string($y)"}, + ir.PatternString{Line: 213, Value: "string($x) == string($y)"}, }, ReportTemplate: "suggestion: bytes.Equal($x, $y)", SuggestTemplate: "bytes.Equal($x, $y)", WhereExpr: ir.FilterExpr{ - Line: 212, + Line: 214, Op: ir.FilterAndOp, Src: "m[\"x\"].Type.Is(`[]byte`) && m[\"y\"].Type.Is(`[]byte`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 212, + Line: 214, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`[]byte`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 212, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 214, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, ir.FilterExpr{ - Line: 212, + Line: 214, Op: ir.FilterVarTypeIsOp, Src: "m[\"y\"].Type.Is(`[]byte`)", Value: "y", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 212, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 214, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, }, }, }, ir.Rule{ - Line: 215, + Line: 217, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 215, Value: "string($x) != string($y)"}, + ir.PatternString{Line: 217, Value: "string($x) != string($y)"}, }, ReportTemplate: "suggestion: !bytes.Equal($x, $y)", SuggestTemplate: "!bytes.Equal($x, $y)", WhereExpr: ir.FilterExpr{ - Line: 216, + Line: 218, Op: ir.FilterAndOp, Src: "m[\"x\"].Type.Is(`[]byte`) && m[\"y\"].Type.Is(`[]byte`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 216, + Line: 218, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`[]byte`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 216, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 218, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, ir.FilterExpr{ - Line: 216, + Line: 218, Op: ir.FilterVarTypeIsOp, Src: "m[\"y\"].Type.Is(`[]byte`)", Value: "y", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 216, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, + ir.FilterExpr{Line: 218, Op: ir.FilterStringOp, Src: "`[]byte`", Value: "[]byte"}, }, }, }, }, }, ir.Rule{ - Line: 219, + Line: 221, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 219, Value: "$re.Match([]byte($s))"}, + ir.PatternString{Line: 221, Value: "$re.Match([]byte($s))"}, }, ReportTemplate: "suggestion: $re.MatchString($s)", SuggestTemplate: "$re.MatchString($s)", WhereExpr: ir.FilterExpr{ - Line: 220, + Line: 222, Op: ir.FilterAndOp, Src: "m[\"re\"].Type.Is(`*regexp.Regexp`) && m[\"s\"].Type.Is(`string`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 220, + Line: 222, Op: ir.FilterVarTypeIsOp, Src: "m[\"re\"].Type.Is(`*regexp.Regexp`)", Value: "re", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 220, Op: ir.FilterStringOp, Src: "`*regexp.Regexp`", Value: "*regexp.Regexp"}, + ir.FilterExpr{Line: 222, Op: ir.FilterStringOp, Src: "`*regexp.Regexp`", Value: "*regexp.Regexp"}, }, }, ir.FilterExpr{ - Line: 220, + Line: 222, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 220, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 222, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, }, }, ir.Rule{ - Line: 223, + Line: 225, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 223, Value: "$re.FindIndex([]byte($s))"}, + ir.PatternString{Line: 225, Value: "$re.FindIndex([]byte($s))"}, }, ReportTemplate: "suggestion: $re.FindStringIndex($s)", SuggestTemplate: "$re.FindStringIndex($s)", WhereExpr: ir.FilterExpr{ - Line: 224, + Line: 226, Op: ir.FilterAndOp, Src: "m[\"re\"].Type.Is(`*regexp.Regexp`) && m[\"s\"].Type.Is(`string`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 224, + Line: 226, Op: ir.FilterVarTypeIsOp, Src: "m[\"re\"].Type.Is(`*regexp.Regexp`)", Value: "re", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 224, Op: ir.FilterStringOp, Src: "`*regexp.Regexp`", Value: "*regexp.Regexp"}, + ir.FilterExpr{Line: 226, Op: ir.FilterStringOp, Src: "`*regexp.Regexp`", Value: "*regexp.Regexp"}, }, }, ir.FilterExpr{ - Line: 224, + Line: 226, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 224, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 226, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, }, }, ir.Rule{ - Line: 227, + Line: 229, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 227, Value: "$re.FindAllIndex([]byte($s), $n)"}, + ir.PatternString{Line: 229, Value: "$re.FindAllIndex([]byte($s), $n)"}, }, ReportTemplate: "suggestion: $re.FindAllStringIndex($s, $n)", SuggestTemplate: "$re.FindAllStringIndex($s, $n)", WhereExpr: ir.FilterExpr{ - Line: 228, + Line: 230, Op: ir.FilterAndOp, Src: "m[\"re\"].Type.Is(`*regexp.Regexp`) && m[\"s\"].Type.Is(`string`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 228, + Line: 230, Op: ir.FilterVarTypeIsOp, Src: "m[\"re\"].Type.Is(`*regexp.Regexp`)", Value: "re", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 228, Op: ir.FilterStringOp, Src: "`*regexp.Regexp`", Value: "*regexp.Regexp"}, + ir.FilterExpr{Line: 230, Op: ir.FilterStringOp, Src: "`*regexp.Regexp`", Value: "*regexp.Regexp"}, }, }, ir.FilterExpr{ - Line: 228, + Line: 230, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 228, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 230, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, @@ -920,7 +922,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 237, + Line: 239, Name: "indexAlloc", MatcherName: "m", DocTags: []string{ @@ -932,25 +934,25 @@ var PrecompiledRules = &ir.File{ DocNote: "See Go issue for details: https://github.com/golang/go/issues/25864", Rules: []ir.Rule{ ir.Rule{ - Line: 238, + Line: 240, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 238, Value: "strings.Index(string($x), $y)"}, + ir.PatternString{Line: 240, Value: "strings.Index(string($x), $y)"}, }, ReportTemplate: "consider replacing $$ with bytes.Index($x, []byte($y))", WhereExpr: ir.FilterExpr{ - Line: 239, + Line: 241, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 239, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, - ir.FilterExpr{Line: 239, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, + ir.FilterExpr{Line: 241, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + ir.FilterExpr{Line: 241, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, }, }, }, }, }, ir.RuleGroup{ - Line: 247, + Line: 249, Name: "wrapperFunc", MatcherName: "m", DocTags: []string{ @@ -961,111 +963,111 @@ var PrecompiledRules = &ir.File{ DocAfter: "wg.Done()", Rules: []ir.Rule{ ir.Rule{ - Line: 248, + Line: 250, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 248, Value: "$wg.Add(-1)"}, + ir.PatternString{Line: 250, Value: "$wg.Add(-1)"}, }, ReportTemplate: "use WaitGroup.Done method in `$$`", WhereExpr: ir.FilterExpr{ - Line: 249, + Line: 251, Op: ir.FilterVarTypeIsOp, Src: "m[\"wg\"].Type.Is(`sync.WaitGroup`)", Value: "wg", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 249, Op: ir.FilterStringOp, Src: "`sync.WaitGroup`", Value: "sync.WaitGroup"}, + ir.FilterExpr{Line: 251, Op: ir.FilterStringOp, Src: "`sync.WaitGroup`", Value: "sync.WaitGroup"}, }, }, }, ir.Rule{ - Line: 252, + Line: 254, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 252, Value: "$buf.Truncate(0)"}, + ir.PatternString{Line: 254, Value: "$buf.Truncate(0)"}, }, ReportTemplate: "use Buffer.Reset method in `$$`", WhereExpr: ir.FilterExpr{ - Line: 253, + Line: 255, Op: ir.FilterVarTypeIsOp, Src: "m[\"buf\"].Type.Is(`bytes.Buffer`)", Value: "buf", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 253, Op: ir.FilterStringOp, Src: "`bytes.Buffer`", Value: "bytes.Buffer"}, + ir.FilterExpr{Line: 255, Op: ir.FilterStringOp, Src: "`bytes.Buffer`", Value: "bytes.Buffer"}, }, }, }, ir.Rule{ - Line: 256, + Line: 258, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 256, Value: "http.HandlerFunc(http.NotFound)"}, + ir.PatternString{Line: 258, Value: "http.HandlerFunc(http.NotFound)"}, }, ReportTemplate: "use http.NotFoundHandler method in `$$`", }, ir.Rule{ - Line: 258, + Line: 260, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 258, Value: "strings.SplitN($_, $_, -1)"}, + ir.PatternString{Line: 260, Value: "strings.SplitN($_, $_, -1)"}, }, ReportTemplate: "use strings.Split method in `$$`", }, ir.Rule{ - Line: 259, + Line: 261, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 259, Value: "strings.Replace($_, $_, $_, -1)"}, + ir.PatternString{Line: 261, Value: "strings.Replace($_, $_, $_, -1)"}, }, ReportTemplate: "use strings.ReplaceAll method in `$$`", }, ir.Rule{ - Line: 260, + Line: 262, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 260, Value: "strings.Map(unicode.ToTitle, $_)"}, + ir.PatternString{Line: 262, Value: "strings.Map(unicode.ToTitle, $_)"}, }, ReportTemplate: "use strings.ToTitle method in `$$`", }, ir.Rule{ - Line: 262, + Line: 264, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 262, Value: "bytes.SplitN(b, []byte(\".\"), -1)"}, + ir.PatternString{Line: 264, Value: "bytes.SplitN(b, []byte(\".\"), -1)"}, }, ReportTemplate: "use bytes.Split method in `$$`", }, ir.Rule{ - Line: 263, + Line: 265, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 263, Value: "bytes.Replace($_, $_, $_, -1)"}, + ir.PatternString{Line: 265, Value: "bytes.Replace($_, $_, $_, -1)"}, }, ReportTemplate: "use bytes.ReplaceAll method in `$$`", }, ir.Rule{ - Line: 264, + Line: 266, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 264, Value: "bytes.Map(unicode.ToUpper, $_)"}, + ir.PatternString{Line: 266, Value: "bytes.Map(unicode.ToUpper, $_)"}, }, ReportTemplate: "use bytes.ToUpper method in `$$`", }, ir.Rule{ - Line: 265, + Line: 267, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 265, Value: "bytes.Map(unicode.ToLower, $_)"}, + ir.PatternString{Line: 267, Value: "bytes.Map(unicode.ToLower, $_)"}, }, ReportTemplate: "use bytes.ToLower method in `$$`", }, ir.Rule{ - Line: 266, + Line: 268, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 266, Value: "bytes.Map(unicode.ToTitle, $_)"}, + ir.PatternString{Line: 268, Value: "bytes.Map(unicode.ToTitle, $_)"}, }, ReportTemplate: "use bytes.ToTitle method in `$$`", }, ir.Rule{ - Line: 268, + Line: 270, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 268, Value: "draw.DrawMask($_, $_, $_, $_, nil, image.Point{}, $_)"}, + ir.PatternString{Line: 270, Value: "draw.DrawMask($_, $_, $_, $_, nil, image.Point{}, $_)"}, }, ReportTemplate: "use draw.Draw method in `$$`", }, }, }, ir.RuleGroup{ - Line: 276, + Line: 278, Name: "regexpMust", MatcherName: "m", DocTags: []string{ @@ -1076,26 +1078,26 @@ var PrecompiledRules = &ir.File{ DocAfter: "re := regexp.MustCompile(\"const pattern\")", Rules: []ir.Rule{ ir.Rule{ - Line: 277, + Line: 279, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 277, Value: "regexp.Compile($pat)"}, + ir.PatternString{Line: 279, Value: "regexp.Compile($pat)"}, }, ReportTemplate: "for const patterns like $pat, use regexp.MustCompile", WhereExpr: ir.FilterExpr{ - Line: 278, + Line: 280, Op: ir.FilterVarConstOp, Src: "m[\"pat\"].Const", Value: "pat", }, }, ir.Rule{ - Line: 281, + Line: 283, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 281, Value: "regexp.CompilePOSIX($pat)"}, + ir.PatternString{Line: 283, Value: "regexp.CompilePOSIX($pat)"}, }, ReportTemplate: "for const patterns like $pat, use regexp.MustCompilePOSIX", WhereExpr: ir.FilterExpr{ - Line: 282, + Line: 284, Op: ir.FilterVarConstOp, Src: "m[\"pat\"].Const", Value: "pat", @@ -1104,7 +1106,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 290, + Line: 292, Name: "badCall", MatcherName: "m", DocTags: []string{ @@ -1115,24 +1117,24 @@ var PrecompiledRules = &ir.File{ DocAfter: "strings.Replace(s, from, to, -1)", Rules: []ir.Rule{ ir.Rule{ - Line: 291, + Line: 293, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 291, Value: "strings.Replace($_, $_, $_, $zero)"}, + ir.PatternString{Line: 293, Value: "strings.Replace($_, $_, $_, $zero)"}, }, ReportTemplate: "suspicious arg 0, probably meant -1", WhereExpr: ir.FilterExpr{ - Line: 292, + Line: 294, Op: ir.FilterEqOp, Src: "m[\"zero\"].Value.Int() == 0", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 292, + Line: 294, Op: ir.FilterVarValueIntOp, Src: "m[\"zero\"].Value.Int()", Value: "zero", }, ir.FilterExpr{ - Line: 292, + Line: 294, Op: ir.FilterIntOp, Src: "0", Value: int64(0), @@ -1142,24 +1144,24 @@ var PrecompiledRules = &ir.File{ LocationVar: "zero", }, ir.Rule{ - Line: 294, + Line: 296, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 294, Value: "bytes.Replace($_, $_, $_, $zero)"}, + ir.PatternString{Line: 296, Value: "bytes.Replace($_, $_, $_, $zero)"}, }, ReportTemplate: "suspicious arg 0, probably meant -1", WhereExpr: ir.FilterExpr{ - Line: 295, + Line: 297, Op: ir.FilterEqOp, Src: "m[\"zero\"].Value.Int() == 0", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 295, + Line: 297, Op: ir.FilterVarValueIntOp, Src: "m[\"zero\"].Value.Int()", Value: "zero", }, ir.FilterExpr{ - Line: 295, + Line: 297, Op: ir.FilterIntOp, Src: "0", Value: int64(0), @@ -1169,24 +1171,24 @@ var PrecompiledRules = &ir.File{ LocationVar: "zero", }, ir.Rule{ - Line: 298, + Line: 300, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 298, Value: "strings.SplitN($_, $_, $zero)"}, + ir.PatternString{Line: 300, Value: "strings.SplitN($_, $_, $zero)"}, }, ReportTemplate: "suspicious arg 0, probably meant -1", WhereExpr: ir.FilterExpr{ - Line: 299, + Line: 301, Op: ir.FilterEqOp, Src: "m[\"zero\"].Value.Int() == 0", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 299, + Line: 301, Op: ir.FilterVarValueIntOp, Src: "m[\"zero\"].Value.Int()", Value: "zero", }, ir.FilterExpr{ - Line: 299, + Line: 301, Op: ir.FilterIntOp, Src: "0", Value: int64(0), @@ -1196,24 +1198,24 @@ var PrecompiledRules = &ir.File{ LocationVar: "zero", }, ir.Rule{ - Line: 301, + Line: 303, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 301, Value: "bytes.SplitN($_, $_, $zero)"}, + ir.PatternString{Line: 303, Value: "bytes.SplitN($_, $_, $zero)"}, }, ReportTemplate: "suspicious arg 0, probably meant -1", WhereExpr: ir.FilterExpr{ - Line: 302, + Line: 304, Op: ir.FilterEqOp, Src: "m[\"zero\"].Value.Int() == 0", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 302, + Line: 304, Op: ir.FilterVarValueIntOp, Src: "m[\"zero\"].Value.Int()", Value: "zero", }, ir.FilterExpr{ - Line: 302, + Line: 304, Op: ir.FilterIntOp, Src: "0", Value: int64(0), @@ -1223,23 +1225,23 @@ var PrecompiledRules = &ir.File{ LocationVar: "zero", }, ir.Rule{ - Line: 305, + Line: 307, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 305, Value: "append($_)"}, + ir.PatternString{Line: 307, Value: "append($_)"}, }, ReportTemplate: "no-op append call, probably missing arguments", }, ir.Rule{ - Line: 307, + Line: 309, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 307, Value: "filepath.Join($_)"}, + ir.PatternString{Line: 309, Value: "filepath.Join($_)"}, }, ReportTemplate: "suspicious Join on 1 argument", }, }, }, ir.RuleGroup{ - Line: 314, + Line: 316, Name: "assignOp", MatcherName: "m", DocTags: []string{ @@ -1250,113 +1252,113 @@ var PrecompiledRules = &ir.File{ DocAfter: "x *= 2", Rules: []ir.Rule{ ir.Rule{ - Line: 315, + Line: 317, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 315, Value: "$x = $x + 1"}, + ir.PatternString{Line: 317, Value: "$x = $x + 1"}, }, ReportTemplate: "replace `$$` with `$x++`", - WhereExpr: ir.FilterExpr{Line: 315, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 317, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 316, + Line: 318, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 316, Value: "$x = $x - 1"}, + ir.PatternString{Line: 318, Value: "$x = $x - 1"}, }, ReportTemplate: "replace `$$` with `$x--`", - WhereExpr: ir.FilterExpr{Line: 316, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 318, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 318, + Line: 320, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 318, Value: "$x = $x + $y"}, + ir.PatternString{Line: 320, Value: "$x = $x + $y"}, }, ReportTemplate: "replace `$$` with `$x += $y`", - WhereExpr: ir.FilterExpr{Line: 318, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 320, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 319, + Line: 321, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 319, Value: "$x = $x - $y"}, + ir.PatternString{Line: 321, Value: "$x = $x - $y"}, }, ReportTemplate: "replace `$$` with `$x -= $y`", - WhereExpr: ir.FilterExpr{Line: 319, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 321, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 321, + Line: 323, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 321, Value: "$x = $x * $y"}, + ir.PatternString{Line: 323, Value: "$x = $x * $y"}, }, ReportTemplate: "replace `$$` with `$x *= $y`", - WhereExpr: ir.FilterExpr{Line: 321, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 323, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 322, + Line: 324, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 322, Value: "$x = $x / $y"}, + ir.PatternString{Line: 324, Value: "$x = $x / $y"}, }, ReportTemplate: "replace `$$` with `$x /= $y`", - WhereExpr: ir.FilterExpr{Line: 322, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 324, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 323, + Line: 325, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 323, Value: "$x = $x % $y"}, + ir.PatternString{Line: 325, Value: "$x = $x % $y"}, }, ReportTemplate: "replace `$$` with `$x %= $y`", - WhereExpr: ir.FilterExpr{Line: 323, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 325, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 324, + Line: 326, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 324, Value: "$x = $x & $y"}, + ir.PatternString{Line: 326, Value: "$x = $x & $y"}, }, ReportTemplate: "replace `$$` with `$x &= $y`", - WhereExpr: ir.FilterExpr{Line: 324, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 326, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 325, + Line: 327, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 325, Value: "$x = $x | $y"}, + ir.PatternString{Line: 327, Value: "$x = $x | $y"}, }, ReportTemplate: "replace `$$` with `$x |= $y`", - WhereExpr: ir.FilterExpr{Line: 325, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 327, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 326, + Line: 328, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 326, Value: "$x = $x ^ $y"}, + ir.PatternString{Line: 328, Value: "$x = $x ^ $y"}, }, ReportTemplate: "replace `$$` with `$x ^= $y`", - WhereExpr: ir.FilterExpr{Line: 326, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 328, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 327, + Line: 329, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 327, Value: "$x = $x << $y"}, + ir.PatternString{Line: 329, Value: "$x = $x << $y"}, }, ReportTemplate: "replace `$$` with `$x <<= $y`", - WhereExpr: ir.FilterExpr{Line: 327, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 329, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 328, + Line: 330, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 328, Value: "$x = $x >> $y"}, + ir.PatternString{Line: 330, Value: "$x = $x >> $y"}, }, ReportTemplate: "replace `$$` with `$x >>= $y`", - WhereExpr: ir.FilterExpr{Line: 328, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 330, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, ir.Rule{ - Line: 329, + Line: 331, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 329, Value: "$x = $x &^ $y"}, + ir.PatternString{Line: 331, Value: "$x = $x &^ $y"}, }, ReportTemplate: "replace `$$` with `$x &^= $y`", - WhereExpr: ir.FilterExpr{Line: 329, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 331, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, }, }, ir.RuleGroup{ - Line: 336, + Line: 338, Name: "preferWriteByte", MatcherName: "m", DocTags: []string{ @@ -1369,49 +1371,49 @@ var PrecompiledRules = &ir.File{ DocAfter: "w.WriteByte('\\n')", Rules: []ir.Rule{ ir.Rule{ - Line: 340, + Line: 342, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 340, Value: "$w.WriteRune($c)"}, + ir.PatternString{Line: 342, Value: "$w.WriteRune($c)"}, }, ReportTemplate: "consider writing single byte rune $c with $w.WriteByte($c)", WhereExpr: ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterAndOp, Src: "m[\"w\"].Type.Implements(\"io.ByteWriter\") && (m[\"c\"].Const && m[\"c\"].Value.Int() < runeSelf)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterVarTypeImplementsOp, Src: "m[\"w\"].Type.Implements(\"io.ByteWriter\")", Value: "w", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 341, Op: ir.FilterStringOp, Src: "\"io.ByteWriter\"", Value: "io.ByteWriter"}, + ir.FilterExpr{Line: 343, Op: ir.FilterStringOp, Src: "\"io.ByteWriter\"", Value: "io.ByteWriter"}, }, }, ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterAndOp, Src: "(m[\"c\"].Const && m[\"c\"].Value.Int() < runeSelf)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterVarConstOp, Src: "m[\"c\"].Const", Value: "c", }, ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterLtOp, Src: "m[\"c\"].Value.Int() < runeSelf", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterVarValueIntOp, Src: "m[\"c\"].Value.Int()", Value: "c", }, ir.FilterExpr{ - Line: 341, + Line: 343, Op: ir.FilterIntOp, Src: "runeSelf", Value: int64(128), @@ -1426,7 +1428,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 349, + Line: 351, Name: "preferFprint", MatcherName: "m", DocTags: []string{ @@ -1438,60 +1440,60 @@ var PrecompiledRules = &ir.File{ DocAfter: "fmt.Fprintf(w, \"%x\", 10)", Rules: []ir.Rule{ ir.Rule{ - Line: 350, + Line: 352, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 350, Value: "$w.Write([]byte(fmt.Sprint($*args)))"}, + ir.PatternString{Line: 352, Value: "$w.Write([]byte(fmt.Sprint($*args)))"}, }, ReportTemplate: "fmt.Fprint($w, $args) should be preferred to the $$", SuggestTemplate: "fmt.Fprint($w, $args)", WhereExpr: ir.FilterExpr{ - Line: 351, + Line: 353, Op: ir.FilterVarTypeImplementsOp, Src: "m[\"w\"].Type.Implements(\"io.Writer\")", Value: "w", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 351, Op: ir.FilterStringOp, Src: "\"io.Writer\"", Value: "io.Writer"}, + ir.FilterExpr{Line: 353, Op: ir.FilterStringOp, Src: "\"io.Writer\"", Value: "io.Writer"}, }, }, }, ir.Rule{ - Line: 355, + Line: 357, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 355, Value: "$w.Write([]byte(fmt.Sprintf($*args)))"}, + ir.PatternString{Line: 357, Value: "$w.Write([]byte(fmt.Sprintf($*args)))"}, }, ReportTemplate: "fmt.Fprintf($w, $args) should be preferred to the $$", SuggestTemplate: "fmt.Fprintf($w, $args)", WhereExpr: ir.FilterExpr{ - Line: 356, + Line: 358, Op: ir.FilterVarTypeImplementsOp, Src: "m[\"w\"].Type.Implements(\"io.Writer\")", Value: "w", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 356, Op: ir.FilterStringOp, Src: "\"io.Writer\"", Value: "io.Writer"}, + ir.FilterExpr{Line: 358, Op: ir.FilterStringOp, Src: "\"io.Writer\"", Value: "io.Writer"}, }, }, }, ir.Rule{ - Line: 360, + Line: 362, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 360, Value: "$w.Write([]byte(fmt.Sprintln($*args)))"}, + ir.PatternString{Line: 362, Value: "$w.Write([]byte(fmt.Sprintln($*args)))"}, }, ReportTemplate: "fmt.Fprintln($w, $args) should be preferred to the $$", SuggestTemplate: "fmt.Fprintln($w, $args)", WhereExpr: ir.FilterExpr{ - Line: 361, + Line: 363, Op: ir.FilterVarTypeImplementsOp, Src: "m[\"w\"].Type.Implements(\"io.Writer\")", Value: "w", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 361, Op: ir.FilterStringOp, Src: "\"io.Writer\"", Value: "io.Writer"}, + ir.FilterExpr{Line: 363, Op: ir.FilterStringOp, Src: "\"io.Writer\"", Value: "io.Writer"}, }, }, }, }, }, ir.RuleGroup{ - Line: 370, + Line: 372, Name: "dupArg", MatcherName: "m", DocTags: []string{ @@ -1502,62 +1504,62 @@ var PrecompiledRules = &ir.File{ DocAfter: "copy(dst, src)", Rules: []ir.Rule{ ir.Rule{ - Line: 371, + Line: 373, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 371, Value: "$x.Equal($x)"}, - ir.PatternString{Line: 371, Value: "$x.Equals($x)"}, - ir.PatternString{Line: 371, Value: "$x.Compare($x)"}, - ir.PatternString{Line: 371, Value: "$x.Cmp($x)"}, + ir.PatternString{Line: 373, Value: "$x.Equal($x)"}, + ir.PatternString{Line: 373, Value: "$x.Equals($x)"}, + ir.PatternString{Line: 373, Value: "$x.Compare($x)"}, + ir.PatternString{Line: 373, Value: "$x.Cmp($x)"}, }, ReportTemplate: "suspicious method call with the same argument and receiver", - WhereExpr: ir.FilterExpr{Line: 372, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, - }, - ir.Rule{ - Line: 375, - SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 375, Value: "copy($x, $x)"}, - ir.PatternString{Line: 376, Value: "math.Max($x, $x)"}, - ir.PatternString{Line: 377, Value: "math.Min($x, $x)"}, - ir.PatternString{Line: 378, Value: "reflect.Copy($x, $x)"}, - ir.PatternString{Line: 379, Value: "reflect.DeepEqual($x, $x)"}, - ir.PatternString{Line: 380, Value: "strings.Contains($x, $x)"}, - ir.PatternString{Line: 381, Value: "strings.Compare($x, $x)"}, - ir.PatternString{Line: 382, Value: "strings.EqualFold($x, $x)"}, - ir.PatternString{Line: 383, Value: "strings.HasPrefix($x, $x)"}, - ir.PatternString{Line: 384, Value: "strings.HasSuffix($x, $x)"}, - ir.PatternString{Line: 385, Value: "strings.Index($x, $x)"}, - ir.PatternString{Line: 386, Value: "strings.LastIndex($x, $x)"}, - ir.PatternString{Line: 387, Value: "strings.Split($x, $x)"}, - ir.PatternString{Line: 388, Value: "strings.SplitAfter($x, $x)"}, - ir.PatternString{Line: 389, Value: "strings.SplitAfterN($x, $x, $_)"}, - ir.PatternString{Line: 390, Value: "strings.SplitN($x, $x, $_)"}, - ir.PatternString{Line: 391, Value: "strings.Replace($_, $x, $x, $_)"}, - ir.PatternString{Line: 392, Value: "strings.ReplaceAll($_, $x, $x)"}, - ir.PatternString{Line: 393, Value: "bytes.Contains($x, $x)"}, - ir.PatternString{Line: 394, Value: "bytes.Compare($x, $x)"}, - ir.PatternString{Line: 395, Value: "bytes.Equal($x, $x)"}, - ir.PatternString{Line: 396, Value: "bytes.EqualFold($x, $x)"}, - ir.PatternString{Line: 397, Value: "bytes.HasPrefix($x, $x)"}, - ir.PatternString{Line: 398, Value: "bytes.HasSuffix($x, $x)"}, - ir.PatternString{Line: 399, Value: "bytes.Index($x, $x)"}, - ir.PatternString{Line: 400, Value: "bytes.LastIndex($x, $x)"}, - ir.PatternString{Line: 401, Value: "bytes.Split($x, $x)"}, - ir.PatternString{Line: 402, Value: "bytes.SplitAfter($x, $x)"}, - ir.PatternString{Line: 403, Value: "bytes.SplitAfterN($x, $x, $_)"}, - ir.PatternString{Line: 404, Value: "bytes.SplitN($x, $x, $_)"}, - ir.PatternString{Line: 405, Value: "bytes.Replace($_, $x, $x, $_)"}, - ir.PatternString{Line: 406, Value: "bytes.ReplaceAll($_, $x, $x)"}, - ir.PatternString{Line: 407, Value: "types.Identical($x, $x)"}, - ir.PatternString{Line: 408, Value: "types.IdenticalIgnoreTags($x, $x)"}, - ir.PatternString{Line: 409, Value: "draw.Draw($x, $_, $x, $_, $_)"}, + WhereExpr: ir.FilterExpr{Line: 374, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + }, + ir.Rule{ + Line: 377, + SyntaxPatterns: []ir.PatternString{ + ir.PatternString{Line: 377, Value: "copy($x, $x)"}, + ir.PatternString{Line: 378, Value: "math.Max($x, $x)"}, + ir.PatternString{Line: 379, Value: "math.Min($x, $x)"}, + ir.PatternString{Line: 380, Value: "reflect.Copy($x, $x)"}, + ir.PatternString{Line: 381, Value: "reflect.DeepEqual($x, $x)"}, + ir.PatternString{Line: 382, Value: "strings.Contains($x, $x)"}, + ir.PatternString{Line: 383, Value: "strings.Compare($x, $x)"}, + ir.PatternString{Line: 384, Value: "strings.EqualFold($x, $x)"}, + ir.PatternString{Line: 385, Value: "strings.HasPrefix($x, $x)"}, + ir.PatternString{Line: 386, Value: "strings.HasSuffix($x, $x)"}, + ir.PatternString{Line: 387, Value: "strings.Index($x, $x)"}, + ir.PatternString{Line: 388, Value: "strings.LastIndex($x, $x)"}, + ir.PatternString{Line: 389, Value: "strings.Split($x, $x)"}, + ir.PatternString{Line: 390, Value: "strings.SplitAfter($x, $x)"}, + ir.PatternString{Line: 391, Value: "strings.SplitAfterN($x, $x, $_)"}, + ir.PatternString{Line: 392, Value: "strings.SplitN($x, $x, $_)"}, + ir.PatternString{Line: 393, Value: "strings.Replace($_, $x, $x, $_)"}, + ir.PatternString{Line: 394, Value: "strings.ReplaceAll($_, $x, $x)"}, + ir.PatternString{Line: 395, Value: "bytes.Contains($x, $x)"}, + ir.PatternString{Line: 396, Value: "bytes.Compare($x, $x)"}, + ir.PatternString{Line: 397, Value: "bytes.Equal($x, $x)"}, + ir.PatternString{Line: 398, Value: "bytes.EqualFold($x, $x)"}, + ir.PatternString{Line: 399, Value: "bytes.HasPrefix($x, $x)"}, + ir.PatternString{Line: 400, Value: "bytes.HasSuffix($x, $x)"}, + ir.PatternString{Line: 401, Value: "bytes.Index($x, $x)"}, + ir.PatternString{Line: 402, Value: "bytes.LastIndex($x, $x)"}, + ir.PatternString{Line: 403, Value: "bytes.Split($x, $x)"}, + ir.PatternString{Line: 404, Value: "bytes.SplitAfter($x, $x)"}, + ir.PatternString{Line: 405, Value: "bytes.SplitAfterN($x, $x, $_)"}, + ir.PatternString{Line: 406, Value: "bytes.SplitN($x, $x, $_)"}, + ir.PatternString{Line: 407, Value: "bytes.Replace($_, $x, $x, $_)"}, + ir.PatternString{Line: 408, Value: "bytes.ReplaceAll($_, $x, $x)"}, + ir.PatternString{Line: 409, Value: "types.Identical($x, $x)"}, + ir.PatternString{Line: 410, Value: "types.IdenticalIgnoreTags($x, $x)"}, + ir.PatternString{Line: 411, Value: "draw.Draw($x, $_, $x, $_, $_)"}, }, ReportTemplate: "suspicious duplicated args in $$", - WhereExpr: ir.FilterExpr{Line: 410, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + WhereExpr: ir.FilterExpr{Line: 412, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, }, }, }, ir.RuleGroup{ - Line: 418, + Line: 420, Name: "returnAfterHttpError", MatcherName: "m", DocTags: []string{ @@ -1569,9 +1571,9 @@ var PrecompiledRules = &ir.File{ DocAfter: "if err != nil { http.Error(...); return; }", Rules: []ir.Rule{ ir.Rule{ - Line: 419, + Line: 421, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 419, Value: "if $_ { $*_; http.Error($w, $err, $code) }"}, + ir.PatternString{Line: 421, Value: "if $_ { $*_; http.Error($w, $err, $code) }"}, }, ReportTemplate: "Possibly return is missed after the http.Error call", LocationVar: "w", @@ -1579,7 +1581,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 428, + Line: 430, Name: "preferFilepathJoin", MatcherName: "m", DocTags: []string{ @@ -1591,33 +1593,33 @@ var PrecompiledRules = &ir.File{ DocAfter: "filepath.Join(x, y)", Rules: []ir.Rule{ ir.Rule{ - Line: 429, + Line: 431, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 429, Value: "$x + string(os.PathSeparator) + $y"}, + ir.PatternString{Line: 431, Value: "$x + string(os.PathSeparator) + $y"}, }, ReportTemplate: "filepath.Join($x, $y) should be preferred to the $$", SuggestTemplate: "filepath.Join($x, $y)", WhereExpr: ir.FilterExpr{ - Line: 430, + Line: 432, Op: ir.FilterAndOp, Src: "m[\"x\"].Type.Is(`string`) && m[\"y\"].Type.Is(`string`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 430, + Line: 432, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`string`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 430, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 432, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, ir.FilterExpr{ - Line: 430, + Line: 432, Op: ir.FilterVarTypeIsOp, Src: "m[\"y\"].Type.Is(`string`)", Value: "y", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 430, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 432, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, }, @@ -1626,7 +1628,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 439, + Line: 441, Name: "preferStringWriter", MatcherName: "m", DocTags: []string{ @@ -1638,43 +1640,43 @@ var PrecompiledRules = &ir.File{ DocAfter: "w.WriteString(\"foo\")", Rules: []ir.Rule{ ir.Rule{ - Line: 440, + Line: 442, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 440, Value: "$w.Write([]byte($s))"}, + ir.PatternString{Line: 442, Value: "$w.Write([]byte($s))"}, }, ReportTemplate: "$w.WriteString($s) should be preferred to the $$", SuggestTemplate: "$w.WriteString($s)", WhereExpr: ir.FilterExpr{ - Line: 441, + Line: 443, Op: ir.FilterVarTypeImplementsOp, Src: "m[\"w\"].Type.Implements(\"io.StringWriter\")", Value: "w", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 441, Op: ir.FilterStringOp, Src: "\"io.StringWriter\"", Value: "io.StringWriter"}, + ir.FilterExpr{Line: 443, Op: ir.FilterStringOp, Src: "\"io.StringWriter\"", Value: "io.StringWriter"}, }, }, }, ir.Rule{ - Line: 445, + Line: 447, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 445, Value: "io.WriteString($w, $s)"}, + ir.PatternString{Line: 447, Value: "io.WriteString($w, $s)"}, }, ReportTemplate: "$w.WriteString($s) should be preferred to the $$", SuggestTemplate: "$w.WriteString($s)", WhereExpr: ir.FilterExpr{ - Line: 446, + Line: 448, Op: ir.FilterVarTypeImplementsOp, Src: "m[\"w\"].Type.Implements(\"io.StringWriter\")", Value: "w", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 446, Op: ir.FilterStringOp, Src: "\"io.StringWriter\"", Value: "io.StringWriter"}, + ir.FilterExpr{Line: 448, Op: ir.FilterStringOp, Src: "\"io.StringWriter\"", Value: "io.StringWriter"}, }, }, }, }, }, ir.RuleGroup{ - Line: 455, + Line: 457, Name: "sliceClear", MatcherName: "m", DocTags: []string{ @@ -1686,24 +1688,24 @@ var PrecompiledRules = &ir.File{ DocAfter: "for i := range buf { buf[i] = 0 }", Rules: []ir.Rule{ ir.Rule{ - Line: 456, + Line: 458, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 456, Value: "for $i := 0; $i < len($xs); $i++ { $xs[$i] = $zero }"}, + ir.PatternString{Line: 458, Value: "for $i := 0; $i < len($xs); $i++ { $xs[$i] = $zero }"}, }, ReportTemplate: "rewrite as for-range so compiler can recognize this pattern", WhereExpr: ir.FilterExpr{ - Line: 457, + Line: 459, Op: ir.FilterEqOp, Src: "m[\"zero\"].Value.Int() == 0", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 457, + Line: 459, Op: ir.FilterVarValueIntOp, Src: "m[\"zero\"].Value.Int()", Value: "zero", }, ir.FilterExpr{ - Line: 457, + Line: 459, Op: ir.FilterIntOp, Src: "0", Value: int64(0), @@ -1714,7 +1716,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 465, + Line: 467, Name: "syncMapLoadAndDelete", MatcherName: "m", DocTags: []string{ @@ -1726,29 +1728,29 @@ var PrecompiledRules = &ir.File{ DocAfter: "v, deleted := m.LoadAndDelete(k); if deleted { f(v) }", Rules: []ir.Rule{ ir.Rule{ - Line: 466, + Line: 468, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 466, Value: "$_, $ok := $m.Load($k); if $ok { $m.Delete($k); $*_ }"}, + ir.PatternString{Line: 468, Value: "$_, $ok := $m.Load($k); if $ok { $m.Delete($k); $*_ }"}, }, ReportTemplate: "use $m.LoadAndDelete to perform load+delete operations atomically", WhereExpr: ir.FilterExpr{ - Line: 467, + Line: 469, Op: ir.FilterAndOp, Src: "m.GoVersion().GreaterEqThan(\"1.15\") &&\n\tm[\"m\"].Type.Is(`*sync.Map`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 467, + Line: 469, Op: ir.FilterGoVersionGreaterEqThanOp, Src: "m.GoVersion().GreaterEqThan(\"1.15\")", Value: "1.15", }, ir.FilterExpr{ - Line: 468, + Line: 470, Op: ir.FilterVarTypeIsOp, Src: "m[\"m\"].Type.Is(`*sync.Map`)", Value: "m", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 468, Op: ir.FilterStringOp, Src: "`*sync.Map`", Value: "*sync.Map"}, + ir.FilterExpr{Line: 470, Op: ir.FilterStringOp, Src: "`*sync.Map`", Value: "*sync.Map"}, }, }, }, @@ -1757,7 +1759,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 476, + Line: 478, Name: "sprintfQuotedString", MatcherName: "m", DocTags: []string{ @@ -1769,32 +1771,32 @@ var PrecompiledRules = &ir.File{ DocAfter: "fmt.Sprintf(`%q`, s)", Rules: []ir.Rule{ ir.Rule{ - Line: 477, + Line: 479, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 477, Value: "fmt.Sprintf($s, $*_)"}, + ir.PatternString{Line: 479, Value: "fmt.Sprintf($s, $*_)"}, }, ReportTemplate: "use %q instead of \"%s\" for quoted strings", WhereExpr: ir.FilterExpr{ - Line: 478, + Line: 480, Op: ir.FilterOrOp, Src: "m[\"s\"].Text.Matches(\"^`.*\\\"%s\\\".*`$\") ||\n\tm[\"s\"].Text.Matches(`^\".*\\\\\"%s\\\\\".*\"$`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 478, + Line: 480, Op: ir.FilterVarTextMatchesOp, Src: "m[\"s\"].Text.Matches(\"^`.*\\\"%s\\\".*`$\")", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 478, Op: ir.FilterStringOp, Src: "\"^`.*\\\"%s\\\".*`$\"", Value: "^`.*\"%s\".*`$"}, + ir.FilterExpr{Line: 480, Op: ir.FilterStringOp, Src: "\"^`.*\\\"%s\\\".*`$\"", Value: "^`.*\"%s\".*`$"}, }, }, ir.FilterExpr{ - Line: 479, + Line: 481, Op: ir.FilterVarTextMatchesOp, Src: "m[\"s\"].Text.Matches(`^\".*\\\\\"%s\\\\\".*\"$`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 479, Op: ir.FilterStringOp, Src: "`^\".*\\\\\"%s\\\\\".*\"$`", Value: "^\".*\\\\\"%s\\\\\".*\"$"}, + ir.FilterExpr{Line: 481, Op: ir.FilterStringOp, Src: "`^\".*\\\\\"%s\\\\\".*\"$`", Value: "^\".*\\\\\"%s\\\\\".*\"$"}, }, }, }, @@ -1803,7 +1805,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 487, + Line: 489, Name: "offBy1", MatcherName: "m", DocTags: []string{ @@ -1814,84 +1816,84 @@ var PrecompiledRules = &ir.File{ DocAfter: "xs[len(xs)-1]", Rules: []ir.Rule{ ir.Rule{ - Line: 488, + Line: 490, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 488, Value: "$x[len($x)]"}, + ir.PatternString{Line: 490, Value: "$x[len($x)]"}, }, ReportTemplate: "index expr always panics; maybe you wanted $x[len($x)-1]?", SuggestTemplate: "$x[len($x)-1]", WhereExpr: ir.FilterExpr{ - Line: 489, + Line: 491, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"x\"].Type.Is(`[]$_`)", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 489, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + ir.FilterExpr{Line: 491, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, ir.FilterExpr{ - Line: 489, + Line: 491, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`[]$_`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 489, Op: ir.FilterStringOp, Src: "`[]$_`", Value: "[]$_"}, + ir.FilterExpr{Line: 491, Op: ir.FilterStringOp, Src: "`[]$_`", Value: "[]$_"}, }, }, }, }, }, ir.Rule{ - Line: 496, + Line: 498, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 497, Value: "$i := strings.Index($s, $_); $_ := $slicing[$i:]"}, - ir.PatternString{Line: 498, Value: "$i := strings.Index($s, $_); $_ = $slicing[$i:]"}, - ir.PatternString{Line: 499, Value: "$i := bytes.Index($s, $_); $_ := $slicing[$i:]"}, - ir.PatternString{Line: 500, Value: "$i := bytes.Index($s, $_); $_ = $slicing[$i:]"}, + ir.PatternString{Line: 499, Value: "$i := strings.Index($s, $_); $_ := $slicing[$i:]"}, + ir.PatternString{Line: 500, Value: "$i := strings.Index($s, $_); $_ = $slicing[$i:]"}, + ir.PatternString{Line: 501, Value: "$i := bytes.Index($s, $_); $_ := $slicing[$i:]"}, + ir.PatternString{Line: 502, Value: "$i := bytes.Index($s, $_); $_ = $slicing[$i:]"}, }, ReportTemplate: "Index() can return -1; maybe you wanted to do $s[$i+1:]", WhereExpr: ir.FilterExpr{ - Line: 501, + Line: 503, Op: ir.FilterEqOp, Src: "m[\"s\"].Text == m[\"slicing\"].Text", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 501, Op: ir.FilterVarTextOp, Src: "m[\"s\"].Text", Value: "s"}, - ir.FilterExpr{Line: 501, Op: ir.FilterVarTextOp, Src: "m[\"slicing\"].Text", Value: "slicing"}, + ir.FilterExpr{Line: 503, Op: ir.FilterVarTextOp, Src: "m[\"s\"].Text", Value: "s"}, + ir.FilterExpr{Line: 503, Op: ir.FilterVarTextOp, Src: "m[\"slicing\"].Text", Value: "slicing"}, }, }, LocationVar: "slicing", }, ir.Rule{ - Line: 505, + Line: 507, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 506, Value: "$i := strings.Index($s, $_); $_ := $slicing[:$i]"}, - ir.PatternString{Line: 507, Value: "$i := strings.Index($s, $_); $_ = $slicing[:$i]"}, - ir.PatternString{Line: 508, Value: "$i := bytes.Index($s, $_); $_ := $slicing[:$i]"}, - ir.PatternString{Line: 509, Value: "$i := bytes.Index($s, $_); $_ = $slicing[:$i]"}, + ir.PatternString{Line: 508, Value: "$i := strings.Index($s, $_); $_ := $slicing[:$i]"}, + ir.PatternString{Line: 509, Value: "$i := strings.Index($s, $_); $_ = $slicing[:$i]"}, + ir.PatternString{Line: 510, Value: "$i := bytes.Index($s, $_); $_ := $slicing[:$i]"}, + ir.PatternString{Line: 511, Value: "$i := bytes.Index($s, $_); $_ = $slicing[:$i]"}, }, ReportTemplate: "Index() can return -1; maybe you wanted to do $s[:$i+1]", WhereExpr: ir.FilterExpr{ - Line: 510, + Line: 512, Op: ir.FilterEqOp, Src: "m[\"s\"].Text == m[\"slicing\"].Text", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 510, Op: ir.FilterVarTextOp, Src: "m[\"s\"].Text", Value: "s"}, - ir.FilterExpr{Line: 510, Op: ir.FilterVarTextOp, Src: "m[\"slicing\"].Text", Value: "slicing"}, + ir.FilterExpr{Line: 512, Op: ir.FilterVarTextOp, Src: "m[\"s\"].Text", Value: "s"}, + ir.FilterExpr{Line: 512, Op: ir.FilterVarTextOp, Src: "m[\"slicing\"].Text", Value: "slicing"}, }, }, LocationVar: "slicing", }, ir.Rule{ - Line: 514, + Line: 516, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 515, Value: "$s[strings.Index($s, $_):]"}, - ir.PatternString{Line: 516, Value: "$s[:strings.Index($s, $_)]"}, - ir.PatternString{Line: 517, Value: "$s[bytes.Index($s, $_):]"}, - ir.PatternString{Line: 518, Value: "$s[:bytes.Index($s, $_)]"}, + ir.PatternString{Line: 517, Value: "$s[strings.Index($s, $_):]"}, + ir.PatternString{Line: 518, Value: "$s[:strings.Index($s, $_)]"}, + ir.PatternString{Line: 519, Value: "$s[bytes.Index($s, $_):]"}, + ir.PatternString{Line: 520, Value: "$s[:bytes.Index($s, $_)]"}, }, ReportTemplate: "Index() can return -1; maybe you wanted to do Index()+1", }, }, }, ir.RuleGroup{ - Line: 526, + Line: 528, Name: "unslice", MatcherName: "m", DocTags: []string{ @@ -1902,33 +1904,33 @@ var PrecompiledRules = &ir.File{ DocAfter: "copy(b, values...)", Rules: []ir.Rule{ ir.Rule{ - Line: 527, + Line: 529, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 527, Value: "$s[:]"}, + ir.PatternString{Line: 529, Value: "$s[:]"}, }, ReportTemplate: "could simplify $$ to $s", SuggestTemplate: "$s", WhereExpr: ir.FilterExpr{ - Line: 528, + Line: 530, Op: ir.FilterOrOp, Src: "m[\"s\"].Type.Is(`string`) || m[\"s\"].Type.Is(`[]$_`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 528, + Line: 530, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`string`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 528, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, + ir.FilterExpr{Line: 530, Op: ir.FilterStringOp, Src: "`string`", Value: "string"}, }, }, ir.FilterExpr{ - Line: 528, + Line: 530, Op: ir.FilterVarTypeIsOp, Src: "m[\"s\"].Type.Is(`[]$_`)", Value: "s", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 528, Op: ir.FilterStringOp, Src: "`[]$_`", Value: "[]$_"}, + ir.FilterExpr{Line: 530, Op: ir.FilterStringOp, Src: "`[]$_`", Value: "[]$_"}, }, }, }, @@ -1937,7 +1939,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 537, + Line: 539, Name: "yodaStyleExpr", MatcherName: "m", DocTags: []string{ @@ -1949,37 +1951,37 @@ var PrecompiledRules = &ir.File{ DocAfter: "return ptr != nil", Rules: []ir.Rule{ ir.Rule{ - Line: 538, + Line: 540, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 538, Value: "$constval != $x"}, + ir.PatternString{Line: 540, Value: "$constval != $x"}, }, ReportTemplate: "consider to change order in expression to $x != $constval", WhereExpr: ir.FilterExpr{ - Line: 538, + Line: 540, Op: ir.FilterAndOp, Src: "m[\"constval\"].Node.Is(`BasicLit`) && !m[\"x\"].Node.Is(`BasicLit`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 538, + Line: 540, Op: ir.FilterVarNodeIsOp, Src: "m[\"constval\"].Node.Is(`BasicLit`)", Value: "constval", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 538, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, + ir.FilterExpr{Line: 540, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, }, }, ir.FilterExpr{ - Line: 538, + Line: 540, Op: ir.FilterNotOp, Src: "!m[\"x\"].Node.Is(`BasicLit`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 538, + Line: 540, Op: ir.FilterVarNodeIsOp, Src: "m[\"x\"].Node.Is(`BasicLit`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 538, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, + ir.FilterExpr{Line: 540, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, }, }, }, @@ -1988,37 +1990,37 @@ var PrecompiledRules = &ir.File{ }, }, ir.Rule{ - Line: 540, + Line: 542, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 540, Value: "$constval == $x"}, + ir.PatternString{Line: 542, Value: "$constval == $x"}, }, ReportTemplate: "consider to change order in expression to $x == $constval", WhereExpr: ir.FilterExpr{ - Line: 540, + Line: 542, Op: ir.FilterAndOp, Src: "m[\"constval\"].Node.Is(`BasicLit`) && !m[\"x\"].Node.Is(`BasicLit`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 540, + Line: 542, Op: ir.FilterVarNodeIsOp, Src: "m[\"constval\"].Node.Is(`BasicLit`)", Value: "constval", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 540, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, + ir.FilterExpr{Line: 542, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, }, }, ir.FilterExpr{ - Line: 540, + Line: 542, Op: ir.FilterNotOp, Src: "!m[\"x\"].Node.Is(`BasicLit`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 540, + Line: 542, Op: ir.FilterVarNodeIsOp, Src: "m[\"x\"].Node.Is(`BasicLit`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 540, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, + ir.FilterExpr{Line: 542, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, }, }, }, @@ -2027,46 +2029,46 @@ var PrecompiledRules = &ir.File{ }, }, ir.Rule{ - Line: 543, + Line: 545, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 543, Value: "nil != $x"}, + ir.PatternString{Line: 545, Value: "nil != $x"}, }, ReportTemplate: "consider to change order in expression to $x != nil", WhereExpr: ir.FilterExpr{ - Line: 543, + Line: 545, Op: ir.FilterNotOp, Src: "!m[\"x\"].Node.Is(`BasicLit`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 543, + Line: 545, Op: ir.FilterVarNodeIsOp, Src: "m[\"x\"].Node.Is(`BasicLit`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 543, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, + ir.FilterExpr{Line: 545, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, }, }, }, }, }, ir.Rule{ - Line: 545, + Line: 547, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 545, Value: "nil == $x"}, + ir.PatternString{Line: 547, Value: "nil == $x"}, }, ReportTemplate: "consider to change order in expression to $x == nil", WhereExpr: ir.FilterExpr{ - Line: 545, + Line: 547, Op: ir.FilterNotOp, Src: "!m[\"x\"].Node.Is(`BasicLit`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 545, + Line: 547, Op: ir.FilterVarNodeIsOp, Src: "m[\"x\"].Node.Is(`BasicLit`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 545, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, + ir.FilterExpr{Line: 547, Op: ir.FilterStringOp, Src: "`BasicLit`", Value: "BasicLit"}, }, }, }, @@ -2075,7 +2077,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 553, + Line: 555, Name: "equalFold", MatcherName: "m", DocTags: []string{ @@ -2087,114 +2089,114 @@ var PrecompiledRules = &ir.File{ DocAfter: "strings.EqualFold(x, y)", Rules: []ir.Rule{ ir.Rule{ - Line: 562, + Line: 564, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 563, Value: "strings.ToLower($x) == $y"}, - ir.PatternString{Line: 564, Value: "strings.ToLower($x) == strings.ToLower($y)"}, - ir.PatternString{Line: 565, Value: "$x == strings.ToLower($y)"}, - ir.PatternString{Line: 566, Value: "strings.ToUpper($x) == $y"}, - ir.PatternString{Line: 567, Value: "strings.ToUpper($x) == strings.ToUpper($y)"}, - ir.PatternString{Line: 568, Value: "$x == strings.ToUpper($y)"}, + ir.PatternString{Line: 565, Value: "strings.ToLower($x) == $y"}, + ir.PatternString{Line: 566, Value: "strings.ToLower($x) == strings.ToLower($y)"}, + ir.PatternString{Line: 567, Value: "$x == strings.ToLower($y)"}, + ir.PatternString{Line: 568, Value: "strings.ToUpper($x) == $y"}, + ir.PatternString{Line: 569, Value: "strings.ToUpper($x) == strings.ToUpper($y)"}, + ir.PatternString{Line: 570, Value: "$x == strings.ToUpper($y)"}, }, ReportTemplate: "consider replacing with strings.EqualFold($x, $y)", SuggestTemplate: "strings.EqualFold($x, $y)]", WhereExpr: ir.FilterExpr{ - Line: 569, + Line: 571, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure && m[\"x\"].Text != m[\"y\"].Text", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 569, + Line: 571, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 569, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, - ir.FilterExpr{Line: 569, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, + ir.FilterExpr{Line: 571, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + ir.FilterExpr{Line: 571, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, }, }, ir.FilterExpr{ - Line: 569, + Line: 571, Op: ir.FilterNeqOp, Src: "m[\"x\"].Text != m[\"y\"].Text", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 569, Op: ir.FilterVarTextOp, Src: "m[\"x\"].Text", Value: "x"}, - ir.FilterExpr{Line: 569, Op: ir.FilterVarTextOp, Src: "m[\"y\"].Text", Value: "y"}, + ir.FilterExpr{Line: 571, Op: ir.FilterVarTextOp, Src: "m[\"x\"].Text", Value: "x"}, + ir.FilterExpr{Line: 571, Op: ir.FilterVarTextOp, Src: "m[\"y\"].Text", Value: "y"}, }, }, }, }, }, ir.Rule{ - Line: 574, + Line: 576, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 575, Value: "strings.ToLower($x) != $y"}, - ir.PatternString{Line: 576, Value: "strings.ToLower($x) != strings.ToLower($y)"}, - ir.PatternString{Line: 577, Value: "$x != strings.ToLower($y)"}, - ir.PatternString{Line: 578, Value: "strings.ToUpper($x) != $y"}, - ir.PatternString{Line: 579, Value: "strings.ToUpper($x) != strings.ToUpper($y)"}, - ir.PatternString{Line: 580, Value: "$x != strings.ToUpper($y)"}, + ir.PatternString{Line: 577, Value: "strings.ToLower($x) != $y"}, + ir.PatternString{Line: 578, Value: "strings.ToLower($x) != strings.ToLower($y)"}, + ir.PatternString{Line: 579, Value: "$x != strings.ToLower($y)"}, + ir.PatternString{Line: 580, Value: "strings.ToUpper($x) != $y"}, + ir.PatternString{Line: 581, Value: "strings.ToUpper($x) != strings.ToUpper($y)"}, + ir.PatternString{Line: 582, Value: "$x != strings.ToUpper($y)"}, }, ReportTemplate: "consider replacing with !strings.EqualFold($x, $y)", SuggestTemplate: "!strings.EqualFold($x, $y)]", WhereExpr: ir.FilterExpr{ - Line: 581, + Line: 583, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure && m[\"x\"].Text != m[\"y\"].Text", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 581, + Line: 583, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 581, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, - ir.FilterExpr{Line: 581, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, + ir.FilterExpr{Line: 583, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + ir.FilterExpr{Line: 583, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, }, }, ir.FilterExpr{ - Line: 581, + Line: 583, Op: ir.FilterNeqOp, Src: "m[\"x\"].Text != m[\"y\"].Text", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 581, Op: ir.FilterVarTextOp, Src: "m[\"x\"].Text", Value: "x"}, - ir.FilterExpr{Line: 581, Op: ir.FilterVarTextOp, Src: "m[\"y\"].Text", Value: "y"}, + ir.FilterExpr{Line: 583, Op: ir.FilterVarTextOp, Src: "m[\"x\"].Text", Value: "x"}, + ir.FilterExpr{Line: 583, Op: ir.FilterVarTextOp, Src: "m[\"y\"].Text", Value: "y"}, }, }, }, }, }, ir.Rule{ - Line: 586, + Line: 588, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 587, Value: "bytes.Equal(bytes.ToLower($x), $y)"}, - ir.PatternString{Line: 588, Value: "bytes.Equal(bytes.ToLower($x), bytes.ToLower($y))"}, - ir.PatternString{Line: 589, Value: "bytes.Equal($x, bytes.ToLower($y))"}, - ir.PatternString{Line: 590, Value: "bytes.Equal(bytes.ToUpper($x), $y)"}, - ir.PatternString{Line: 591, Value: "bytes.Equal(bytes.ToUpper($x), bytes.ToUpper($y))"}, - ir.PatternString{Line: 592, Value: "bytes.Equal($x, bytes.ToUpper($y))"}, + ir.PatternString{Line: 589, Value: "bytes.Equal(bytes.ToLower($x), $y)"}, + ir.PatternString{Line: 590, Value: "bytes.Equal(bytes.ToLower($x), bytes.ToLower($y))"}, + ir.PatternString{Line: 591, Value: "bytes.Equal($x, bytes.ToLower($y))"}, + ir.PatternString{Line: 592, Value: "bytes.Equal(bytes.ToUpper($x), $y)"}, + ir.PatternString{Line: 593, Value: "bytes.Equal(bytes.ToUpper($x), bytes.ToUpper($y))"}, + ir.PatternString{Line: 594, Value: "bytes.Equal($x, bytes.ToUpper($y))"}, }, ReportTemplate: "consider replacing with bytes.EqualFold($x, $y)", SuggestTemplate: "bytes.EqualFold($x, $y)]", WhereExpr: ir.FilterExpr{ - Line: 593, + Line: 595, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure && m[\"x\"].Text != m[\"y\"].Text", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 593, + Line: 595, Op: ir.FilterAndOp, Src: "m[\"x\"].Pure && m[\"y\"].Pure", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 593, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, - ir.FilterExpr{Line: 593, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, + ir.FilterExpr{Line: 595, Op: ir.FilterVarPureOp, Src: "m[\"x\"].Pure", Value: "x"}, + ir.FilterExpr{Line: 595, Op: ir.FilterVarPureOp, Src: "m[\"y\"].Pure", Value: "y"}, }, }, ir.FilterExpr{ - Line: 593, + Line: 595, Op: ir.FilterNeqOp, Src: "m[\"x\"].Text != m[\"y\"].Text", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 593, Op: ir.FilterVarTextOp, Src: "m[\"x\"].Text", Value: "x"}, - ir.FilterExpr{Line: 593, Op: ir.FilterVarTextOp, Src: "m[\"y\"].Text", Value: "y"}, + ir.FilterExpr{Line: 595, Op: ir.FilterVarTextOp, Src: "m[\"x\"].Text", Value: "x"}, + ir.FilterExpr{Line: 595, Op: ir.FilterVarTextOp, Src: "m[\"y\"].Text", Value: "y"}, }, }, }, @@ -2203,7 +2205,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 602, + Line: 604, Name: "argOrder", MatcherName: "m", DocTags: []string{ @@ -2214,45 +2216,45 @@ var PrecompiledRules = &ir.File{ DocAfter: "strings.HasPrefix(userpass, \"#\")", Rules: []ir.Rule{ ir.Rule{ - Line: 603, - SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 604, Value: "strings.HasPrefix($lit, $s)"}, - ir.PatternString{Line: 605, Value: "bytes.HasPrefix($lit, $s)"}, - ir.PatternString{Line: 606, Value: "strings.HasSuffix($lit, $s)"}, - ir.PatternString{Line: 607, Value: "bytes.HasSuffix($lit, $s)"}, - ir.PatternString{Line: 608, Value: "strings.Contains($lit, $s)"}, - ir.PatternString{Line: 609, Value: "bytes.Contains($lit, $s)"}, - ir.PatternString{Line: 610, Value: "strings.TrimPrefix($lit, $s)"}, - ir.PatternString{Line: 611, Value: "bytes.TrimPrefix($lit, $s)"}, - ir.PatternString{Line: 612, Value: "strings.TrimSuffix($lit, $s)"}, - ir.PatternString{Line: 613, Value: "bytes.TrimSuffix($lit, $s)"}, - ir.PatternString{Line: 614, Value: "strings.Split($lit, $s)"}, - ir.PatternString{Line: 615, Value: "bytes.Split($lit, $s)"}, + Line: 605, + SyntaxPatterns: []ir.PatternString{ + ir.PatternString{Line: 606, Value: "strings.HasPrefix($lit, $s)"}, + ir.PatternString{Line: 607, Value: "bytes.HasPrefix($lit, $s)"}, + ir.PatternString{Line: 608, Value: "strings.HasSuffix($lit, $s)"}, + ir.PatternString{Line: 609, Value: "bytes.HasSuffix($lit, $s)"}, + ir.PatternString{Line: 610, Value: "strings.Contains($lit, $s)"}, + ir.PatternString{Line: 611, Value: "bytes.Contains($lit, $s)"}, + ir.PatternString{Line: 612, Value: "strings.TrimPrefix($lit, $s)"}, + ir.PatternString{Line: 613, Value: "bytes.TrimPrefix($lit, $s)"}, + ir.PatternString{Line: 614, Value: "strings.TrimSuffix($lit, $s)"}, + ir.PatternString{Line: 615, Value: "bytes.TrimSuffix($lit, $s)"}, + ir.PatternString{Line: 616, Value: "strings.Split($lit, $s)"}, + ir.PatternString{Line: 617, Value: "bytes.Split($lit, $s)"}, }, ReportTemplate: "$lit and $s arguments order looks reversed", WhereExpr: ir.FilterExpr{ - Line: 616, + Line: 618, Op: ir.FilterAndOp, Src: "(m[\"lit\"].Const || m[\"lit\"].ConstSlice) &&\n\t!(m[\"s\"].Const || m[\"s\"].ConstSlice) &&\n\t!m[\"lit\"].Node.Is(`Ident`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 616, + Line: 618, Op: ir.FilterAndOp, Src: "(m[\"lit\"].Const || m[\"lit\"].ConstSlice) &&\n\t!(m[\"s\"].Const || m[\"s\"].ConstSlice)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 616, + Line: 618, Op: ir.FilterOrOp, Src: "(m[\"lit\"].Const || m[\"lit\"].ConstSlice)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 616, + Line: 618, Op: ir.FilterVarConstOp, Src: "m[\"lit\"].Const", Value: "lit", }, ir.FilterExpr{ - Line: 616, + Line: 618, Op: ir.FilterVarConstSliceOp, Src: "m[\"lit\"].ConstSlice", Value: "lit", @@ -2260,23 +2262,23 @@ var PrecompiledRules = &ir.File{ }, }, ir.FilterExpr{ - Line: 617, + Line: 619, Op: ir.FilterNotOp, Src: "!(m[\"s\"].Const || m[\"s\"].ConstSlice)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 617, + Line: 619, Op: ir.FilterOrOp, Src: "(m[\"s\"].Const || m[\"s\"].ConstSlice)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 617, + Line: 619, Op: ir.FilterVarConstOp, Src: "m[\"s\"].Const", Value: "s", }, ir.FilterExpr{ - Line: 617, + Line: 619, Op: ir.FilterVarConstSliceOp, Src: "m[\"s\"].ConstSlice", Value: "s", @@ -2288,17 +2290,17 @@ var PrecompiledRules = &ir.File{ }, }, ir.FilterExpr{ - Line: 618, + Line: 620, Op: ir.FilterNotOp, Src: "!m[\"lit\"].Node.Is(`Ident`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 618, + Line: 620, Op: ir.FilterVarNodeIsOp, Src: "m[\"lit\"].Node.Is(`Ident`)", Value: "lit", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 618, Op: ir.FilterStringOp, Src: "`Ident`", Value: "Ident"}, + ir.FilterExpr{Line: 620, Op: ir.FilterStringOp, Src: "`Ident`", Value: "Ident"}, }, }, }, @@ -2309,7 +2311,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 626, + Line: 628, Name: "stringConcatSimplify", MatcherName: "m", DocTags: []string{ @@ -2321,25 +2323,25 @@ var PrecompiledRules = &ir.File{ DocAfter: "x + \"_\" + y", Rules: []ir.Rule{ ir.Rule{ - Line: 627, + Line: 629, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 627, Value: "strings.Join([]string{$x, $y}, \"\")"}, + ir.PatternString{Line: 629, Value: "strings.Join([]string{$x, $y}, \"\")"}, }, ReportTemplate: "suggestion: $x + $y", SuggestTemplate: "$x + $y", }, ir.Rule{ - Line: 628, + Line: 630, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 628, Value: "strings.Join([]string{$x, $y, $z}, \"\")"}, + ir.PatternString{Line: 630, Value: "strings.Join([]string{$x, $y, $z}, \"\")"}, }, ReportTemplate: "suggestion: $x + $y + $z", SuggestTemplate: "$x + $y + $z", }, ir.Rule{ - Line: 629, + Line: 631, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 629, Value: "strings.Join([]string{$x, $y}, $glue)"}, + ir.PatternString{Line: 631, Value: "strings.Join([]string{$x, $y}, $glue)"}, }, ReportTemplate: "suggestion: $x + $glue + $y", SuggestTemplate: "$x + $glue + $y", @@ -2347,7 +2349,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 636, + Line: 638, Name: "timeExprSimplify", MatcherName: "m", DocTags: []string{ @@ -2359,44 +2361,44 @@ var PrecompiledRules = &ir.File{ DocAfter: "t.UnixMilli()", Rules: []ir.Rule{ ir.Rule{ - Line: 637, + Line: 639, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 637, Value: "$t.Unix() / 1000"}, + ir.PatternString{Line: 639, Value: "$t.Unix() / 1000"}, }, ReportTemplate: "use $t.UnixMilli() instead of $$", SuggestTemplate: "$t.UnixMilli()", WhereExpr: ir.FilterExpr{ - Line: 638, + Line: 640, Op: ir.FilterAndOp, Src: "m.GoVersion().GreaterEqThan(\"1.17\") &&\n\t(m[\"t\"].Type.Is(`time.Time`) || m[\"t\"].Type.Is(`*time.Time`))", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 638, + Line: 640, Op: ir.FilterGoVersionGreaterEqThanOp, Src: "m.GoVersion().GreaterEqThan(\"1.17\")", Value: "1.17", }, ir.FilterExpr{ - Line: 639, + Line: 641, Op: ir.FilterOrOp, Src: "(m[\"t\"].Type.Is(`time.Time`) || m[\"t\"].Type.Is(`*time.Time`))", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 639, + Line: 641, Op: ir.FilterVarTypeIsOp, Src: "m[\"t\"].Type.Is(`time.Time`)", Value: "t", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 639, Op: ir.FilterStringOp, Src: "`time.Time`", Value: "time.Time"}, + ir.FilterExpr{Line: 641, Op: ir.FilterStringOp, Src: "`time.Time`", Value: "time.Time"}, }, }, ir.FilterExpr{ - Line: 639, + Line: 641, Op: ir.FilterVarTypeIsOp, Src: "m[\"t\"].Type.Is(`*time.Time`)", Value: "t", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 639, Op: ir.FilterStringOp, Src: "`*time.Time`", Value: "*time.Time"}, + ir.FilterExpr{Line: 641, Op: ir.FilterStringOp, Src: "`*time.Time`", Value: "*time.Time"}, }, }, }, @@ -2405,44 +2407,44 @@ var PrecompiledRules = &ir.File{ }, }, ir.Rule{ - Line: 643, + Line: 645, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 643, Value: "$t.UnixNano() * 1000"}, + ir.PatternString{Line: 645, Value: "$t.UnixNano() * 1000"}, }, ReportTemplate: "use $t.UnixMicro() instead of $$", SuggestTemplate: "$t.UnixMicro()", WhereExpr: ir.FilterExpr{ - Line: 644, + Line: 646, Op: ir.FilterAndOp, Src: "m.GoVersion().GreaterEqThan(\"1.17\") &&\n\t(m[\"t\"].Type.Is(`time.Time`) || m[\"t\"].Type.Is(`*time.Time`))", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 644, + Line: 646, Op: ir.FilterGoVersionGreaterEqThanOp, Src: "m.GoVersion().GreaterEqThan(\"1.17\")", Value: "1.17", }, ir.FilterExpr{ - Line: 645, + Line: 647, Op: ir.FilterOrOp, Src: "(m[\"t\"].Type.Is(`time.Time`) || m[\"t\"].Type.Is(`*time.Time`))", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 645, + Line: 647, Op: ir.FilterVarTypeIsOp, Src: "m[\"t\"].Type.Is(`time.Time`)", Value: "t", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 645, Op: ir.FilterStringOp, Src: "`time.Time`", Value: "time.Time"}, + ir.FilterExpr{Line: 647, Op: ir.FilterStringOp, Src: "`time.Time`", Value: "time.Time"}, }, }, ir.FilterExpr{ - Line: 645, + Line: 647, Op: ir.FilterVarTypeIsOp, Src: "m[\"t\"].Type.Is(`*time.Time`)", Value: "t", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 645, Op: ir.FilterStringOp, Src: "`*time.Time`", Value: "*time.Time"}, + ir.FilterExpr{Line: 647, Op: ir.FilterStringOp, Src: "`*time.Time`", Value: "*time.Time"}, }, }, }, @@ -2453,7 +2455,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 654, + Line: 656, Name: "exposedSyncMutex", MatcherName: "m", DocTags: []string{ @@ -2465,73 +2467,73 @@ var PrecompiledRules = &ir.File{ DocAfter: "type Foo struct{ ...; mu sync.Mutex; ... }", Rules: []ir.Rule{ ir.Rule{ - Line: 655, + Line: 657, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 655, Value: "type $x struct { $*_; sync.Mutex; $*_ }"}, + ir.PatternString{Line: 657, Value: "type $x struct { $*_; sync.Mutex; $*_ }"}, }, ReportTemplate: "don't embed sync.Mutex", WhereExpr: ir.FilterExpr{ - Line: 656, + Line: 658, Op: ir.FilterVarTextMatchesOp, Src: "m[\"x\"].Text.Matches(`^\\p{Lu}`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 656, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, + ir.FilterExpr{Line: 658, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, }, }, }, ir.Rule{ - Line: 659, + Line: 661, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 659, Value: "type $x struct { $*_; *sync.Mutex; $*_ }"}, + ir.PatternString{Line: 661, Value: "type $x struct { $*_; *sync.Mutex; $*_ }"}, }, ReportTemplate: "don't embed *sync.Mutex", WhereExpr: ir.FilterExpr{ - Line: 660, + Line: 662, Op: ir.FilterVarTextMatchesOp, Src: "m[\"x\"].Text.Matches(`^\\p{Lu}`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 660, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, + ir.FilterExpr{Line: 662, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, }, }, }, ir.Rule{ - Line: 663, + Line: 665, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 663, Value: "type $x struct { $*_; sync.RWMutex; $*_ }"}, + ir.PatternString{Line: 665, Value: "type $x struct { $*_; sync.RWMutex; $*_ }"}, }, ReportTemplate: "don't embed sync.RWMutex", WhereExpr: ir.FilterExpr{ - Line: 664, + Line: 666, Op: ir.FilterVarTextMatchesOp, Src: "m[\"x\"].Text.Matches(`^\\p{Lu}`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 664, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, + ir.FilterExpr{Line: 666, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, }, }, }, ir.Rule{ - Line: 667, + Line: 669, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 667, Value: "type $x struct { $*_; *sync.RWMutex; $*_ }"}, + ir.PatternString{Line: 669, Value: "type $x struct { $*_; *sync.RWMutex; $*_ }"}, }, ReportTemplate: "don't embed *sync.RWMutex", WhereExpr: ir.FilterExpr{ - Line: 668, + Line: 670, Op: ir.FilterVarTextMatchesOp, Src: "m[\"x\"].Text.Matches(`^\\p{Lu}`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 668, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, + ir.FilterExpr{Line: 670, Op: ir.FilterStringOp, Src: "`^\\p{Lu}`", Value: "^\\p{Lu}"}, }, }, }, }, }, ir.RuleGroup{ - Line: 676, + Line: 678, Name: "badSorting", MatcherName: "m", DocTags: []string{ @@ -2543,60 +2545,60 @@ var PrecompiledRules = &ir.File{ DocAfter: "sort.Strings(xs)", Rules: []ir.Rule{ ir.Rule{ - Line: 677, + Line: 679, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 677, Value: "$x = sort.IntSlice($x)"}, + ir.PatternString{Line: 679, Value: "$x = sort.IntSlice($x)"}, }, ReportTemplate: "suspicious sort.IntSlice usage, maybe sort.Ints was intended?", SuggestTemplate: "sort.Ints($x)", WhereExpr: ir.FilterExpr{ - Line: 678, + Line: 680, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`[]int`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 678, Op: ir.FilterStringOp, Src: "`[]int`", Value: "[]int"}, + ir.FilterExpr{Line: 680, Op: ir.FilterStringOp, Src: "`[]int`", Value: "[]int"}, }, }, }, ir.Rule{ - Line: 682, + Line: 684, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 682, Value: "$x = sort.Float64Slice($x)"}, + ir.PatternString{Line: 684, Value: "$x = sort.Float64Slice($x)"}, }, ReportTemplate: "suspicious sort.Float64s usage, maybe sort.Float64s was intended?", SuggestTemplate: "sort.Float64s($x)", WhereExpr: ir.FilterExpr{ - Line: 683, + Line: 685, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`[]float64`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 683, Op: ir.FilterStringOp, Src: "`[]float64`", Value: "[]float64"}, + ir.FilterExpr{Line: 685, Op: ir.FilterStringOp, Src: "`[]float64`", Value: "[]float64"}, }, }, }, ir.Rule{ - Line: 687, + Line: 689, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 687, Value: "$x = sort.StringSlice($x)"}, + ir.PatternString{Line: 689, Value: "$x = sort.StringSlice($x)"}, }, ReportTemplate: "suspicious sort.StringSlice usage, maybe sort.Strings was intended?", SuggestTemplate: "sort.Strings($x)", WhereExpr: ir.FilterExpr{ - Line: 688, + Line: 690, Op: ir.FilterVarTypeIsOp, Src: "m[\"x\"].Type.Is(`[]string`)", Value: "x", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 688, Op: ir.FilterStringOp, Src: "`[]string`", Value: "[]string"}, + ir.FilterExpr{Line: 690, Op: ir.FilterStringOp, Src: "`[]string`", Value: "[]string"}, }, }, }, }, }, ir.RuleGroup{ - Line: 697, + Line: 699, Name: "externalErrorReassign", MatcherName: "m", DocTags: []string{ @@ -2608,32 +2610,32 @@ var PrecompiledRules = &ir.File{ DocAfter: "/* don't do it */", Rules: []ir.Rule{ ir.Rule{ - Line: 698, + Line: 700, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 698, Value: "$pkg.$err = $x"}, + ir.PatternString{Line: 700, Value: "$pkg.$err = $x"}, }, ReportTemplate: "suspicious reassigment of error from another package", WhereExpr: ir.FilterExpr{ - Line: 699, + Line: 701, Op: ir.FilterAndOp, Src: "m[\"err\"].Type.Is(`error`) && m[\"pkg\"].Object.Is(`PkgName`)", Args: []ir.FilterExpr{ ir.FilterExpr{ - Line: 699, + Line: 701, Op: ir.FilterVarTypeIsOp, Src: "m[\"err\"].Type.Is(`error`)", Value: "err", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 699, Op: ir.FilterStringOp, Src: "`error`", Value: "error"}, + ir.FilterExpr{Line: 701, Op: ir.FilterStringOp, Src: "`error`", Value: "error"}, }, }, ir.FilterExpr{ - Line: 699, + Line: 701, Op: ir.FilterVarObjectIsOp, Src: "m[\"pkg\"].Object.Is(`PkgName`)", Value: "pkg", Args: []ir.FilterExpr{ - ir.FilterExpr{Line: 699, Op: ir.FilterStringOp, Src: "`PkgName`", Value: "PkgName"}, + ir.FilterExpr{Line: 701, Op: ir.FilterStringOp, Src: "`PkgName`", Value: "PkgName"}, }, }, }, @@ -2642,7 +2644,7 @@ var PrecompiledRules = &ir.File{ }, }, ir.RuleGroup{ - Line: 707, + Line: 709, Name: "emptyDecl", MatcherName: "m", DocTags: []string{ @@ -2654,23 +2656,23 @@ var PrecompiledRules = &ir.File{ DocAfter: "/* nothing */", Rules: []ir.Rule{ ir.Rule{ - Line: 708, + Line: 710, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 708, Value: "var()"}, + ir.PatternString{Line: 710, Value: "var()"}, }, ReportTemplate: "empty var() block", }, ir.Rule{ - Line: 709, + Line: 711, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 709, Value: "const()"}, + ir.PatternString{Line: 711, Value: "const()"}, }, ReportTemplate: "empty const() block", }, ir.Rule{ - Line: 710, + Line: 712, SyntaxPatterns: []ir.PatternString{ - ir.PatternString{Line: 710, Value: "type()"}, + ir.PatternString{Line: 712, Value: "type()"}, }, ReportTemplate: "empty type() block", }, @@ -2678,3 +2680,4 @@ var PrecompiledRules = &ir.File{ }, }, } +