ignore lines containing nolint:consistent directives

blizzy78 · blizzy78 · commit 327489b41e45 · 2024-05-04T16:36:08.000+02:00
diff --git a/README.md b/README.md
@@ -46,6 +46,15 @@ See below for a complete list of checks.
 This analyzer works similar to [go-consistent], but with explicit configuration of checks instead of
 auto-detection, which should make it faster.
 
+The `nolint:consistent` directive can be used to ignore warnings on a particular line of code,
+for example:
+
+```go
+_ = make([]int, 0) //nolint:consistent
+
+_ = make([]int, 0) //nolint:consistent // human-readable explanation here
+```
+
 
 List of Checks
 --------------
diff --git a/andnot.go b/andnot.go
@@ -29,14 +29,14 @@ func checkAndNotExpr(pass *analysis.Pass, expr *ast.BinaryExpr, mode string) {
 			return
 		}
 
-		pass.Reportf(expr.Pos(), "use AND-NOT operator instead of AND operator with complement expression")
+		reportf(pass, expr.Pos(), "use AND-NOT operator instead of AND operator with complement expression")
 
 	case andNOTsANDComp:
 		if expr.Op != token.AND_NOT {
 			return
 		}
 
-		pass.Reportf(expr.Pos(), "use AND operator with complement expression instead of AND-NOT operator")
+		reportf(pass, expr.Pos(), "use AND operator with complement expression instead of AND-NOT operator")
 	}
 }
 
@@ -59,13 +59,13 @@ func checkAndNotAssignStmt(pass *analysis.Pass, stmt *ast.AssignStmt, mode strin
 			return
 		}
 
-		pass.Reportf(stmt.Pos(), "use AND-NOT assignment instead of AND assignment with complement expression")
+		reportf(pass, stmt.Pos(), "use AND-NOT assignment instead of AND assignment with complement expression")
 
 	case andNOTsANDComp:
 		if stmt.Tok != token.AND_NOT_ASSIGN {
 			return
 		}
 
-		pass.Reportf(stmt.Pos(), "use AND assignment with complement expression instead of AND-NOT assignment")
+		reportf(pass, stmt.Pos(), "use AND assignment with complement expression instead of AND-NOT assignment")
 	}
 }
diff --git a/consistent.go b/consistent.go
@@ -300,6 +300,55 @@ func filesToIgnore(pass *analysis.Pass, cfg *configuration) []*ast.File {
 	return files
 }
 
