make Import() function more module-aware with v%d support

Now paths like `foo/v2` will work automatically.
For a more complicated use case, call `ImportAs` and assign
a proper name manually.

Author: quasilyte

analyzer/testdata/src/imports/f1.go

@@ -25,3 +25,24 @@ type distraction struct{}
 func (distraction) Read(p []byte) (int, error) {
 	return 0, nil
 }
+
+type (
+	v1Impl struct{}
+	v2Impl struct{}
+	v3Impl struct{}
+)
+
+func (i *v1Impl) Do() {}
+
+func (i *v2Impl) Do(x any) {}
+
+func (i *v3Impl) Do(x int) {}
+
+func json2() {
+	var i1 *v1Impl
+	var i2 *v2Impl
+	var i3 *v3Impl
+	_ = i1 // want `\Qv1 implemented`
+	_ = i2 // want `\Qv2 implemented`
+	_ = i3 // want `\Qv3 implemented`
+}

analyzer/testdata/src/imports/mylib/mylib.go

@@ -0,0 +1,5 @@
+package mylib
+
+type Contract interface {
+	Do()
+}

analyzer/testdata/src/imports/mylib/v2/mylib.go

@@ -0,0 +1,5 @@
+package mylib
+
+type Contract interface {
+	Do(x any)
+}

analyzer/testdata/src/imports/mylib/v3/mylib.go

@@ -0,0 +1,5 @@
+package mylib
+
+type Contract interface {
+	Do(x int)
+}

analyzer/testdata/src/imports/rules.go

@@ -15,3 +15,24 @@ func testCryptoRand(m dsl.Matcher) {
 	m.Import(`crypto/rand`)
 	m.Match(`rand.Read($*_)`).Report(`crypto/rand`)
 }
+
+func testImportV1(m dsl.Matcher) {
+	m.Import(`github.com/quasilyte/go-ruleguard/analyzer/testdata/src/imports/mylib`)
+	m.Match(`_ = $x`).
+		Where(m["x"].Type.Implements(`mylib.Contract`)).
+		Report(`v1 implemented`)
+}
+
+func testImportV2(m dsl.Matcher) {
+	m.Import(`github.com/quasilyte/go-ruleguard/analyzer/testdata/src/imports/mylib/v2`)
+	m.Match(`_ = $x`).
+		Where(m["x"].Type.Implements(`mylib.Contract`)).
+		Report(`v2 implemented`)
+}
+
+func testImportV3(m dsl.Matcher) {
+	m.Import(`github.com/quasilyte/go-ruleguard/analyzer/testdata/src/imports/mylib/v3`)
+	m.Match(`_ = $x`).
+		Where(m["x"].Type.Implements(`mylib.Contract`)).
+		Report(`v3 implemented`)
+}

ruleguard/irconv/irconv.go

@@ -7,6 +7,7 @@ import (
 	"go/token"
 	"go/types"
 	"path"
+	"regexp"
 	"strconv"
 	"strings"
 
@@ -41,10 +42,11 @@ func ConvertFile(ctx *Context, f *ast.File) (result *ir.File, err error) {
 	}()
 
 	conv := &converter{
-		types: ctx.Types,
-		pkg:   ctx.Pkg,
-		fset:  ctx.Fset,
-		src:   ctx.Src,
+		types:         ctx.Types,
+		pkg:           ctx.Pkg,
+		fset:          ctx.Fset,
+		src:           ctx.Src,
+		versionPathRe: regexp.MustCompile(`^v[0-9]+$`),
 	}
 	result = conv.ConvertFile(f)
 	return result, nil
@@ -66,6 +68,8 @@ type converter struct {
 	fset  *token.FileSet
 	src   []byte
 
+	versionPathRe *regexp.Regexp
+
 	group      *ir.RuleGroup
 	groupFuncs []localMacroFunc
 
@@ -224,6 +228,11 @@ func (conv *converter) convertRuleGroup(decl *ast.FuncDecl) *ir.RuleGroup {
 				panic(conv.errorf(call, "Import() should be used before any rules definitions"))
 			}
 			conv.doMatcherImport(call)
+		case "ImportAs":
+			if seenRules {
+				panic(conv.errorf(call, "ImportAs() should be used before any rules definitions"))
+			}
+			conv.doMatcherImportAs(call)
 		default:
 			seenRules = true
 			conv.convertRuleExpr(call)
@@ -375,7 +384,24 @@ func (conv *converter) localDefine(assign *ast.AssignStmt) {
 
 func (conv *converter) doMatcherImport(call *ast.CallExpr) {
 	pkgPath := conv.parseStringArg(call.Args[0])
+
+	// Try to be at least somewhat module-aware.
+	// If the last path part is "/v%d", we might want to take
+	// the previous path part as a package name.
 	pkgName := path.Base(pkgPath)
+	if conv.versionPathRe.MatchString(pkgName) {
+		pkgName = path.Base(path.Dir(pkgPath))
+	}
+
+	conv.group.Imports = append(conv.group.Imports, ir.PackageImport{
+		Path: pkgPath,
+		Name: pkgName,
+	})
+}
+
+func (conv *converter) doMatcherImportAs(call *ast.CallExpr) {
+	pkgPath := conv.parseStringArg(call.Args[0])
+	pkgName := conv.parseStringArg(call.Args[1])
 	conv.group.Imports = append(conv.group.Imports, ir.PackageImport{
 		Path: pkgPath,
 		Name: pkgName,