ruleguard: fix interpolation of vars with common prefix

ruleguard/ruleguard_test.go

@@ -0,0 +1,100 @@
+package ruleguard
+
+import (
+	"go/ast"
+	"go/token"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+)
+
+func TestRenderMessage(t *testing.T) {
+	tests := []struct {
+		msg  string
+		want string
+		vars []string
+	}{
+		{
+			`$x`,
+			`xvar`,
+			[]string{`x`},
+		},
+		{
+			`$x$x`,
+			`xvarxvar`,
+			[]string{`x`},
+		},
+		{
+			`$f $foo`,
+			`fvar foovar`,
+			[]string{`f`, `foo`},
+		},
+		{
+			`$foo $f`,
+			`foovar fvar`,
+			[]string{`f`, `foo`},
+		},
+		{
+			`$foo $f`,
+			`foovar fvar`,
+			[]string{`foo`, `f`},
+		},
+		{
+			`$foo $foo $f`,
+			`foovar foovar fvar`,
+			[]string{`foo`, `f`},
+		},
+		{
+			`$foo$f`,
+			`foovarfvar`,
+			[]string{`foo`, `f`},
+		},
+		{
+			`$foo($f) + $f.$foo`,
+			`foovar(fvar) + fvar.foovar`,
+			[]string{`foo`, `f`},
+		},
+
+		// Do we care about finding a proper variable border?
+		{
+			`$fooo`,
+			`foovaro`,
+			[]string{`foo`},
+		},
+
+		// Unknown $-expressions are not interpolated.
+		{
+			`$nonexisting`,
+			`$nonexisting`,
+			[]string{`x`},
+		},
+
+		// Double dollar interpolation.
+		{
+			`$$`,
+			`dd`,
+			[]string{`x`},
+		},
+		{
+			`$$[$x]`,
+			`dd[xvar]`,
+			[]string{`x`},
+		},
+	}
+
+	var rr rulesRunner
+	rr.ctx = &Context{
+		Fset: token.NewFileSet(),
+	}
+	for _, test := range tests {
+		nodes := make(map[string]ast.Node, len(test.vars))
+		for _, v := range test.vars {
+			nodes[v] = &ast.Ident{Name: v + "var"}
+		}
+
+		have := rr.renderMessage(test.msg, &ast.Ident{Name: "dd"}, nodes, false)
+		if diff := cmp.Diff(have, test.want); diff != "" {
+			t.Errorf("render %s %v:\n(+want -have)\n%s", test.msg, test.vars, diff)
+		}
+	}
+}

ruleguard/runner.go

@@ -21,6 +21,9 @@ type rulesRunner struct {
 	filename string
 	src      []byte
 
+	// A slice that is used to do a nodes keys sorting in renderMessage().
+	sortScratch []string
+
 	fileFilterParams fileFilterParams
 	nodeFilterParams nodeFilterParams
 }
@@ -35,6 +38,7 @@ func newRulesRunner(ctx *Context, rules *GoRuleSet) *rulesRunner {
 		nodeFilterParams: nodeFilterParams{
 			ctx: ctx,
 		},
+		sortScratch: make([]string, 0, 8),
 	}
 	rr.nodeFilterParams.nodeText = rr.nodeText
 	return rr
@@ -224,7 +228,17 @@ func (rr *rulesRunner) renderMessage(msg string, n ast.Node, nodes map[string]as
 	if len(nodes) == 0 {
 		return msg
 	}
-	for name, n := range nodes {
+
+	rr.sortScratch = rr.sortScratch[:0]
+	for name := range nodes {
+		rr.sortScratch = append(rr.sortScratch, name)
+	}
+	sort.Slice(rr.sortScratch, func(i, j int) bool {
+		return len(rr.sortScratch[i]) > len(rr.sortScratch[j])
+	})
+
+	for _, name := range rr.sortScratch {
+		n := nodes[name]
 		key := "$" + name
 		if !strings.Contains(msg, key) {
 			continue