internal/encoding/gotypes: generate disjunctions of structs as a map

For a simple and closed CUE struct, we can generate a Go struct.
However, for a disjunction of structs we cannot generate a single
Go struct in the general case. For now, generate a map[string]any,
which is fairly loose but at least will work.

Ideas for future enhancements are left under a TODO.

Note that we were incorrectly generating pointers to maps,
given that the decision to use a Go pointer was made before
the decision to use a Go map to represent a CUE struct.
This is resolved now as well, along with regression tests.

Signed-off-by: Daniel Martí <[email protected]>
Change-Id: I2ce4eb40b107b456c20a44d28332df668be33045
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1207219
Reviewed-by: Roger Peppe <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: mvdan

cmd/cue/cmd/testdata/script/exp_gengotypes.txtar

@@ -79,9 +79,8 @@ fail: cue: isNotEqual: {mustEqual1: 8, mustEqual2: 99}
 pass: isEqual:         {mustEqual1: 8, mustEqual2: 8}
 
 fail: cue: discBoth: discriminatorField: {one: 5, two: 5}
-// TODO: discriminator field structs seem to generate empty Go structs.
-// pass: discOne: discriminatorField: one: 5
-// pass: discTwo: discriminatorField: two: 5
+pass: discOne: discriminatorField: one: 5
+pass: discTwo: discriminatorField: two: 5
 
 // To avoid repetition, we template the type test cases.
 // Note that some types have multipe test cases.
@@ -163,45 +162,45 @@ _typeTests: [...#typeTest] & [
 ]
 -- cuetest/fail_check.stderr --
 fail.both."16_IntList".types.IntList.0: conflicting values "foo" and int (mismatched types string and int):
-    ./cuetest/all.cue:68:40
+    ./cuetest/all.cue:67:40
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:26:20
     ./root/types.cue:26:23
 fail.both."16_IntList".types.IntList.1: conflicting values "bar" and int (mismatched types string and int):
-    ./cuetest/all.cue:68:47
+    ./cuetest/all.cue:67:47
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:26:20
     ./root/types.cue:26:23
 fail.both."20_IntMap".types.IntMap.one: conflicting values "x" and int (mismatched types string and int):
-    ./cuetest/all.cue:72:47
+    ./cuetest/all.cue:71:47
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:28:29
 fail.both."20_IntMap".types.IntMap.two: conflicting values "y" and int (mismatched types string and int):
-    ./cuetest/all.cue:72:59
+    ./cuetest/all.cue:71:59
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:28:29
 fail.both."37_NonEmptyString".types.NonEmptyString: conflicting values string and 123 (mismatched types string and int):
-    ./cuetest/all.cue:21:1
-    ./cuetest/all.cue:28:2
-    ./cuetest/all.cue:29:56
-    ./cuetest/all.cue:90:43
+    ./cuetest/all.cue:20:1
+    ./cuetest/all.cue:27:2
+    ./cuetest/all.cue:28:56
+    ./cuetest/all.cue:89:43
     ./root/types.cue:38:23
 fail.both."40_NonEmptyString".types.NonEmptyString: conflicting values string and [1,2,3] (mismatched types string and list):
