tools/syz-linter: define context.Context usage rules

1. It is the first parameter everywhere except tests.
2. It is the second param in the tests.
3. It is always named ctx.

Author: tarasmadan

tools/syz-linter/linter.go

@@ -68,6 +68,7 @@ func run(p *analysis.Pass) (any, error) {
 				pass.checkStringLenCompare(n)
 			case *ast.FuncDecl:
 				pass.checkFuncArgs(n)
+				pass.checkContextArgs(n)
 			case *ast.CallExpr:
 				pass.checkFlagDefinition(n)
 				pass.checkLogErrorFormat(n)
@@ -229,6 +230,43 @@ func (pass *Pass) reportFuncArgs(fields []*ast.Field, first, last int) {
 	pass.report(fields[first], "Use '%v %v'", names[2:], pass.typ(fields[first].Type))
 }
 
+func (pass *Pass) checkContextArgs(n *ast.FuncDecl) {
+	if n.Type.Params == nil {
+		return
+	}
+	expectedArgPos := 0
+	if len(n.Type.Params.List) > 0 {
+		field := n.Type.Params.List[0]
+		if strings.HasSuffix(pass.typ(field.Type), "*testing.T") {
+			expectedArgPos = 1
+		}
+	}
+	argPos := 0
+	for _, field := range n.Type.Params.List {
+		isContext := pass.typ(field.Type) == "context.Context"
+		if len(field.Names) == 0 {
+			if isContext {
+				if argPos != expectedArgPos {
+					pass.report(field, "Context must be the first argument")
+				}
+				pass.report(field, "Context variable must be named 'ctx'")
+			}
+			argPos++
+		}
+		for _, name := range field.Names {
+			if isContext {
+				if argPos != expectedArgPos {
+					pass.report(name, "Context must be the first argument")
+				}
+				if name.Name != "ctx" && name.Name != "_" {
+					pass.report(name, "Context variable must be named 'ctx'")
+				}
+			}
+			argPos++
+		}
+	}
+}
+
 func (pass *Pass) checkFlagDefinition(n *ast.CallExpr) {
 	fun, ok := n.Fun.(*ast.SelectorExpr)
 	if !ok {

tools/syz-linter/testdata/src/lintertest/lintertest.go

@@ -4,6 +4,7 @@
 package lintertest
 
 import (
+	"context"
 	"flag"
 	"fmt"
 	"log"
@@ -28,14 +29,16 @@ func stringComparison() {
 
 func returnString() string { return "foo" }
 
-//
 // One space.
-//  Two spaces.
-//	One tab.
-//		Two tabs.
-//No space.			// want "Use either //<one-or-more-spaces>comment or //<one-or-more-tabs>comment format for comments"
+//
+//	 Two spaces.
+//		One tab.
+//			Two tabs.
+//
+// No space.			// want "Use either //<one-or-more-spaces>comment or //<one-or-more-tabs>comment format for comments"
+//
 //	  Tab and spaces.	// want "Use either //<one-or-more-spaces>comment or //<one-or-more-tabs>comment format for comments"
-// 	Space and tab.		// want "Use either //<one-or-more-spaces>comment or //<one-or-more-tabs>comment format for comments"
+//	Space and tab.		// want "Use either //<one-or-more-spaces>comment or //<one-or-more-tabs>comment format for comments"
 func checkCommentSpace() {
 	checkCommentSpace() // lower-case comment is OK
 	// Capital letter comment.
@@ -126,13 +129,13 @@ func varDecls() {
 
 func minmax() {
 	x, y := 0, 0
-	if x < y + 1 {		// want "Use max function instead"
+	if x < y+1 { // want "Use max function instead"
 		x = y + 1
 	}
-	if x >= y {		// want "Use max function instead"
+	if x >= y { // want "Use max function instead"
 		y = x
 	}
-	if x > 10 {		// want "Use min function instead"
+	if x > 10 { // want "Use min function instead"
 		x = 10
 	}
 }
@@ -145,10 +148,31 @@ func loopvar() {
 	}
 }
 
-func anyInterface() interface{} {	// want "Use any instead of interface{}"
-	var v interface{}		// want "Use any instead of interface{}"
-	func(interface{}) {} (v)	// want "Use any instead of interface{}"
+func anyInterface() interface{} { // want "Use any instead of interface{}"
+	var v interface{}       // want "Use any instead of interface{}"
+	func(interface{}) {}(v) // want "Use any instead of interface{}"
 	var y any
-	func(any) {} (y)
+	func(any) {}(y)
 	return v
 }
+
+func contextArgs(ctx context.Context) {
+}
+
+func contextArgsBad1(c context.Context) { // want "Context variable must be named 'ctx'"
+}
+
+func contextArgsBad2(a int, ctx context.Context) { // want "Context must be the first argument"
+}
+
+func contextArgsBad4(ctx context.Context, a int) {
+}
+
+func TestContextArgsGood(t *testing.T, ctx context.Context) {
+}
+
+func TestContextArgsBad1(t *testing.T, c context.Context) { // want "Context variable must be named 'ctx'"
+}
+
+func TestContextArgsBad2(t *testing.T, a int, ctx context.Context) { // want "Context must be the first argument"
+}