cmd/cue: actually drop unsupported Go std types in get go

The Go logic fell through if altType returned nil,
meaning that we would try to generate and import Go std packages
as if they were CUE std packages, which does not work at all.

While here, move the extractor fields to clarify that pkg and consts
are per-package and not per-file, and declare a pkg variable which
simplifies the named type logic a bit and lets us see that a nil check
further down was redundant.

Some Go standard library packages may declare a structure
which can be imported as CUE correctly, and our thinking is that they
could be generated under a non-CUE-std namespace like
cue.mod/gen/pkg.go.dev/reflect rather than cue.mod/gen/reflect.
That is left for a future change in the form of TODOs in both
the testscript, which includes two such examples, and the code.

Fixes #648.

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

Author: mvdan

cmd/cue/cmd/get_go.go

@@ -249,13 +249,13 @@ type extractor struct {
 	done    map[string]bool
 
 	// per package
+	pkg      *packages.Package
 	orig     map[types.Type]*ast.StructType
 	usedPkgs map[string]bool
+	consts   map[string][]string
 
 	// per file
 	cmap     ast.CommentMap
-	pkg      *packages.Package
-	consts   map[string][]string
 	pkgNames map[string]pkgInfo
 
 	exclusions []*regexp.Regexp
@@ -1040,21 +1040,22 @@ func (e *extractor) makeType(typ types.Type) (result cueast.Expr) {
 	switch typ := types.Unalias(typ).(type) {
 	case *types.Named:
 		obj := typ.Obj()
-		if obj.Pkg() == nil {
+		pkg := obj.Pkg()
+		if pkg == nil {
 			return e.ident("_", false)
 		}
 		// Check for builtin packages.
 		switch {
-		case obj.Pkg().Path() == "time" && obj.Name() == "Time":
-			ref := e.ident(e.pkgNames[obj.Pkg().Path()].name, false)
+		case pkg.Path() == "time" && obj.Name() == "Time":
+			ref := e.ident(e.pkgNames[pkg.Path()].name, false)
 			var name *cueast.Ident
 			if ref.Name != "time" {
 				name = e.ident(ref.Name, false)
 			}
 			ref.Node = cueast.NewImport(name, "time")
 			return cueast.NewSel(ref, obj.Name())
 
-		case obj.Pkg().Path() == "time" && obj.Name() == "Duration":
+		case pkg.Path() == "time" && obj.Name() == "Duration":
 			// Go's time.Duration is an int64 to represent nanoseconds,
 			// and even though most Go users would find the string representation
 			// like "3s" or "40m" most reasonable and readable for constant values,
@@ -1072,22 +1073,27 @@ func (e *extractor) makeType(typ types.Type) (result cueast.Expr) {
 			// and constants like '300 | *"300ns"' to support both at the same time?
 			return e.ident("int", false)
 
-		case obj.Pkg().Path() == "math/big" && obj.Name() == "Int":
+		case pkg.Path() == "math/big" && obj.Name() == "Int":
 			return e.ident("int", false)
 
 		default:
-			if !strings.ContainsAny(obj.Pkg().Path(), ".") {
-				// Drop any standard library type if they haven't been handled
-				// above.
-				// TODO: Doc?
+			// Any Go standard library type that hasn't been handled above is not supported;
+			// fall back to whatever alternative type we can, or just "top".
+			// Otherwise we would end up generating "std" packages which clash with our
+			// own standard library, for example cue.mod/gen/time.
+			// TODO: for cases where the Go std type could be supported, we could still generate
+			// and import it under a non-std CUE package, such as cue.mod/gen/pkg.go.dev/time.
+			// TODO: Doc?
+			if !strings.ContainsAny(pkg.Path(), ".") {
 				if s := e.altType(obj.Type()); s != nil {
 					return s
 				}
+				return e.ident("_", false)
 			}
 		}
 
 		result = e.ident(obj.Name(), true)
-		if pkg := obj.Pkg(); pkg != nil && pkg != e.pkg.Types {
+		if pkg != e.pkg.Types {
 			info := e.pkgNames[pkg.Path()]
 			if info.name == "" {
 				info.name = pkg.Name()

cmd/cue/cmd/testdata/script/get_go_std.txtar

@@ -5,14 +5,12 @@ exec cue get go --local
 cmp src_go_gen.cue src_go_gen.cue.golden
 
 # Check which files were generated under cue.mod/gen and other directories.
-# TODO: we should be generating zero "std" packages under cue.mod/gen.
+# We cannot generate any std packages under cue.mod/gen either.
 find-files cue.mod
-stdout '^cue.mod/gen/[^.]+/'
+! stdout '^cue.mod/gen/[^.]+/'
 
 # Verify that the result can be loaded correctly.
-# TODO: this should succeed, not fail.
-! exec cue vet -c=false
-cmp stderr vet.stderr
+exec cue vet -c=false
 
 -- go.mod --
 module mod.test
@@ -37,8 +35,9 @@ type Root struct {
 	ReflectValue reflect.Value
 
 	// reflect.ValueError is an example of a struct made up of simple types,
-	// in this case a Method string and a Kind uint. We could generate that structure,
-	// as long as we don't place it in cue.mod/pkg/reflect, conflicting with CUE's own std.
+	// in this case a Method string and a Kind uint.
+	// TODO: generate that structure as long as we don't place it in cue.mod/pkg/reflect,
+	// which conflicts with CUE's own std.
 	ReflectValueError reflect.ValueError
 
 	// io.Writer is an interface, so there is no structure to be generated.
@@ -47,6 +46,8 @@ type Root struct {
 
 	// time.Month is just an int type, but this edge case is particularly interesting
 	// given that CUE already has a "time" package with e.g. Duration and Time, but no Month.
+	// TODO: generate that structure as long as we don't place it in cue.mod/pkg/reflect,
+	// which conflicts with CUE's own std, or generate "int" directly.
 	TimeMonth time.Month
 }
 -- src_go_gen.cue.golden --
@@ -56,31 +57,23 @@ type Root struct {
 
 package x
 
-import (
-	"reflect"
-	"io"
-	"time"
-)
-
 #Root: {
 	// reflect types and values in Go are opaque and do not encode as useful JSON.
-	ReflectType: reflect.#Type
+	ReflectType: _ @go(,reflect.Type)
 
 	// reflect.ValueError is an example of a struct made up of simple types,
-	// in this case a Method string and a Kind uint. We could generate that structure,
-	// as long as we don't place it in cue.mod/pkg/reflect, conflicting with CUE's own std.
-	ReflectValueError: reflect.#ValueError
+	// in this case a Method string and a Kind uint.
+	// TODO: generate that structure as long as we don't place it in cue.mod/pkg/reflect,
+	// which conflicts with CUE's own std.
+	ReflectValueError: _ @go(,reflect.ValueError)
 
 	// io.Writer is an interface, so there is no structure to be generated.
 	// Moreover, even though "io" is a very common Go package, CUE has no such package.
-	IoWriter: io.#Writer
+	IoWriter: _ @go(,io.Writer)
 
 	// time.Month is just an int type, but this edge case is particularly interesting
 	// given that CUE already has a "time" package with e.g. Duration and Time, but no Month.
-	TimeMonth: time.#Month
+	// TODO: generate that structure as long as we don't place it in cue.mod/pkg/reflect,
+	// which conflicts with CUE's own std, or generate "int" directly.
+	TimeMonth: _ @go(,time.Month)
 }
--- vet.stderr --
-builtin package "reflect" undefined:
-    ./src_go_gen.cue:8:2
-builtin package "io" undefined:
-    ./src_go_gen.cue:9:2