+func reportf(pass *analysis.Pass, pos token.Pos, format string, args ...any) {
+	if noLintDirectivePos(pass, pos) {
+		return
+	}
+
+	pass.Reportf(pos, format, args...)
+}
+
+func noLintDirectivePos(pass *analysis.Pass, pos token.Pos) bool {
+	line := pass.Fset.Position(pos).Line
+
+	for _, file := range pass.Files {
+		if pos < file.FileStart || pos > file.FileEnd {
+			continue
+		}
+
+		for _, comment := range file.Comments {
+			if pass.Fset.Position(comment.Pos()).Line < line {
+				continue
+			}
+
+			return noLintDirective(comment.List[0].Text)
+		}
+	}
+
+	return false
+}
+
+func noLintDirective(comment string) bool {
+	if !strings.HasPrefix(comment, "//nolint:") {
+		return false
+	}
+
+	comment = comment[9:]
+
+	secondaryCommentPos := strings.Index(comment, "//")
+	if secondaryCommentPos >= 0 {
+		comment = comment[:secondaryCommentPos]
+	}
+
+	for _, p := range strings.Split(comment, ",") {
+		if strings.TrimSpace(p) == "consistent" {
+			return true
+		}
+	}
+
+	return false
+}
+
 func isFuncDefinition(typ *ast.FuncType, decls []*ast.FuncDecl, lits []*ast.FuncLit) bool {
 	for _, decl := range decls {
 		if decl.Type == typ {
diff --git a/emptyifaces.go b/emptyifaces.go
@@ -37,7 +37,7 @@ func checkEmptyIfaceAny(pass *analysis.Pass, node ast.Node) {
 		return
 	}
 
-	pass.Reportf(node.Pos(), "use any instead of interface{}")
+	reportf(pass, node.Pos(), "use any instead of interface{}")
 }
 
 func checkEmptyIfaceIface(pass *analysis.Pass, node ast.Node) {
@@ -56,5 +56,5 @@ func checkEmptyIfaceIface(pass *analysis.Pass, node ast.Node) {
 		return
 	}
 
-	pass.Reportf(typ.Pos(), "use interface{} instead of any")
+	reportf(pass, typ.Pos(), "use interface{} instead of any")
 }
diff --git a/fieldlist.go b/fieldlist.go
@@ -22,7 +22,7 @@ func checkFieldList(pass *analysis.Pass, fields *ast.FieldList, fieldTypePlural
 	case fieldListExplicit:
 		for _, f := range fields.List {
 			if len(f.Names) > 1 {
-				pass.Reportf(fields.Pos(), "declare the type of %s explicitly", fieldTypePlural)
+				reportf(pass, fields.Pos(), "declare the type of %s explicitly", fieldTypePlural)
 				break
 			}
 		}
@@ -38,7 +38,7 @@ func checkFieldList(pass *analysis.Pass, fields *ast.FieldList, fieldTypePlural
 			prevTyp := pass.TypesInfo.TypeOf(list[i].Type)
 
 			if typ == prevTyp {
-				pass.Reportf(fields.Pos(), "declare the type of similar consecutive %s only once", fieldTypePlural)
+				reportf(pass, fields.Pos(), "declare the type of similar consecutive %s only once", fieldTypePlural)
 				break
 			}
 		}
diff --git a/floatlits.go b/floatlits.go
@@ -33,8 +33,8 @@ func checkFloatLit(pass *analysis.Pass, lit *ast.BasicLit, mode string) {
 
 	switch implicit := dotPos == 0; {
 	case mode == floatLitsExplicit && implicit:
-		pass.Reportf(lit.Pos(), "add zero before decimal point in floating-point literal")
+		reportf(pass, lit.Pos(), "add zero before decimal point in floating-point literal")
 	case mode == floatLitsImplicit && !implicit && strings.TrimLeft(value[:dotPos], "0") == "":
-		pass.Reportf(lit.Pos(), "remove zero before decimal point in floating-point literal")
+		reportf(pass, lit.Pos(), "remove zero before decimal point in floating-point literal")
 	}
 }
diff --git a/functypeparams.go b/functypeparams.go
@@ -17,11 +17,11 @@ func checkParamsFuncType(pass *analysis.Pass, typ *ast.FuncType, mode string) {
 
 	switch {
 	case namedFields(typ.Params) && mode == funcTypeParamsUnnamed:
-		pass.Reportf(typ.Pos(), "use unnamed function type parameters")
+		reportf(pass, typ.Pos(), "use unnamed function type parameters")
 		return
 
 	case unnamedFields(typ.Params) && mode != flagIgnore && mode != funcTypeParamsUnnamed:
-		pass.Reportf(typ.Pos(), "use named function type parameters")
+		reportf(pass, typ.Pos(), "use named function type parameters")
 		return
 	}
 
diff --git a/hexlits.go b/hexlits.go
@@ -28,9 +28,9 @@ func checkHexLit(pass *analysis.Pass, lit *ast.BasicLit, mode string) {
 
 	switch {
 	case mode == hexLitsLower && strings.ToLower(val) != val:
-		pass.Reportf(lit.Pos(), "use lowercase digits in hex literal")
+		reportf(pass, lit.Pos(), "use lowercase digits in hex literal")
 	case mode == hexLitsUpper && strings.ToUpper(val) != val:
-		pass.Reportf(lit.Pos(), "use uppercase digits in hex literal")
+		reportf(pass, lit.Pos(), "use uppercase digits in hex literal")
 	}
 }
 
diff --git a/labelsregexp.go b/labelsregexp.go
@@ -15,5 +15,5 @@ func checkLabel(pass *analysis.Pass, stmt *ast.LabeledStmt, regexp regexpValue)
 		return
 	}
 
-	pass.Reportf(stmt.Label.Pos(), "change label to match regular expression: %s", regexp.s)
+	reportf(pass, stmt.Label.Pos(), "change label to match regular expression: %s", regexp.s)
 }
diff --git a/lenchecks.go b/lenchecks.go
@@ -39,28 +39,28 @@ func checkLenCheck(pass *analysis.Pass, expr *ast.BinaryExpr, mode string) { //n
 	case lenChecksEqualZero:
 		if (oper == token.LEQ && litInt == 0) ||
 			(oper == token.LSS && litInt == 1) {
-			pass.Reportf(expr.Pos(), "check if %s is 0 instead", fun)
+			reportf(pass, expr.Pos(), "check if %s is 0 instead", fun)
 		}
 
 		if (oper == token.GTR && litInt == 0) ||
 			(oper == token.GEQ && litInt == 1) {
-			pass.Reportf(expr.Pos(), "check if %s is not 0 instead", fun)
+			reportf(pass, expr.Pos(), "check if %s is not 0 instead", fun)
 		}
 
 	case lenChecksCompareZero:
 		if (oper == token.NEQ && litInt == 0) ||
 			(oper == token.GEQ && litInt == 1) ||
 			(oper == token.EQL && litInt == 0) ||
 			(oper == token.LSS && litInt == 1) {
-			pass.Reportf(expr.Pos(), "compare %s to 0 instead", fun)
+			reportf(pass, expr.Pos(), "compare %s to 0 instead", fun)
 		}
 
 	case lenChecksCompareOne:
 		if (oper == token.NEQ && litInt == 0) ||
 			(oper == token.GTR && litInt == 0) ||
 			(oper == token.EQL && litInt == 0) ||
 			(oper == token.LEQ && litInt == 0) {
-			pass.Reportf(expr.Pos(), "compare %s to 1 instead", fun)
+			reportf(pass, expr.Pos(), "compare %s to 1 instead", fun)
 		}
 	}
 }
diff --git a/makeallocs.go b/makeallocs.go
@@ -26,9 +26,9 @@ func checkMakeAllocLit(pass *analysis.Pass, expr *ast.CompositeLit, mode string)
 
 	switch pass.TypesInfo.TypeOf(expr.Type).Underlying().(type) {
 	case *types.Slice:
-		pass.Reportf(expr.Pos(), "call make instead of using slice literal")
+		reportf(pass, expr.Pos(), "call make instead of using slice literal")
 	case *types.Map:
-		pass.Reportf(expr.Pos(), "call make instead of using map literal")
+		reportf(pass, expr.Pos(), "call make instead of using map literal")
 	}
 }
 
