internal/encoding/gotypes: handle cyclic types out of the box

So that the linked list example doesn't need an explicit attribute
to use a pointer so the resulting Go type can compile.

While here, fix up bits of the code that still named typeFacts variables
as "info" from a previous iteration where the type was typeInfo.
And we also don't need a strings.Builder in emitTypeReference now.

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

Author: mvdan

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

@@ -163,6 +163,8 @@ _typeTests: [...#typeTest] & [
 	{name: "NonEmptyString",     fail: both: [1, 2, 3]},
 	{name: "LinkedList",         pass:       {item: 12, next: {item: 34}}},
 	{name: "LinkedList",         fail: both: {next: "x"}},
+	{name: "GraphNode",          pass:       {edges: [{}, {edges: [{}]}]}},
+	{name: "GraphNode",          fail: both: {edges: {}}},
 ]
 -- cuetest/fail_check.stderr --
 fail.both."16_IntList".types.IntList.0: conflicting values "foo" and int (mismatched types string and int):
@@ -185,7 +187,10 @@ fail.both."40_NonEmptyString".types.NonEmptyString: conflicting values string an
     ./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:94:50
-    ./root/types.cue:43:14
+    ./root/types.cue:44:14
+fail.both."44_GraphNode".types.GraphNode.edges: conflicting values [...#graphNode] and {} (mismatched types list and struct):
+    ./cuetest/all.cue:96:51
+    ./root/types.cue:50:10
 fail.both.notList: conflicting values [1,2,3] and {embedded2?:int} (mismatched types list and struct):
     ./cuetest/all.cue:5:24
     ./root/root.cue:136:2
@@ -591,14 +596,16 @@ import (
 	NonEmptyString?:     string & != ""
 	UniqueStrings?:      list.UniqueItems & [... string]
 	LinkedList?:         #linkedList
+	GraphNode?:          #graphNode
 }
 
 #linkedList: {
 	item?: _
-	// TODO: it would be nice to not have to specify optional= here;
-	// we could determine that this is a recursive type, so a pointer must be used
-	// as otherwise the Go type tries to have infinite size.
-	next?: #linkedList @go(,optional=nillable)
+	next?: #linkedList
+}
+
+#graphNode: {
+	edges?: [...#graphNode]
 }
 -- root/import.cue --
 package root
@@ -707,17 +714,20 @@ type Types struct {
 	UniqueStrings []string `json:"UniqueStrings,omitempty"`
 
 	LinkedList LinkedList `json:"LinkedList,omitempty"`
+
+	GraphNode GraphNode `json:"GraphNode,omitempty"`
 }
 
 type LinkedList struct {
 	Item any/* CUE top */ `json:"item,omitempty"`
 
-	// TODO: it would be nice to not have to specify optional= here;
-	// we could determine that this is a recursive type, so a pointer must be used
-	// as otherwise the Go type tries to have infinite size.
 	Next *LinkedList `json:"next,omitempty"`
 }
 
+type GraphNode struct {
+	Edges []*GraphNode `json:"edges,omitempty"`
+}
+
 // emptyStruct has a doc comment.
 type EmptyStruct struct {
 }

internal/encoding/gotypes/generate.go

@@ -292,11 +292,11 @@ func (g *generator) genDef(path cue.Path, val cue.Value) (*generatedDef, error)
 	def := &generatedDef{inProgress: true}
 	g.def = def
 	g.generatedTypes[qpath] = def
-	info, err := g.emitType(val, optionalZero)
+	facts, err := g.emitType(val, optionalZero)
 	if err != nil {
 		return nil, err
 	}
-	g.def.facts = info
+	g.def.facts = facts
 	g.def.inProgress = false
 	g.def = parentDef
 	return def, nil
