internal/encoding/gotypes: obey @go(,type=) for optional fields

The logic to make the generated Go type a pointer happened before
we looked at a `@go()` attribute for a type= override,
meaning that the pointer was generated on top.
Instead, give the end user full control with type=.

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

Author: mvdan

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

@@ -326,9 +326,9 @@ func main() {
 	var _ = zeroRoot.AttrChangedNameNested
 	zeroRoot.AttrType = constant.Kind(0)
 	zeroRoot.AttrTypeCompat = token.Token(0)
-	// zeroRoot.AttrTypeNested = make(map[any]any)
+	zeroRoot.AttrTypeNested = make(map[any]any)
 	zeroRoot.Fields.OptionalStruct = &root.EmptyStruct{}
-	// zeroRoot.Fields.OptionalStructAttrType = root.EmptyStruct{}
+	zeroRoot.Fields.OptionalStructAttrType = root.EmptyStruct{}
 
 	// 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.
@@ -666,7 +666,7 @@ type Root struct {
 
 		OptionalStruct *EmptyStruct `json:"optionalStruct,omitempty"`
 
-		OptionalStructAttrType *EmptyStruct `json:"optionalStructAttrType,omitempty"`
+		OptionalStructAttrType EmptyStruct `json:"optionalStructAttrType,omitempty"`
 
 		RegularStruct struct {
 			Field int64 `json:"field,omitempty"`
@@ -688,7 +688,7 @@ type Root struct {
 	// For compatibility with `cue get go`, an unnamed second value is also a type.
 	AttrTypeCompat token.Token `json:"attrTypeCompat,omitempty"`
 
-	AttrTypeNested *map[any]any `json:"attrTypeNested,omitempty"`
+	AttrTypeNested map[any]any `json:"attrTypeNested,omitempty"`
 
 	// doc is a great field.
 	//

internal/encoding/gotypes/generate.go

@@ -83,7 +83,7 @@ func Generate(ctx *cue.Context, insts ...*build.Instance) error {
 
 			g.emitDocs(goName, val.Doc())
 			g.appendf("type %s ", goName)
-			if err := g.emitType(val); err != nil {
+			if err := g.emitType(val, false); err != nil {
 				return err
 			}
 			g.appendf("\n\n")
@@ -180,7 +180,7 @@ func (g *generator) addDef(path cue.Path) {
 // emitType generates a CUE value as a Go type.
 // When possible, the Go type is emitted in the form of a reference.
 // Otherwise, an inline Go type expression is used.
-func (g *generator) emitType(val cue.Value) error {
+func (g *generator) emitType(val cue.Value, optional bool) error {
 	goAttr := val.Attribute("go")
 	// We prefer the form @go(Name,type=pkg.Baz) as it is explicit and extensible,
 	// but we are also backwards compatible with @go(Name,pkg.Baz) as emitted by `cue get go`.
@@ -201,6 +201,18 @@ func (g *generator) emitType(val cue.Value) 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) {
@@ -210,7 +222,7 @@ func (g *generator) emitType(val cue.Value) error {
 	case cue.StructKind:
 		if elem := val.LookupPath(cue.MakePath(cue.AnyString)); elem.Err() == nil {
 			g.appendf("map[string]")
-			if err := g.emitType(elem); err != nil {
+			if err := g.emitType(elem, false); err != nil {
 				return err
 			}
 			break
@@ -242,19 +254,7 @@ func (g *generator) emitType(val cue.Value) error {
 			}
 
 			g.appendf("%s ", goName)
-			// 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("*")
-			}
-			if err := g.emitType(val); err != nil {
+			if err := g.emitType(val, optional); err != nil {
 				return err
 			}
 			// TODO: should we generate cuego tags like `cue:"expr"`?
@@ -275,7 +275,7 @@ func (g *generator) emitType(val cue.Value) error {
 		if !elem.Exists() {
 			// TODO: perhaps mention the original type.
 			g.appendf("any /* CUE closed list */")
-		} else if err := g.emitType(elem); err != nil {
+		} else if err := g.emitType(elem, false); err != nil {
 			return err
 		}