@@ -71,9 +71,9 @@ func checkMakeAllocMake(pass *analysis.Pass, call *ast.CallExpr, mode string) {
 	}
 
 	if mapTyp {
-		pass.Reportf(call.Pos(), "use map literal instead of calling make")
+		reportf(pass, call.Pos(), "use map literal instead of calling make")
 		return
 	}
 
-	pass.Reportf(call.Pos(), "use slice literal instead of calling make")
+	reportf(pass, call.Pos(), "use slice literal instead of calling make")
 }
diff --git a/newallocs.go b/newallocs.go
@@ -35,7 +35,7 @@ func checkNewAllocLit(pass *analysis.Pass, expr *ast.UnaryExpr, mode string) {
 		return
 	}
 
-	pass.Reportf(expr.Pos(), "call new instead of using zero-value literal")
+	reportf(pass, expr.Pos(), "call new instead of using zero-value literal")
 }
 
 func checkNewAllocNew(pass *analysis.Pass, call *ast.CallExpr, mode string) {
@@ -56,7 +56,7 @@ func checkNewAllocNew(pass *analysis.Pass, call *ast.CallExpr, mode string) {
 		return
 	}
 
-	pass.Reportf(call.Pos(), "use zero-value literal instead of calling new")
+	reportf(pass, call.Pos(), "use zero-value literal instead of calling new")
 }
 
 func identOrSelector(e ast.Expr) bool {
diff --git a/nolintdirective_test.go b/nolintdirective_test.go
@@ -0,0 +1,9 @@
+package consistent
+
+import "testing"
+
+func TestRun_NoLintDirective(t *testing.T) {
+	runTest(t, "nolintdirective", map[string]string{
+		"makeAllocs": makeAllocsLiteral,
+	})
+}
diff --git a/rangechecks.go b/rangechecks.go
@@ -34,7 +34,7 @@ func checkRangeCheck(pass *analysis.Pass, expr *ast.BinaryExpr, mode string) {
 		return
 	}
 
-	pass.Reportf(expr.Pos(), rangeCheckFlagDesc[mode])
+	reportf(pass, expr.Pos(), rangeCheckFlagDesc[mode])
 }
 
 func rangeExprStyle(expr *ast.BinaryExpr) string { //nolint:cyclop,gocognit // collecting a bunch of flags
diff --git a/singleimports.go b/singleimports.go
@@ -33,10 +33,10 @@ func checkSingleImports(pass *analysis.Pass, file *ast.File, mode string) {
 
 	switch parens := decl.Lparen.IsValid() && decl.Rparen.IsValid(); {
 	case mode == singleImportsBare && parens:
-		pass.Reportf(decl.Pos(), "remove parens around single import declaration")
+		reportf(pass, decl.Pos(), "remove parens around single import declaration")
 
 	case mode == singleImportsParens && !parens:
-		pass.Reportf(decl.Pos(), "add parens around single import declaration")
+		reportf(pass, decl.Pos(), "add parens around single import declaration")
 	}
 }
 
diff --git a/slogattrs.go b/slogattrs.go
@@ -50,13 +50,13 @@ func checkSlogAttrs(pass *analysis.Pass, call *ast.CallExpr, mode string) {
 
 	switch {
 	case mode == slogAttrsBare && attrs:
-		pass.Reportf(call.Pos(), "use bare arguments only")
+		reportf(pass, call.Pos(), "use bare arguments only")
 
 	case mode == slogAttrsAttr && bare:
-		pass.Reportf(call.Pos(), "use Attr arguments only")
+		reportf(pass, call.Pos(), "use Attr arguments only")
 
 	case mode == slogAttrsConsistent && bare && attrs:
-		pass.Reportf(call.Pos(), "use consistent arguments (either bare or Attr)")
+		reportf(pass, call.Pos(), "use consistent arguments (either bare or Attr)")
 	}
 }
 
diff --git a/switchcases.go b/switchcases.go
@@ -42,15 +42,15 @@ func checkSwitchCase(pass *analysis.Pass, clause *ast.CaseClause, mode string) {
 				continue
 			}
 
-			pass.Reportf(expr.Pos(), "separate cases with comma instead of using logical OR")
+			reportf(pass, expr.Pos(), "separate cases with comma instead of using logical OR")
 		}
 
 	case switchCasesOR:
 		if len(clause.List) <= 1 {
 			return
 		}
 
