test(golang): the generator's kind check and Go-name rule against the eql build

Review of #1095: lowerDeclaration's plaintext-kind check (Age int64 with
encrypt_into=TextEq) ran only against the real engine with EQL types, which
no test linked; and EQLGoName and eql-codegen's go_name held one rule with
nothing comparing them. TestRunAsksTheEmbeddedEngine, the one test that
links encrypt/eql, gains the kind-mismatch case ("TextEq seals a string,
and int64 is int", nothing written). The Go-name rule is exported as
stashgen.EQLGoName and checked against every row of the generated
eql.Types table from cmd/stashgen — not from stashgen's own tests, which
must not link encrypt/eql or the embedded engine they test changes build.

Claude-Session: https://claude.ai/code/session_01V3WFXwax4J3uecpFEJ6yHc

Author: coderdan

languages/golang/cmd/stashgen/main_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 
 	"github.com/cipherstash/stack/languages/golang/encrypt"
+	"github.com/cipherstash/stack/languages/golang/encrypt/eql"
 	"github.com/cipherstash/stack/languages/golang/stashgen"
 	"github.com/cipherstash/stack/languages/golang/stashgen/enginetest"
 )
@@ -155,6 +156,22 @@ func TestRunAsksTheEmbeddedEngine(t *testing.T) {
 	if _, err := os.Stat(filepath.Join(dir, "user_stash.go")); !os.IsNotExist(err) {
 		t.Fatal("a file was written after the engine refused")
 	}
+	// A Go type the EQL type does not seal: TextEq takes a string. The
+	// generator refuses it from the engine's plaintext kind, before the
+	// engine is asked. Only this test links encrypt/eql, so only it reaches
+	// the kind check against the real target list.
+	mismatched := strings.Replace(userSource, "Email string   `stash:\"email,encrypt_into=TextEq\"`", "Age int64 `stash:\"age,encrypt_into=TextEq\"`", 1)
+	if mismatched == userSource {
+		t.Fatal("the fixture's Email line changed shape")
+	}
+	dir = writeModule(t, map[string]string{"model.go": mismatched})
+	stderr.Reset()
+	if code := run([]string{"-type", "User"}, dir, &stdout, &stderr, stashgen.GuestEngine); code != 1 {
+		t.Fatalf("exit %d, want 1\n%s", code, stderr.String())
+	}
+	if !strings.Contains(stderr.String(), "User.Age") || !strings.Contains(stderr.String(), "TextEq seals a string, and int64 is int") {
+		t.Fatalf("stderr = %q", stderr.String())
+	}
 	// A context of two segments leaves an EQL field no column: refused by
 	// name, before the engine is asked, and nothing written.
 	deep := strings.Replace(userSource, "context=users", "context=app/users", 1)
@@ -178,6 +195,33 @@ func TestRunAsksTheEmbeddedEngine(t *testing.T) {
 	}
 }
 
+// stashgen.EQLGoName and eql-codegen's go_name hold one rule (Json is JSON).
+// The generated encrypt/eql table records both names for every type, so a
+// type whose GoName the Go rule does not reproduce is a rule the two no
+// longer share. This test lives here because the command links encrypt/eql;
+// the stashgen package's own tests must not, or the embedded engine they
+// test changes build.
+func TestEQLGoNameAgreesWithTheGeneratedPackage(t *testing.T) {
+	if len(eql.Types) == 0 {
+		t.Fatal("the generated eql.Types table is empty")
+	}
+	renamed := 0
+	for _, typ := range eql.Types {
+		if got := stashgen.EQLGoName(typ.Name); got != typ.GoName {
+			t.Errorf("%s: EQLGoName = %s, generated GoName = %s", typ.Name, got, typ.GoName)
+		}
+		if typ.Name != typ.GoName {
+			renamed++
+		}
+	}
+	if renamed == 0 {
+		t.Fatal("the rule renamed nothing: the Json family is spelled JSON")
+	}
+	if stashgen.EQLGoName("Json") != "JSON" || stashgen.EQLGoName("TextEq") != "TextEq" || stashgen.EQLGoName("SteVecQuery") != "SteVecQuery" {
+		t.Fatal("the one rule: a Json prefix is JSON, every other name is itself")
+	}
+}
+
 func TestModelFlagsRepeat(t *testing.T) {
 	var m modelFlags
 	for _, s := range []string{"Rows=ContactRow", "Legacy=userdb.Contact:contactRow"} {

languages/golang/stashgen/read.go

@@ -134,12 +134,14 @@ type modelField struct {
 	output *output
 }
 
-// eqlGoName is the Go type name in encrypt/eql of an EQL type the engine
+// EQLGoName is the Go type name in encrypt/eql of an EQL type the engine
 // names: the same name in every language, save the JSON family, whose Go
-// names start with JSON (Json -> JSON, JsonSearch -> JSONSearch), as Go
-// spells initialisms. The generated encrypt/eql package follows the same
-// rule (eql-codegen's go_eql renderer).
-func eqlGoName(name string) string {
+// names start with JSON (Json is JSON), as Go spells initialisms. The
+// generated encrypt/eql package follows the same rule (eql-codegen's go_eql
+// renderer), and its Types table records both names, which is what holds
+// the two in agreement (a test in cmd/stashgen reads it; this package's own
+// tests cannot link encrypt/eql without changing the engine they test).
+func EQLGoName(name string) string {
 	if strings.HasPrefix(name, "Json") {
 		return "JSON" + strings.TrimPrefix(name, "Json")
 	}
@@ -689,10 +691,10 @@ func (r *reader) buildFields(c *collected) error {
 				return fieldErr(typeName, cf.goName, "the engine cannot produce the EQL type %s yet: %s", field.EQLType, reason)
 			}
 			f.imports.add(eqlPath, "eql")
-			g.outputType = "eql." + eqlGoName(eqlType.Name)
-			g.outputs = []output{{name: "EQL", typeExpr: g.outputType, pathType: eqlPath + "." + eqlGoName(eqlType.Name)}}
+			g.outputType = "eql." + EQLGoName(eqlType.Name)
+			g.outputs = []output{{name: "EQL", typeExpr: g.outputType, pathType: eqlPath + "." + EQLGoName(eqlType.Name)}}
 			if eqlType.Query != "" {
-				g.queryType = "eql." + eqlGoName(eqlType.Query)
+				g.queryType = "eql." + EQLGoName(eqlType.Query)
 			}
 		default:
 			g.outputType = f.encName + cf.goName