-    ./cuetest/all.cue:21:1
-    ./cuetest/all.cue:28:2
-    ./cuetest/all.cue:29:56
-    ./cuetest/all.cue:93:43
+    ./cuetest/all.cue:20:1
+    ./cuetest/all.cue:27:2
+    ./cuetest/all.cue:28:56
+    ./cuetest/all.cue:92:43
     ./root/types.cue:38:23
 fail.both."42_LinkedList".types.LinkedList.next: conflicting values "x" and {item?:_,next?:#linkedList} (mismatched types string and struct):
-    ./cuetest/all.cue:95:50
+    ./cuetest/all.cue:94:50
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
@@ -219,41 +218,41 @@ fail.both.notString: conflicting values "not_a_struct" and {doc?:_} (mismatched
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:81:8
 fail.cue."11_Int8".types.Int8: invalid value 99999 (out of bound <=127):
-    ./cuetest/all.cue:62:30
+    ./cuetest/all.cue:61:30
 fail.cue."12_Int8".types.Int8: invalid value -99999 (out of bound >=-128):
-    ./cuetest/all.cue:63:30
+    ./cuetest/all.cue:62:30
 fail.cue."18_IntListClosed2".types.IntListClosed2: incompatible list lengths (2 and 4)
 fail.cue."29_NullOrStruct".types.NullOrStruct: 2 errors in empty disjunction:
 fail.cue."29_NullOrStruct".types.NullOrStruct: conflicting values "foo" and null (mismatched types string and null):
-    ./cuetest/all.cue:82:43
+    ./cuetest/all.cue:81:43
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:35:23
 fail.cue."29_NullOrStruct".types.NullOrStruct: conflicting values "foo" and {foo?:int} (mismatched types string and struct):
-    ./cuetest/all.cue:82:43
+    ./cuetest/all.cue:81:43
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:35:30
 fail.cue."32_NullOrString".types.NullOrString: 2 errors in empty disjunction:
 fail.cue."32_NullOrString".types.NullOrString: conflicting values 123 and null (mismatched types int and null):
-    ./cuetest/all.cue:85:43
+    ./cuetest/all.cue:84:43
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:36:23
 fail.cue."32_NullOrString".types.NullOrString: conflicting values 123 and string (mismatched types int and string):
-    ./cuetest/all.cue:85:43
+    ./cuetest/all.cue:84:43
     ./cuetest/fail_check.cue:7:12
     ./cuetest/fail_check.cue:7:17
     ./root/root.cue:12:10
     ./root/types.cue:36:30
 fail.cue."39_UniqueStrings".types.UniqueStrings: invalid value ["foo","foo"] (does not satisfy list.UniqueItems): equal value ("foo") at position 0 and 1:
-    ./cuetest/all.cue:26:55
+    ./cuetest/all.cue:25:55
     ./root/types.cue:39:23
 fail.cue."9_Uint".types.Uint: invalid value -34 (out of bound >=0):
-    ./cuetest/all.cue:60:30
+    ./cuetest/all.cue:59:30
 fail.cue.discBoth.discriminatorField: 2 errors in empty disjunction:
 fail.cue.discBoth.discriminatorField.one: field not allowed:
     ./cuetest/all.cue:14:43
@@ -273,11 +272,11 @@ fail.cue.isNotEqual.mustEqual2: conflicting values 8 and 99:
     ./root/root.cue:77:15
 fail.cue."34_NumericBounds".types.NumericBounds: invalid value 5555 (out of bound <100):
     ./root/types.cue:37:28
-    ./cuetest/all.cue:87:43
+    ./cuetest/all.cue:86:43
 fail.cue."36_NonEmptyString".types.NonEmptyString: invalid value "" (out of bound !=""):
     ./root/types.cue:38:32
-    ./cuetest/all.cue:26:55
-    ./cuetest/all.cue:89:43
+    ./cuetest/all.cue:25:55
+    ./cuetest/all.cue:88:43
     ./root/types.cue:38:23
 -- go.mod --
 module "foo.test/bar"
@@ -315,8 +314,11 @@ func main() {
 	// It's easier to test the fields with a root value.
 	// We use reflection to ensure that inline struct pointers are initialized.
 	var zeroRoot root.Root
-	fv := reflect.ValueOf(&zeroRoot).Elem().FieldByName("Fields")
+	rv := reflect.ValueOf(&zeroRoot).Elem()
+	fv := rv.FieldByName("Fields")
 	fv.Set(reflect.New(fv.Type().Elem()))
+	tv := rv.FieldByName("Types")
+	tv.Set(reflect.New(tv.Type().Elem()))
 
 	var _ = zeroRoot.Embedded1
 	var _ = zeroRoot.Embedded2
@@ -327,8 +329,10 @@ func main() {
 	zeroRoot.AttrType = constant.Kind(0)
 	zeroRoot.AttrTypeCompat = token.Token(0)
 	zeroRoot.AttrTypeNested = make(map[any]any)
+	zeroRoot.DiscriminatorField = make(map[string]any)
 	zeroRoot.Fields.OptionalStruct = &root.EmptyStruct{}
 	zeroRoot.Fields.OptionalStructAttrType = root.EmptyStruct{}
+	zeroRoot.Types.IntMap = make(map[string]int64)
 
 	// Sanity check that Go can JSON decode all the values we expect.
 	// We also re-encode the ones we expect CUE to be able to validate again.
@@ -628,7 +632,7 @@ type Types struct {
 
 	IntListClosed2 []any/* CUE closed list */ `json:"IntListClosed2,omitempty"`
 
-	IntMap *map[string]int64 `json:"IntMap,omitempty"`
+	IntMap map[string]int64 `json:"IntMap,omitempty"`
 
 	Time time.Time `json:"Time,omitempty"`
 
@@ -718,8 +722,7 @@ type Root struct {
 
 	UseHiddenStruct *hiddenStruct `json:"useHiddenStruct,omitempty"`
 
-	DiscriminatorField *struct {
-	} `json:"discriminatorField,omitempty"`
+	DiscriminatorField map[string]any `json:"discriminatorField,omitempty"`
 
 	MustEqual1 int64 `json:"mustEqual1,omitempty"`
 

internal/encoding/gotypes/generate.go

@@ -201,23 +201,12 @@ func (g *generator) emitType(val cue.Value, optional bool) error {
 		g.appendf("%s", attrType)
 		return nil
 	}
-	// TODO: should we ensure that optional fields are always nilable in Go?
-	// On one hand this allows telling int64(0) apart from a missing field,
-	// but on the other, it's often unnecessary and leads to clumsy types.
-	// Perhaps add a @go() attribute parameter to require nullability.
-	//
-	// For now, only structs are always pointers when optional.
-	// This is necessary to allow recursive Go types such as linked lists.
-	// Pointers to structs are still OK in terms of UX, given that
-	// one can do X.PtrY.Z without needing to do (*X.PtrY).Z.
-	if optional && cue.Dereference(val).IncompleteKind() == cue.StructKind {
-		g.appendf("*")
-	}
 	// TODO: support nullable types, such as `null | #SomeReference` and
 	// `null | {foo: int}`.
-	if g.emitTypeReference(val) {
+	if g.emitTypeReference(val, optional) {
 		return nil
 	}
+
 	switch k := val.IncompleteKind(); k {
 	case cue.StructKind:
 		if elem := val.LookupPath(cue.MakePath(cue.AnyString)); elem.Err() == nil {
@@ -227,7 +216,22 @@ func (g *generator) emitType(val cue.Value, optional bool) error {
 			}
 			break
 		}
+		// A disjunction of structs cannot be represented in Go, as it does not have sum types.
+		// Fall back to a map of string to any, which is not ideal, but will work for any field.
+		//
+		// TODO: consider alternatives, such as:
+		// * For `#StructFoo | #StructBar`, generate named types for each disjunct,
+		//   and use `any` here as a sum type between them.
+		// * For a disjunction of closed structs, generate a flat struct with the superset
+		//   of all fields, akin to a C union.
+		if op, _ := val.Expr(); op == cue.OrOp {
+			g.appendf("map[string]any")
+			break
+		}
 		// TODO: treat a single embedding like `{[string]: int}` like we would `[string]: int`
+		if optional {
+			g.appendf("*")
+		}
 		g.appendf("struct {\n")
 		iter, err := val.Fields(cue.Definitions(true), cue.Optional(true))
 		if err != nil {
@@ -243,6 +247,15 @@ func (g *generator) emitType(val cue.Value, optional bool) error {
 			cueName := sel.String()
 			cueName = strings.TrimRight(cueName, "?!")
 			g.emitDocs(cueName, val.Doc())
+			// TODO: should we ensure that optional fields are always nilable in Go?
+			// On one hand this allows telling int64(0) apart from a missing field,
+			// but on the other, it's often unnecessary and leads to clumsy types.
+			// Perhaps add a @go() attribute parameter to require nullability.
+			//
+			// For now, only structs are always pointers when optional.
+			// This is necessary to allow recursive Go types such as linked lists.
+			// Pointers to structs are still OK in terms of UX, given that
+			// one can do X.PtrY.Z without needing to do (*X.PtrY).Z.
 			optional := sel.ConstraintType()&cue.OptionalConstraint != 0
 
 			// We want the Go name from just this selector, even when it's not a definition.
@@ -352,7 +365,7 @@ func goNameFromPath(path cue.Path, defsOnly bool) string {
 
 // emitTypeReference attempts to generate a CUE value as a Go type via a reference,
 // either to a type in the same Go package, or to a type in an imported package.
-func (g *generator) emitTypeReference(val cue.Value) bool {
+func (g *generator) emitTypeReference(val cue.Value, optional bool) bool {
 	// References to existing names, either from the same package or an imported package.
 	root, path := val.ReferencePath()
 	// TODO: surely there is a better way to check whether ReferencePath returned "no path",
@@ -367,6 +380,9 @@ func (g *generator) emitTypeReference(val cue.Value) bool {
 	unqualifiedPath := module.ParseImportPath(inst.ImportPath).Unqualified().String()
 
 	var sb strings.Builder
+	if optional && cue.Dereference(val).IncompleteKind() == cue.StructKind {
+		sb.WriteString("*")
+	}
 	if root != g.pkgRoot {
 		sb.WriteString(inst.PkgName)
 		sb.WriteString(".")