ruleguard/typematch: use external matcher state

.gitignore

@@ -1,5 +1,5 @@
 .idea
 .vscode
-test-ruleguard
-test-ruleguard-ir
+test-ruleguard.exe
+test-ruleguard-ir.exe
 coverage.txt

Makefile

@@ -14,7 +14,8 @@ build-release:
 		./cmd/ruleguard
 
 test:
-	go test -count 3 -coverpkg=./... -coverprofile=coverage.txt -covermode=atomic -race ./...
+	go test -timeout=10m -count=1 -race -coverpkg=./... -coverprofile=coverage.txt -covermode=atomic ./...
+	go test -count=3 -run=TestE2E ./analyzer
 	cd rules && go test -v .
 	@echo "everything is OK"
 

analyzer/analyzer_test.go

@@ -51,6 +51,15 @@ var tests = []struct {
 	{name: "quickfix", quickfixes: true},
 }
 
+var ruleguardExe string
+
+func TestMain(m *testing.M) {
+	ruleguardExe = buildRuleguard()
+
+	exitCode := m.Run()
+	os.Exit(exitCode)
+}
+
 func TestDirectiveComments(t *testing.T) {
 	testdata := analysistest.TestData()
 	badDirectiveRe := regexp.MustCompile("// want `[^\\\\][^Q].*")
@@ -114,6 +123,31 @@ func TestAnalyzer(t *testing.T) {
 	}
 }
 
+func TestE2E(t *testing.T) {
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	rootPath := filepath.Join(wd, "..")
+
+	for i := range tests {
+		test := tests[i]
+		t.Run(test.name, func(t *testing.T) {
+			rulesFilename := fmt.Sprintf("./analyzer/testdata/src/%s/rules.go", test.name)
+			cmd := exec.Command(ruleguardExe, "-rules", rulesFilename, "./...") // nolint:gosec
+			cmd.Dir = rootPath
+			cmd.Env = append([]string{}, os.Environ()...)
+			cmd.Env = append(cmd.Env, "GORACE=halt_on_error=1 exitcode=39")
+			out, err := cmd.CombinedOutput()
+			if exitError, ok := err.(*exec.ExitError); ok {
+				if exitError.ExitCode() == 39 {
+					t.Fatalf("found a data race!\n%s", out)
+				}
+			}
+		})
+	}
+}
+
 func TestPrintIR(t *testing.T) {
 	analyzerTemplate := `
 package main
@@ -137,18 +171,6 @@ var rulesFile = %s
 		t.Fatal(err)
 	}
 
-	{
-		args := []string{
-			"build",
-			"-o", "test-ruleguard",
-			filepath.Join(wd, "..", "cmd", "ruleguard"),
-		}
-		out, err := exec.Command("go", args...).CombinedOutput()
-		if err != nil {
-			t.Fatalf("build go-ruleguard: %v: %s", err, out)
-		}
-	}
-
 	for i := range tests {
 		test := tests[i]
 		if test.flags != nil {
@@ -194,14 +216,14 @@ var rulesFile = %s
 				t.Fatal(err)
 			}
 
-			srcRulesCmd := exec.Command(filepath.Join(wd, "test-ruleguard"), "-rules", rulesFilename, "./...") // nolint:gosec
+			srcRulesCmd := exec.Command(ruleguardExe, "-rules", rulesFilename, "./...") // nolint:gosec
 			srcRulesCmd.Dir = filepath.Join(wd, "testdata", "src", test.name)
 			srcOut, _ := srcRulesCmd.CombinedOutput()
 
 			{
 				args := []string{
 					"build",
-					"-o", "test-ruleguard-ir",
+					"-o", "test-ruleguard-ir.exe",
 					mainFile.Name(),
 				}
 				out, err := exec.Command("go", args...).CombinedOutput()
@@ -210,7 +232,7 @@ var rulesFile = %s
 				}
 			}
 
-			irRulesCmd := exec.Command(filepath.Join(wd, "test-ruleguard-ir"), "./...") // nolint:gosec
+			irRulesCmd := exec.Command(filepath.Join(wd, "test-ruleguard-ir.exe"), "./...") // nolint:gosec
 			irRulesCmd.Dir = filepath.Join(wd, "testdata", "src", test.name)
 			irOut, _ := irRulesCmd.CombinedOutput()
 
@@ -221,3 +243,23 @@ var rulesFile = %s
 		})
 	}
 }
+
+func buildRuleguard() string {
+	wd, err := os.Getwd()
+	if err != nil {
+		panic(err)
+	}
+
+	args := []string{
+		"build",
+		"-o", "test-ruleguard.exe",
+		"-race",
+		filepath.Join(wd, "..", "cmd", "ruleguard"),
+	}
+	out, err := exec.Command("go", args...).CombinedOutput()
+	if err != nil {
+		panic(fmt.Sprintf("build go-ruleguard: %v: %s", err, out))
+	}
+
+	return filepath.Join(wd, "test-ruleguard.exe")
+}

analyzer/testdata/src/regression/issue372.go

@@ -0,0 +1,6 @@
+package regression
+
+func _() {
+	_ = map[string]int{}       // want `\Qcreating a map`
+	_ = make(map[int][]string) // want `\Qcreating a map`
+}

analyzer/testdata/src/regression/rules.go

@@ -71,3 +71,9 @@ func issue360(m dsl.Matcher) {
 		Report(`don't use strings.Compare`).
 		At(m["s1"])
 }
