cmd/cue: support type parameters in get go

Go type parameters are represented as their basic types in most cases, but
there are some more complicated areas which are not handled yet. These
cases are documented clearly as TODOs and may be good candidates for
improvement work in future. For now, this should unblock importing some
packages.

Fixes #2217

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

Author: uhthomas

cmd/cue/cmd/get_go.go

@@ -1023,7 +1023,8 @@ func (e *extractor) makeField(name string, kind fieldKind, expr types.Type, doc
 }
 
 func (e *extractor) makeType(expr types.Type) (result cueast.Expr) {
-	if x, ok := expr.(*types.Named); ok {
+	switch x := expr.(type) {
+	case *types.Named:
 		obj := x.Obj()
 		if obj.Pkg() == nil {
 			return e.ident("_", false)
@@ -1076,10 +1077,52 @@ func (e *extractor) makeType(expr types.Type) (result cueast.Expr) {
 			result = cueast.NewSel(p, "#"+obj.Name())
 			e.usedPkg(pkg.Path())
 		}
-		return
-	}
 
-	switch x := expr.(type) {
+		// TODO(uhthomas): Fields with type parameters should not be
+		// top.
+		//
+		// For example:
+		//
+		// 	type A[T any] struct {
+		// 		SomeField T
+		// 	}
+		//
+		// 	type B A[string]
+		//
+		// Should become:
+		//
+		// 	#A: SomeField: _
+		//
+		// 	#B: #A & {
+		// 		_#T: string
+		// 		SomeField: _#T
+		// 	}
+		//
+		// Or maybe:
+		//
+		// 	#A: {
+		// 		#T: _
+		// 		SomeField: #T
+		// 	}
+		//
+		// 	#B: #A & {
+		// 		#T: string
+		// 	}
+		//
+		// The values of x.TypeParams() and x.TypeArgs() may be helpful.
+
+		// params := x.TypeParams()
+		// args := x.TypeArgs()
+		// if params.Len() > 0 {
+		// 	var fields []any
+		// 	for i := 0; i < params.Len(); i++ {
+		// 		name := params.At(i).Obj().Name()
+		// 		fields = append(fields, e.ident(name, true), e.makeType(args.At(i)))
+		// 	}
+		// 	return cueast.NewBinExpr(cuetoken.AND, result, cueast.NewStruct(fields...))
+		// }
+
+		return result
 	case *types.Pointer:
 		return &cueast.BinaryExpr{
 			X:  cueast.NewNull(),
@@ -1148,8 +1191,38 @@ func (e *extractor) makeType(expr types.Type) (result cueast.Expr) {
 			return e.ident(x.String(), false)
 		}
 
+	case *types.Union:
+		var exprs []cueast.Expr
+		for i := 0; i < x.Len(); i++ {
+			exprs = append(exprs, e.makeType(x.Term(i).Type()))
+		}
+		return cueast.NewBinExpr(cuetoken.OR, exprs...)
+
 	case *types.Interface:
-		return e.ident("_", false)
+		// TODO(uhthomas): Should interfaces with methods (IsMethodSet)
+		// be set to top?
+		if !x.IsComparable() {
+			return e.ident("_", false)
+		}
+
+		// TODO(uhthomas): Simplify expressions.
+		//
+		// For example:
+		//
+		// 	int | (int | string)
+		//
+		// Should really become:
+		//
+		// 	int | string
+		//
+		var exprs []cueast.Expr
+		for i := 0; i < x.NumEmbeddeds(); i++ {
+			exprs = append(exprs, e.makeType(x.EmbeddedType(i)))
+		}
+		return cueast.NewBinExpr(cuetoken.OR, exprs...)
+
+	case *types.TypeParam:
+		return e.makeType(x.Constraint())
 
 	default:
 		// record error

cmd/cue/cmd/testdata/script/get_go_types.txtar

@@ -13,18 +13,19 @@ cmp ./pkg1/file1_go_gen.cue ./pkg1/file1_go_gen.cue.golden
 cmp ./pkg1/alias_go_gen.cue ./pkg1/alias_go_gen.cue.golden
 cmp ./pkg2/pkg2_go_gen.cue ./pkg2/pkg2_go_gen.cue.golden
 cmp ./pkg4/pkg4_go_gen.cue ./pkg4/pkg4_go_gen.cue.golden
+cmp ./pkg_generics/pkg_generics_go_gen.cue ./pkg_generics/pkg_generics_go_gen.cue.golden
 
 # Verify dependencies did not change
 cmp go.mod go.mod.golden
 
 -- go.mod --
 module mod.test
 
-go 1.14
+go 1.21
 -- go.mod.golden --
 module mod.test
 
-go 1.14
+go 1.21
 -- cue.mod --
 module: "mod.test"
 -- pkg1/alias.go --
@@ -433,3 +434,91 @@ package pkg4
 #A: {
 	UnsafePointer: uint64 @go(,unsafe.Pointer)
 }
+-- pkg_generics/pkg_generics.go --
+package pkg_generics
+
+type SomeUnionInterface interface {
+	string | int | byte
+}
+
+type SomeStructAny[T any] struct {
+	SomeField T
+}
+
+type SomeStructString[T string] struct {
+	SomeField T
+}
+
+type SomeStructSomeInterface[T SomeUnionInterface] struct {
+	SomeField T
+}
+
+type SomeStructMultipleTypeParameters[T string, Z ~int] struct {
+	SomeField      T
+	SomeOtherField Z
+}
+
+type SomeStructComparable[T comparable] struct {
+	SomeField T
+}
+
+type SomeInterfaceWithMethod interface {
+	int
+
+	Do() string
+}
+
+type SomeAlias = string
+
+type StructWithAlias[T SomeAlias] struct {
+	SomeField T
+}
+
+type SomeType int
+
+type StructWithType[T SomeType] struct {
+	SomeField T
+}
+-- pkg_generics/pkg_generics_go_gen.cue.golden --
+// Code generated by cue get go. DO NOT EDIT.
+
+//cue:generate cue get go mod.test/pkg_generics
+
+package pkg_generics
+
+#SomeUnionInterface: string | int | uint8
+
+#SomeStructAny: {
+	SomeField: _ @go(,T)
+}
+
+#SomeStructString: {
+	SomeField: string @go(,T)
+}
+
+#SomeStructSomeInterface: {
+	SomeField: #SomeUnionInterface @go(,T)
+}
+
+#SomeStructMultipleTypeParameters: {
+	SomeField:      string @go(,T)
+	SomeOtherField: int    @go(,Z)
+}
+
+#SomeStructComparable: {
+	SomeField: _ @go(,T)
+}
+
+#SomeInterfaceWithMethod: int
+
+#SomeAlias: string
+
+#StructWithAlias: {
+	SomeField: string @go(,T)
+}
+
+#SomeType: int
+
+#StructWithType: {
+	SomeField: #SomeType @go(,T)
+}