-		pass.Reportf(clause.Pos(), "use logical OR instead of separating cases with comma")
+		reportf(pass, clause.Pos(), "use logical OR instead of separating cases with comma")
 	}
 }
 
diff --git a/switchdefaults.go b/switchdefaults.go
@@ -30,14 +30,14 @@ func checkSwitchDefault(pass *analysis.Pass, stmt *ast.SwitchStmt, mode string)
 			return
 		}
 
-		pass.Reportf(stmt.Body.List[idx].Pos(), "move switch default clause to the end")
+		reportf(pass, stmt.Body.List[idx].Pos(), "move switch default clause to the end")
 
 	case switchDefaultsFirst:
 		if idx == 0 {
 			return
 		}
 
-		pass.Reportf(stmt.Body.List[idx].Pos(), "move switch default clause to the beginning")
+		reportf(pass, stmt.Body.List[idx].Pos(), "move switch default clause to the beginning")
 	}
 }
 
diff --git a/testdata/src/nolintdirective/nolintdirective.go b/testdata/src/nolintdirective/nolintdirective.go
@@ -0,0 +1,15 @@
+package nolintdirective
+
+func foo() {
+	_ = make([]int, 0) // want "use slice literal instead of calling make"
+	_ = make([]int, 0) //nolint:consistent
+	_ = make([]int, 0) //nolint:consistent // ignore
+	_ = make([]int, 0) //nolint:foo,consistent
+	_ = make([]int, 0) //nolint:foo,consistent // ignore
+	_ = make([]int, 0) //nolint:consistent,foo
+	_ = make([]int, 0) //nolint:consistent,foo // ignore
+	_ = make([]int, 0) //nolint:foo,consistent,bar
+	_ = make([]int, 0) //nolint:foo,consistent,bar // ignore
+	_ = make([]int, 0) //nolint: foo, consistent, bar
+	_ = make([]int, 0) //nolint: foo, consistent, bar // ignore
+}