@@ -356,10 +356,10 @@ func (g *generator) emitType(val cue.Value, optionalStg optionalStrategy) (typeF
 	// Note that type references don't get optionalStg,
 	// as @go(,optional=) only affects fields under the current type expression.
 	// TODO: support nullable types, such as `null | #SomeReference` and `null | {foo: int}`.
-	if done, info, err := g.emitTypeReference(val); err != nil {
-		return info, err
+	if done, facts, err := g.emitTypeReference(val); err != nil {
+		return typeFacts{}, err
 	} else if done {
-		return info, nil
+		return facts, nil
 	}
 
 	// Inline types are below.
@@ -443,18 +443,18 @@ func (g *generator) emitType(val cue.Value, optionalStg optionalStrategy) (typeF
 			}
 			g.def.printf("%s ", goName)
 
-			// Pointers in Go are a prefix in the syntax, but we won't find out the generated type info
+			// Pointers in Go are a prefix in the syntax, but we won't find out the generated type facts
 			// until we have emitted its Go source, which we do into the same buffer to avoid copies.
 			// Luckily, since a pointer is always one byte, and we gofmt the result anyway for nice formatting,
 			// we can add the pointer first and replace it with whitespace later if not wanted.
 			ptrOffset := len(g.def.src)
 			g.def.printf("*")
 
-			info, err := g.emitType(val, optionalStg)
+			facts, err := g.emitType(val, optionalStg)
 			if err != nil {
-				return info, err
+				return facts, err
 			}
-			if !usePointer(info, optional, optionalStg) {
+			if !usePointer(facts, optional, optionalStg) {
 				g.def.src[ptrOffset] = ' '
 			}
 
@@ -522,8 +522,8 @@ func (g *generator) emitType(val cue.Value, optionalStg optionalStrategy) (typeF
 	return facts, nil
 }
 
-func usePointer(info typeFacts, optional bool, strategy optionalStrategy) bool {
-	if info.isTypeOverride {
+func usePointer(facts typeFacts, optional bool, strategy optionalStrategy) bool {
+	if facts.isTypeOverride {
 		// @(,type=) overrides any @(,optional=) setting
 		return false
 	}
@@ -536,7 +536,7 @@ func usePointer(info typeFacts, optional bool, strategy optionalStrategy) bool {
 		return false
 	case optionalNillable:
 		// Only use a pointer when the type isn't already nillable.
-		return !info.isNillable
+		return !facts.isNillable
 	default:
 		panic("unreachable")
 	}
@@ -690,26 +690,19 @@ func goPkgNameForInstance(inst *build.Instance, instVal cue.Value) 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, typeFacts, error) {
-	var facts typeFacts
 	// 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",
 	// such as a possible path.IsValid method?
 	if len(path.Selectors()) == 0 {
-		return false, facts, nil
+		return false, typeFacts{}, nil
 	}
 	inst := root.BuildInstance()
 	// Go has no notion of qualified import paths; if a CUE file imports
 	// "foo.com/bar:qualified", we import just "foo.com/bar" on the Go side.
 	// TODO: deal with multiple packages existing in the same directory.
 	unqualifiedPath := ast.ParseImportPath(inst.ImportPath).Unqualified().String()
 
-	var sb strings.Builder
-	if root != g.pkgRoot {
-		sb.WriteString(goPkgNameForInstance(inst, root))
-		sb.WriteString(".")
-	}
-
 	// As a special case, some CUE standard library types are allowed as references
 	// even though they aren't definitions.
 	defsOnly := true
@@ -718,33 +711,50 @@ func (g *generator) emitTypeReference(val cue.Value) (bool, typeFacts, error) {
 		// Note that CUE represents durations as strings, but Go as int64.
 		// TODO: can we do better here, such as a custom duration type?
 		g.def.printf("string /* CUE time.Duration */")
-		return true, facts, nil
+		return true, typeFacts{}, nil
 	case "time.Time":
 		defsOnly = false
 	}
 
 	name := goNameFromPath(path, defsOnly)
 	if name == "" {
-		return false, facts, nil // Not a path we are generating.
+		return false, typeFacts{}, nil // Not a path we are generating.
 	}
 
-	sb.WriteString(name)
-	g.def.printf("%s", sb.String())
-
+	var facts typeFacts
+	inProgress := false
 	// We did use a reference; if the referenced name was from another package,
 	// we need to ensure that package is imported.
 	// Otherwise, we need to ensure that the referenced local definition is generated.
 	// Either way, return the facts about the referenced type.
 	if root != g.pkgRoot {
-		// TODO: populate the facts here, which will require generating imported packages first.
 		g.importCuePkgAsGoPkg[inst.ImportPath] = unqualifiedPath
-		return true, facts, nil
+		// TODO: populate the facts here, which will require generating imported packages first.
+	} else {
+		def, err := g.genDef(path, cue.Dereference(val))
+		if err != nil {
+			return false, typeFacts{}, err
+		}
+		facts = def.facts
+		inProgress = def.inProgress
 	}
-	def, err := g.genDef(path, cue.Dereference(val))
-	if err != nil {
-		return false, facts, err
+	// We generate types depth-first; if the type referenced here is still in progress,
+	// it means that we are in a cyclic type, so be nillable to avoid a Go type of infinite size.
+	// Note that sometimes we're in a complex type which is already nillable, such as:
+	//
+	//    #GraphNode: {edges?: [...#GraphNode]}
+	//
+	// So we could generate the Go field as `[]GraphNode` rather than `[]*GraphNode`,
+	// given that Go slices are already nillable, but we currently do use a pointer.
+	if inProgress && !facts.isNillable {
+		g.def.printf("*")
+		facts.isNillable = true // pointers can be nil
+	}
+	if root != g.pkgRoot {
+		g.def.printf("%s.", goPkgNameForInstance(inst, root))
 	}
-	return true, def.facts, nil
+	g.def.printf("%s", name)
+	return true, facts, nil
 }
 
 // emitDocs generates the documentation comments attached to the following declaration.