Add flag to ignore missing calls (off by default)

main.go

@@ -7,5 +7,5 @@ import (
 )
 
 func main() {
-	singlechecker.Main(paralleltest.NewAnalyzer())
+	singlechecker.Main(paralleltest.Analyzer)
 }

pkg/paralleltest/paralleltest.go

@@ -15,16 +15,21 @@ It also checks that the t.Parallel is used if multiple tests cases are run as pa
 As part of ensuring parallel tests works as expected it checks for reinitialising of the range value
 over the test cases.(https://tinyurl.com/y6555cy6)`
 
-func NewAnalyzer() *analysis.Analyzer {
-	return &analysis.Analyzer{
-		Name:     "paralleltest",
-		Doc:      Doc,
-		Run:      run,
-		Requires: []*analysis.Analyzer{inspect.Analyzer},
-	}
+var Analyzer = &analysis.Analyzer{
+	Name:     "paralleltest",
+	Doc:      Doc,
+	Run:      run,
+	Requires: []*analysis.Analyzer{inspect.Analyzer},
+}
+
+var ignoreMissing bool
+
+func init() {
+	Analyzer.Flags.BoolVar(&ignoreMissing, "i", false, "ignore missing calls to t.Parallel")
 }
 
 func run(pass *analysis.Pass) (interface{}, error) {
+
 	inspector := inspector.New(pass.Files)
 
 	nodeFilter := []ast.Node{
@@ -52,12 +57,12 @@ func run(pass *analysis.Pass) (interface{}, error) {
 
 			case *ast.ExprStmt:
 				ast.Inspect(v, func(n ast.Node) bool {
-					// Check if the test method is calling t.parallel
+					// Check if the test method is calling t.Parallel
 					if !funcHasParallelMethod {
 						funcHasParallelMethod = methodParallelIsCalledInTestFunction(n, testVar)
 					}
 
-					// Check if the t.Run within the test function is calling t.parallel
+					// Check if the t.Run within the test function is calling t.Parallel
 					if methodRunIsCalledInTestFunction(n, testVar) {
 						// n is a call to t.Run; find out the name of the subtest's *testing.T parameter.
 						innerTestVar := getRunCallbackParameterName(n)
@@ -77,7 +82,7 @@ func run(pass *analysis.Pass) (interface{}, error) {
 					return true
 				})
 
-			// Check if the range over testcases is calling t.parallel
+			// Check if the range over testcases is calling t.Parallel
 			case *ast.RangeStmt:
 				rangeNode = v
 
@@ -114,22 +119,26 @@ func run(pass *analysis.Pass) (interface{}, error) {
 			}
 		}
 
-		if !funcHasParallelMethod {
+		if !ignoreMissing && !funcHasParallelMethod {
 			pass.Reportf(node.Pos(), "Function %s missing the call to method parallel\n", funcDecl.Name.Name)
 		}
 
 		if rangeStatementOverTestCasesExists && rangeNode != nil {
 			if !rangeStatementHasParallelMethod {
-				pass.Reportf(rangeNode.Pos(), "Range statement for test %s missing the call to method parallel in test Run\n", funcDecl.Name.Name)
+				if !ignoreMissing {
+					pass.Reportf(rangeNode.Pos(), "Range statement for test %s missing the call to method parallel in test Run\n", funcDecl.Name.Name)
+				}
 			} else if loopVariableUsedInRun != nil {
 				pass.Reportf(rangeNode.Pos(), "Range statement for test %s does not reinitialise the variable %s\n", funcDecl.Name.Name, *loopVariableUsedInRun)
 			}
 		}
 
 		// Check if the t.Run is more than one as there is no point making one test parallel
-		if numberOfTestRun > 1 && len(positionOfTestRunNode) > 0 {
-			for _, n := range positionOfTestRunNode {
-				pass.Reportf(n.Pos(), "Function %s has missing the call to method parallel in the test run\n", funcDecl.Name.Name)
+		if !ignoreMissing {
+			if numberOfTestRun > 1 && len(positionOfTestRunNode) > 0 {
+				for _, n := range positionOfTestRunNode {
+					pass.Reportf(n.Pos(), "Function %s has missing the call to method parallel in the test run\n", funcDecl.Name.Name)
+				}
 			}
 		}
 	})

pkg/paralleltest/paralleltest_test.go

@@ -16,5 +16,5 @@ func TestAll(t *testing.T) {
 	}
 
 	testdata := filepath.Join(filepath.Dir(wd), "paralleltest", "testdata")
-	analysistest.Run(t, testdata, NewAnalyzer(), "t")
+	analysistest.Run(t, testdata, Analyzer, "t")
 }