Original file line number	Diff line number	Diff line change
`@@ -29,14 +29,14 @@ func checkAndNotExpr(pass analysis.Pass, expr ast.BinaryExpr, mode string) {`
`29`	`29`	`return`
`30`	`30`	`}`
`31`	`31`
`32`		`- pass.Reportf(expr.Pos(), "use AND-NOT operator instead of AND operator with complement expression")`
	`32`	`+ reportf(pass, expr.Pos(), "use AND-NOT operator instead of AND operator with complement expression")`
`33`	`33`
`34`	`34`	`case andNOTsANDComp:`
`35`	`35`	`if expr.Op != token.AND_NOT {`
`36`	`36`	`return`
`37`	`37`	`}`
`38`	`38`
`39`		`- pass.Reportf(expr.Pos(), "use AND operator with complement expression instead of AND-NOT operator")`
	`39`	`+ reportf(pass, expr.Pos(), "use AND operator with complement expression instead of AND-NOT operator")`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`@@ -59,13 +59,13 @@ func checkAndNotAssignStmt(pass analysis.Pass, stmt ast.AssignStmt, mode strin`
`59`	`59`	`return`
`60`	`60`	`}`
`61`	`61`
`62`		`- pass.Reportf(stmt.Pos(), "use AND-NOT assignment instead of AND assignment with complement expression")`
	`62`	`+ reportf(pass, stmt.Pos(), "use AND-NOT assignment instead of AND assignment with complement expression")`
`63`	`63`
`64`	`64`	`case andNOTsANDComp:`
`65`	`65`	`if stmt.Tok != token.AND_NOT_ASSIGN {`
`66`	`66`	`return`
`67`	`67`	`}`
`68`	`68`
`69`		`- pass.Reportf(stmt.Pos(), "use AND assignment with complement expression instead of AND-NOT assignment")`
	`69`	`+ reportf(pass, stmt.Pos(), "use AND assignment with complement expression instead of AND-NOT assignment")`