+
+func issue372(m dsl.Matcher) {
+	m.Match("$x{}", "make($x)").
+		Where(m["x"].Type.Is("map[$k]$v")).
+		Report("creating a map")
+}

ruleguard/filters.go

@@ -292,11 +292,11 @@ func makeTypeIsFilter(src, varname string, underlying bool, pat *typematch.Patte
 		return func(params *filterParams) matchFilterResult {
 			if list, ok := params.subNode(varname).(gogrep.ExprSlice); ok {
 				return exprListFilterApply(src, list, func(x ast.Expr) bool {
-					return pat.MatchIdentical(params.typeofNode(x).Underlying())
+					return pat.MatchIdentical(params.typematchState, params.typeofNode(x).Underlying())
 				})
 			}
 			typ := params.typeofNode(params.subNode(varname)).Underlying()
-			if pat.MatchIdentical(typ) {
+			if pat.MatchIdentical(params.typematchState, typ) {
 				return filterSuccess
 			}
 			return filterFailure(src)
@@ -306,11 +306,11 @@ func makeTypeIsFilter(src, varname string, underlying bool, pat *typematch.Patte
 	return func(params *filterParams) matchFilterResult {
 		if list, ok := params.subNode(varname).(gogrep.ExprSlice); ok {
 			return exprListFilterApply(src, list, func(x ast.Expr) bool {
-				return pat.MatchIdentical(params.typeofNode(x))
+				return pat.MatchIdentical(params.typematchState, params.typeofNode(x))
 			})
 		}
 		typ := params.typeofNode(params.subNode(varname))
-		if pat.MatchIdentical(typ) {
+		if pat.MatchIdentical(params.typematchState, typ) {
 			return filterSuccess
 		}
 		return filterFailure(src)

ruleguard/gorule.go

@@ -7,6 +7,7 @@ import (
 	"regexp"
 
 	"github.com/quasilyte/go-ruleguard/ruleguard/quasigo"
+	"github.com/quasilyte/go-ruleguard/ruleguard/typematch"
 	"github.com/quasilyte/gogrep"
 	"github.com/quasilyte/gogrep/nodetag"
 )
@@ -60,6 +61,7 @@ type filterParams struct {
 
 	importer       *goImporter
 	gogrepSubState *gogrep.MatcherState
+	typematchState *typematch.MatcherState
 
 	match    matchData
 	nodePath *nodePath

ruleguard/runner.go

@@ -17,6 +17,7 @@ import (
 
 	"github.com/quasilyte/go-ruleguard/ruleguard/goutil"
 	"github.com/quasilyte/go-ruleguard/ruleguard/profiling"
+	"github.com/quasilyte/go-ruleguard/ruleguard/typematch"
 	"github.com/quasilyte/gogrep"
 	"github.com/quasilyte/gogrep/nodetag"
 )
@@ -80,9 +81,10 @@ func newRulesRunner(ctx *RunContext, buildContext *build.Context, state *engineS
 		nodePath:       newNodePath(),
 		truncateLen:    ctx.TruncateLen,
 		filterParams: filterParams{
-			env:      state.env.GetEvalEnv(),
-			importer: importer,
-			ctx:      ctx,
+			typematchState: typematch.NewMatcherState(),
+			env:            state.env.GetEvalEnv(),
+			importer:       importer,
+			ctx:            ctx,
 		},
 	}
 	if ctx.TruncateLen == 0 {