`70`	`70`	`}`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ func checkEmptyIfaceAny(pass *analysis.Pass, node ast.Node) {`
`37`	`37`	`return`
`38`	`38`	`}`
`39`	`39`
`40`		`- pass.Reportf(node.Pos(), "use any instead of interface{}")`
	`40`	`+ reportf(pass, node.Pos(), "use any instead of interface{}")`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`func checkEmptyIfaceIface(pass *analysis.Pass, node ast.Node) {`
`@@ -56,5 +56,5 @@ func checkEmptyIfaceIface(pass *analysis.Pass, node ast.Node) {`
`56`	`56`	`return`
`57`	`57`	`}`
`58`	`58`
`59`		`- pass.Reportf(typ.Pos(), "use interface{} instead of any")`
	`59`	`+ reportf(pass, typ.Pos(), "use interface{} instead of any")`
`60`	`60`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ func checkFieldList(pass analysis.Pass, fields ast.FieldList, fieldTypePlural`
`22`	`22`	`case fieldListExplicit:`
`23`	`23`	`for _, f := range fields.List {`
`24`	`24`	`if len(f.Names) > 1 {`
`25`		`- pass.Reportf(fields.Pos(), "declare the type of %s explicitly", fieldTypePlural)`
	`25`	`+ reportf(pass, fields.Pos(), "declare the type of %s explicitly", fieldTypePlural)`
`26`	`26`	`break`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -38,7 +38,7 @@ func checkFieldList(pass analysis.Pass, fields ast.FieldList, fieldTypePlural`
`38`	`38`	`prevTyp := pass.TypesInfo.TypeOf(list[i].Type)`
`39`	`39`
`40`	`40`	`if typ == prevTyp {`
`41`		`- pass.Reportf(fields.Pos(), "declare the type of similar consecutive %s only once", fieldTypePlural)`
	`41`	`+ reportf(pass, fields.Pos(), "declare the type of similar consecutive %s only once", fieldTypePlural)`
`42`	`42`	`break`
`43`	`43`	`}`
`44`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,8 +33,8 @@ func checkFloatLit(pass analysis.Pass, lit ast.BasicLit, mode string) {`
`33`	`33`
`34`	`34`	`switch implicit := dotPos == 0; {`
`35`	`35`	`case mode == floatLitsExplicit && implicit:`
`36`		`- pass.Reportf(lit.Pos(), "add zero before decimal point in floating-point literal")`
	`36`	`+ reportf(pass, lit.Pos(), "add zero before decimal point in floating-point literal")`
`37`	`37`	`case mode == floatLitsImplicit && !implicit && strings.TrimLeft(value[:dotPos], "0") == "":`
`38`		`- pass.Reportf(lit.Pos(), "remove zero before decimal point in floating-point literal")`
	`38`	`+ reportf(pass, lit.Pos(), "remove zero before decimal point in floating-point literal")`
`39`	`39`	`}`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ func checkHexLit(pass analysis.Pass, lit ast.BasicLit, mode string) {`
`28`	`28`
`29`	`29`	`switch {`
`30`	`30`	`case mode == hexLitsLower && strings.ToLower(val) != val:`
`31`		`- pass.Reportf(lit.Pos(), "use lowercase digits in hex literal")`
	`31`	`+ reportf(pass, lit.Pos(), "use lowercase digits in hex literal")`
`32`	`32`	`case mode == hexLitsUpper && strings.ToUpper(val) != val:`
`33`		`- pass.Reportf(lit.Pos(), "use uppercase digits in hex literal")`
	`33`	`+ reportf(pass, lit.Pos(), "use uppercase digits in hex literal")`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -15,5 +15,5 @@ func checkLabel(pass analysis.Pass, stmt ast.LabeledStmt, regexp regexpValue)`
`15`	`15`	`return`
`16`	`16`	`}`
`17`	`17`
`18`		`- pass.Reportf(stmt.Label.Pos(), "change label to match regular expression: %s", regexp.s)`
	`18`	`+ reportf(pass, stmt.Label.Pos(), "change label to match regular expression: %s", regexp.s)`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,28 +39,28 @@ func checkLenCheck(pass analysis.Pass, expr ast.BinaryExpr, mode string) { //n`
`39`	`39`	`case lenChecksEqualZero:`
`40`	`40`	`if (oper == token.LEQ && litInt == 0) \|\|`
`41`	`41`	`(oper == token.LSS && litInt == 1) {`
`42`		`- pass.Reportf(expr.Pos(), "check if %s is 0 instead", fun)`
	`42`	`+ reportf(pass, expr.Pos(), "check if %s is 0 instead", fun)`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`if (oper == token.GTR && litInt == 0) \|\|`
`46`	`46`	`(oper == token.GEQ && litInt == 1) {`
`47`		`- pass.Reportf(expr.Pos(), "check if %s is not 0 instead", fun)`
	`47`	`+ reportf(pass, expr.Pos(), "check if %s is not 0 instead", fun)`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`case lenChecksCompareZero:`
`51`	`51`	`if (oper == token.NEQ && litInt == 0) \|\|`
`52`	`52`	`(oper == token.GEQ && litInt == 1) \|\|`
`53`	`53`	`(oper == token.EQL && litInt == 0) \|\|`
`54`	`54`	`(oper == token.LSS && litInt == 1) {`
`55`		`- pass.Reportf(expr.Pos(), "compare %s to 0 instead", fun)`
	`55`	`+ reportf(pass, expr.Pos(), "compare %s to 0 instead", fun)`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`case lenChecksCompareOne:`
`59`	`59`	`if (oper == token.NEQ && litInt == 0) \|\|`
`60`	`60`	`(oper == token.GTR && litInt == 0) \|\|`
`61`	`61`	`(oper == token.EQL && litInt == 0) \|\|`
`62`	`62`	`(oper == token.LEQ && litInt == 0) {`
`63`		`- pass.Reportf(expr.Pos(), "compare %s to 1 instead", fun)`
	`63`	`+ reportf(pass, expr.Pos(), "compare %s to 1 instead", fun)`
`64`	`64`	`}`
`65`	`65`	`}`
`66`	`66`	`}`