cmd/cue/cmd: add get to define CUE package from Go
Update #24
Change-Id: Ief47b7295249354d5eafbe0bcf33ea26dd6dfdc7
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/1723
Reviewed-by: Marcel van Lohuizen <mpvl@google.com>
diff --git a/cmd/cue/cmd/common_test.go b/cmd/cue/cmd/common_test.go
index fe71588..ff751cf 100644
--- a/cmd/cue/cmd/common_test.go
+++ b/cmd/cue/cmd/common_test.go
@@ -42,8 +42,8 @@
if err != nil {
log.Fatal(err)
}
-
const dir = "./testdata"
+
filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
t.Run(path, func(t *testing.T) {
if err != nil {
diff --git a/cmd/cue/cmd/get.go b/cmd/cue/cmd/get.go
new file mode 100644
index 0000000..4222db7
--- /dev/null
+++ b/cmd/cue/cmd/get.go
@@ -0,0 +1,45 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+ "fmt"
+
+ "github.com/spf13/cobra"
+)
+
+// getCmd represents the extract command
+var getCmd = &cobra.Command{
+ Use: "get <language> [packages]",
+ Short: "add dependencies to the current module",
+ Long: `Get downloads packages or modules for CUE or another language
+to include them in the module's pkg directory.
+
+Get requires an additional language field to determine for which
+language definitions should be fetched. If get fetches definitions
+for a language other than CUE, the definitions are extracted from
+the source of the respective language and stored.
+The specifics on how dependencies are fechted and converted vary
+per language and are documented in the respective subcommands.
+`,
+ RunE: func(cmd *cobra.Command, args []string) error {
+ fmt.Println("get must be run as one of its subcommands")
+ return nil
+ },
+}
+
+func init() {
+ rootCmd.AddCommand(getCmd)
+}
diff --git a/cmd/cue/cmd/get_go.go b/cmd/cue/cmd/get_go.go
new file mode 100644
index 0000000..0ab6262
--- /dev/null
+++ b/cmd/cue/cmd/get_go.go
@@ -0,0 +1,1073 @@
+// Copyright 2018 The CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+ "bytes"
+ "fmt"
+ "go/ast"
+ "go/token"
+ "go/types"
+ "io"
+ "io/ioutil"
+ "os"
+ "path"
+ "path/filepath"
+ "reflect"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+
+ "cuelang.org/go/cue/format"
+ "cuelang.org/go/cue/parser"
+ cuetoken "cuelang.org/go/cue/token"
+ "github.com/spf13/cobra"
+ "golang.org/x/tools/go/packages"
+)
+
+// TODO:
+// Document:
+// - how to deal with "oneOf" or sum types?
+// - generate cue files for cuego definitions?
+// - cue go get or cue get go
+// - include generation report in doc_gen.cue or report.txt.
+// Possible enums:
+// package foo
+// Type: enumType
+
+var getGoCmd = &cobra.Command{
+ Use: "go [packages]",
+ Short: "add Go dependencies to the current module",
+ Long: `go converts Go types into CUE definitions
+
+The command "cue get go" is like "go get", but converts the retrieved Go
+packages to CUE. The retrieved packages are put in the CUE module's pkg
+directory at the import path of the corresponding Go package. The converted
+definitions are available to any CUE file within the CUE module by using
+this import path.
+
+The Go type definitions are converted to CUE based on how they would be
+interpreted by Go's encoding/json package. Definitions for a Go file foo.go
+are written to a CUE file named foo_go_gen.cue.
+
+It is safe for users to add additional files to the generated directories,
+as long as their name does not end with _gen.*.
+
+
+Rules of Converting Go types to CUE
+
+Go structs are converted to cue structs adhering to the following conventions:
+
+ - field names are translated based on the definition of a "json" or "yaml"
+ tag, in that order.
+
+ - embedded structs marked with a json inline tag unify with struct
+ definition. For instance, the Go struct
+
+ struct MyStruct {
+ Common ` + "json:\",inline\"" + `
+ Field string
+ }
+
+ translates to the CUE struct
+
+ MyStruct: Common & {
+ Field: string
+ }
+
+ - a type that implements MarshalJSON, UnmarshalJSON, MarshalYAML, or
+ UnmarshalYAML is translated to top (_) to indicate it may be any
+ value. For some Go core types for which the implementation of these
+ methods is known, like time.Time, the type may be more specific.
+
+ - a type implementing MarshalText or UnmarshalText is represented as
+ the CUE type string
+
+ - slices and arrays convert to CUE lists, except when the element type is
+ byte, in which case it translates to the CUE bytes type.
+ In the case of arrays, the length of the CUE value is constrained
+ accordingly, when possible.
+
+ - Maps translate to a CUE struct, where all elements are constrained to
+ be of Go map element type. Like for JSON, maps may only have string keys.
+
+ - Pointers translate to a sum type with the default value of null and
+ the Go type as an alternative value.
+
+ - Field tags are translated to CUE's field attributes. In some cases,
+ the contents are rewritten to reflect the corresponding types in CUE.
+ The @go attribute is added if the field name or type definition differs
+ between the generated CUE and the original Go.
+
+
+Native CUE Constraints
+
+Native CUE constraints may be defined in separate cue files alongside the
+generated files either in the original Go directory or in the generated
+directory. These files can impose additional constraints on types and values
+that are not otherwise expressible in Go. The package name for these CUE files
+must be the same as that of the Go package.
+
+For instance, for the type
+
+ package foo
+
+ type IP4String string
+
+defined in the Go package, one could add a cue file foo.cue with the following
+contents to allow IP4String to assume only valid IP4 addresses:
+
+ package foo
+
+ // IP4String defines a valid IP4 address.
+ IP4String: =~#"^\#(byte)\.\#(byte)\.\#(byte)\.\#(byte)$"#
+
+ // byte defines string allowing integer values of 0-255.
+ byte = #"([01]?\d?\d|2[0-4]\d|25[0-5])"#
+
+
+The "cue get go" command copies any cue files in the original Go package
+directory that has a package clause with the same name as the Go package to the
+destination directory, replacing its .cue ending with _gen.cue.
+
+Alternatively, the additional native constraints can be added to the generated
+package, as long as the file name does not end with _gen.cue.
+Running cue get go again to regenerate the package will never overwrite any
+files not ending with _gen.*.
+
+
+Constants and Enums
+
+Go does not have an enum or sum type. Conventionally, a type that is supposed
+to be an enum is followed by a const block with the allowed values for that
+type. However, as that is only a guideline and not a hard rule, these cases
+cannot be translated to CUE disjunctions automatically.
+
+Constant values, however, are generated in a way that makes it easy to convert
+a type to a proper enum using native CUE constraints. For instance, the Go type
+
+ package foo
+
+ type Switch int
+
+ const (
+ Off Switch = iota
+ On
+ )
+
+translates into the following CUE definitions:
+
+ package foo
+
+ Switch: int // enumSwitch
+
+ enumSwitch: Off | On
+
+ Off: 0
+ On: 1
+
+This definition allows any integer value for Switch, while the enumSwitch value
+defines all defined constants for Switch and thus all valid values if Switch
+were to be interpreted as an enum type. To turn Switch into an enum,
+include the following constraint in, say, enum.cue, in either the original
+source directory or the generated directory:
+
+ package foo
+
+ // limit the valid values for Switch to those existing as constants with
+ // the same type.
+ Switch: enumSwitch
+
+This tells CUE that only the values enumerated by enumSwitch are valid
+values for Switch. Note that there are now two definitions of Switch.
+CUE handles this in the usual way by unifying the two definitions, in which case
+the more restrictive enum interpretation of Switch remains.
+`,
+ // - TODO: interpret cuego's struct tags and annotations.
+
+ RunE: func(cmd *cobra.Command, args []string) error {
+ return extract(cmd, args)
+ },
+}
+
+func init() {
+ getCmd.AddCommand(getGoCmd)
+
+ exclude = getGoCmd.Flags().StringP("exclude", "e", "",
+ "comma-separated list of regexps of entries")
+}
+
+var (
+ cueTestRoot string // the CUE module root for test purposes.
+ exclude *string
+
+ exclusions []*regexp.Regexp
+)
+
+type dstUsed struct {
+ dst string
+ used bool
+}
+
+func initExclusions() {
+ for _, re := range strings.Split(*exclude, ",") {
+ if re != "" {
+ exclusions = append(exclusions, regexp.MustCompile(re))
+ }
+ }
+}
+
+func filter(name string) bool {
+ if !ast.IsExported(name) {
+ return true
+ }
+ for _, ex := range exclusions {
+ if ex.MatchString(name) {
+ return true
+ }
+ }
+ return false
+}
+
+type extractor struct {
+ stderr io.Writer
+ err error
+ pkgs []*packages.Package
+ done map[string]bool
+
+ // per package
+ orig map[types.Type]*ast.StructType
+ usedPkgs map[string]bool
+
+ // per file
+ w *bytes.Buffer
+ cmap ast.CommentMap
+ pkg *packages.Package
+ consts map[string][]string
+ pkgNames map[string]string
+ usedInFile map[string]bool
+ indent int
+}
+
+func (e *extractor) logf(format string, args ...interface{}) {
+ if *fVerbose {
+ fmt.Fprintf(e.stderr, format+"\n", args...)
+ }
+}
+
+func (e *extractor) usedPkg(pkg string) {
+ e.usedPkgs[pkg] = true
+ e.usedInFile[pkg] = true
+}
+
+func (e *extractor) errorf(format string, args ...interface{}) {
+ err := fmt.Errorf(format, args...)
+ fmt.Fprintln(e.stderr, err)
+ if e.err == nil {
+ e.err = err
+ }
+}
+
+func initInterfaces() error {
+ cfg := &packages.Config{
+ Mode: packages.LoadAllSyntax,
+ }
+ p, err := packages.Load(cfg, "cuelang.org/go/cmd/cue/cmd/interfaces")
+ if err != nil {
+ return err
+ }
+
+ for e, tt := range p[0].TypesInfo.Types {
+ if n, ok := tt.Type.(*types.Named); ok && n.String() == "error" {
+ continue
+ }
+ if tt.Type.Underlying().String() == "interface{}" {
+ continue
+ }
+
+ switch tt.Type.Underlying().(type) {
+ case *types.Interface:
+ file := p[0].Fset.Position(e.Pos()).Filename
+ switch filepath.Base(file) {
+ case "top.go":
+ toTop = append(toTop, tt.Type)
+ case "text.go":
+ toString = append(toString, tt.Type)
+ }
+ }
+ }
+ return nil
+}
+
+var (
+ toTop []types.Type
+ toString []types.Type
+)
+
+// TODO:
+// - consider not including types with any dropped fields.
+
+func extract(cmd *cobra.Command, args []string) error {
+ // determine module root:
+ binst := loadFromArgs(cmd, []string{"."})[0]
+
+ if err := initInterfaces(); err != nil {
+ return err
+ }
+
+ // TODO: require explicitly set root.
+ root := binst.Root
+
+ // Override root in testing mode.
+ if cueTestRoot != "" {
+ root = cueTestRoot
+ }
+
+ cfg := &packages.Config{
+ Mode: packages.LoadAllSyntax,
+ }
+ pkgs, err := packages.Load(cfg, args...)
+ if err != nil {
+ return err
+ }
+
+ e := extractor{
+ stderr: cmd.OutOrStderr(),
+ pkgs: pkgs,
+ orig: map[types.Type]*ast.StructType{},
+ }
+
+ initExclusions()
+
+ e.done = map[string]bool{}
+
+ for _, p := range pkgs {
+ e.done[p.PkgPath] = true
+ }
+
+ for _, p := range pkgs {
+ if err := e.extractPkg(root, p); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func (e *extractor) recordTypeInfo(p *packages.Package) {
+ for _, f := range p.Syntax {
+ ast.Inspect(f, func(n ast.Node) bool {
+ switch x := n.(type) {
+ case *ast.StructType:
+ e.orig[p.TypesInfo.TypeOf(x)] = x
+ }
+ return true
+ })
+ }
+}
+
+func (e *extractor) extractPkg(root string, p *packages.Package) error {
+ e.pkg = p
+ e.logf("--- Package %s", p.PkgPath)
+
+ e.recordTypeInfo(p)
+
+ e.consts = map[string][]string{}
+
+ for _, f := range p.Syntax {
+ for _, d := range f.Decls {
+ switch x := d.(type) {
+ case *ast.GenDecl:
+ e.recordConsts(x)
+ }
+ }
+ }
+
+ pkg := p.PkgPath
+ dir := filepath.Join(root, "pkg", filepath.FromSlash(pkg))
+ if err := os.MkdirAll(dir, 0755); err != nil {
+ return err
+ }
+
+ e.usedPkgs = map[string]bool{}
+
+ args := pkg
+ if *exclude != "" {
+ args += " --exclude=" + *exclude
+ }
+
+ for i, f := range p.Syntax {
+ e.w = &bytes.Buffer{}
+
+ e.cmap = ast.NewCommentMap(p.Fset, f, f.Comments)
+
+ e.pkgNames = map[string]string{}
+ e.usedInFile = map[string]bool{}
+
+ for _, spec := range f.Imports {
+ key, _ := strconv.Unquote(spec.Path.Value)
+ if spec.Name != nil {
+ e.pkgNames[key] = spec.Name.Name
+ } else {
+ // TODO: incorrect, should be name of package clause
+ e.pkgNames[key] = path.Base(key)
+ }
+ }
+
+ hasEntries := false
+ for _, d := range f.Decls {
+ switch x := d.(type) {
+ case *ast.GenDecl:
+ if e.reportDecl(e.w, x) {
+ hasEntries = true
+ }
+ }
+ }
+
+ if !hasEntries && f.Doc == nil {
+ continue
+ }
+
+ pkgs := []string{}
+ for k := range e.usedInFile {
+ pkgs = append(pkgs, k)
+ }
+ sort.Strings(pkgs)
+
+ w := &bytes.Buffer{}
+
+ fmt.Fprintln(w, "// Code generated by cue get go. DO NOT EDIT.")
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "//cue:generate cue get go", args)
+ fmt.Fprintln(w)
+ if f.Doc != nil {
+ for _, c := range f.Doc.List {
+ fmt.Fprintln(w, c.Text)
+ }
+ }
+ fmt.Fprintf(w, "package %s\n", p.Name)
+ fmt.Fprintln(w)
+ if len(pkgs) > 0 {
+ fmt.Fprintln(w, "import (")
+ for _, s := range pkgs {
+ name := e.pkgNames[s]
+ if p.Imports[s].Name == name {
+ fmt.Fprintf(w, "%q\n", s)
+ } else {
+ fmt.Fprintf(w, "%v %q\n", name, s)
+ }
+ }
+ fmt.Fprintln(w, ")")
+ fmt.Fprintln(w)
+ }
+ fmt.Fprintln(w)
+ io.Copy(w, e.w)
+
+ file := filepath.Base(p.CompiledGoFiles[i])
+
+ file = strings.Replace(file, ".go", "_go", 1)
+ file += "_gen.cue"
+ b, err := format.Source(w.Bytes())
+ if err != nil {
+ ioutil.WriteFile(filepath.Join(dir, file), w.Bytes(), 0644)
+ fmt.Println(w.String())
+ fmt.Println(dir, file)
+ return err
+ }
+ err = ioutil.WriteFile(filepath.Join(dir, file), b, 0644)
+ if err != nil {
+ return err
+ }
+ }
+
+ for _, o := range p.CompiledGoFiles {
+ root := filepath.Dir(o)
+ err := filepath.Walk(root, func(path string, fi os.FileInfo, err error) error {
+ if fi.IsDir() && path != root {
+ return filepath.SkipDir
+ }
+ if filepath.Ext(path) != ".cue" {
+ return nil
+ }
+ f, err := parser.ParseFile(cuetoken.NewFileSet(), path, nil)
+ if err != nil {
+ return err
+ }
+
+ if f.Name != nil && f.Name.Name == p.Name {
+ file := filepath.Base(path)
+ file = file[:len(file)-len(".cue")]
+ file += "_gen.cue"
+
+ w := &bytes.Buffer{}
+ fmt.Fprintln(w, "// Code generated by cue get go. DO NOT EDIT.")
+ fmt.Fprintln(w)
+ fmt.Fprintln(w, "//cue:generate cue get go", args)
+ fmt.Fprintln(w)
+
+ b, err := ioutil.ReadFile(path)
+ if err != nil {
+ return err
+ }
+ w.Write(b)
+
+ dst := filepath.Join(dir, file)
+ if err := ioutil.WriteFile(dst, w.Bytes(), 0644); err != nil {
+ return err
+ }
+ }
+ return nil
+ })
+ if err != nil {
+ return err
+ }
+ }
+
+ for path := range e.usedPkgs {
+ if !e.done[path] {
+ e.done[path] = true
+ p := p.Imports[path]
+ if err := e.extractPkg(root, p); err != nil {
+ return err
+ }
+ }
+ }
+
+ return nil
+}
+
+func (e *extractor) recordConsts(x *ast.GenDecl) {
+ if x.Tok != token.CONST {
+ return
+ }
+ for _, s := range x.Specs {
+ v, ok := s.(*ast.ValueSpec)
+ if !ok {
+ continue
+ }
+ for _, n := range v.Names {
+ typ := e.pkg.TypesInfo.TypeOf(n).String()
+ e.consts[typ] = append(e.consts[typ], n.Name)
+ }
+ }
+}
+
+func (e *extractor) reportDecl(w io.Writer, x *ast.GenDecl) (added bool) {
+ switch x.Tok {
+ case token.TYPE:
+ for _, s := range x.Specs {
+ v, ok := s.(*ast.TypeSpec)
+ if !ok || filter(v.Name.Name) {
+ continue
+ }
+
+ typ := e.pkg.TypesInfo.TypeOf(v.Name)
+ enums := e.consts[typ.String()]
+ name := v.Name.Name
+ switch tn, ok := e.pkg.TypesInfo.Defs[v.Name].(*types.TypeName); {
+ case ok:
+ if altType := e.altType(tn.Type()); altType != "" {
+ // TODO: add the underlying tag as a Go tag once we have
+ // proper string escaping for CUE.
+ e.printDoc(x.Doc, true)
+ fmt.Fprintf(e.w, "%s: %s", name, altType)
+ added = true
+ break
+ }
+ fallthrough
+
+ default:
+ if !supportedType(nil, typ) {
+ e.logf(" Dropped declaration %v of unsupported type %v", name, typ)
+ continue
+ }
+ added = true
+
+ if s := e.altType(types.NewPointer(typ)); s != "" {
+ e.printDoc(x.Doc, true)
+ fmt.Fprint(e.w, name, ": ", s)
+ break
+ }
+ // TODO: only print original type if value is not marked as enum.
+ underlying := e.pkg.TypesInfo.TypeOf(v.Type)
+ e.printField(name, false, underlying, x.Doc, true)
+ }
+
+ e.indent++
+ if len(enums) > 0 {
+ fmt.Fprintf(e.w, " // enum%s", name)
+
+ e.newLine()
+ e.newLine()
+ fmt.Fprintf(e.w, "enum%s:\n%v", name, enums[0])
+ for _, v := range enums[1:] {
+ fmt.Fprint(e.w, " |")
+ e.newLine()
+ fmt.Fprint(e.w, v)
+ }
+ }
+ e.indent--
+ e.newLine()
+ e.newLine()
+ }
+
+ case token.CONST:
+ // TODO: copy over comments for constant blocks.
+
+ for _, s := range x.Specs {
+ // TODO: determine type name and filter.
+ v, ok := s.(*ast.ValueSpec)
+ if !ok {
+ continue
+ }
+
+ for i, name := range v.Names {
+ if !ast.IsExported(name.Name) {
+ continue
+ }
+ added = true
+
+ e.printDoc(v.Doc, true)
+ fmt.Fprint(e.w, name.Name, ": ")
+
+ typ := e.pkg.TypesInfo.TypeOf(name)
+ if s := typ.String(); !strings.Contains(s, "untyped") {
+ switch s {
+ case "byte", "string", "error":
+ default:
+ e.printType(typ)
+ fmt.Fprint(e.w, " & ")
+ }
+ }
+
+ val := ""
+ comment := ""
+ if i < len(v.Values) {
+ if lit, ok := v.Values[i].(*ast.BasicLit); ok {
+ val = lit.Value
+ }
+ }
+
+ outer:
+ switch {
+ case len(val) <= 1:
+ case val[0] == '\'':
+ comment = " // " + val
+ val = ""
+
+ case strings.HasPrefix(val, "0"):
+ for _, c := range val[1:] {
+ if c < '0' || '9' < c {
+ val = ""
+ break outer
+ }
+ }
+ val = "0o" + val[1:]
+ }
+
+ if val == "" {
+ c := e.pkg.TypesInfo.Defs[v.Names[i]].(*types.Const)
+ val = c.Val().String()
+ }
+
+ fmt.Fprint(e.w, val, comment)
+ e.newLine()
+ }
+ }
+ e.newLine()
+ }
+ return added
+}
+
+func shortTypeName(t types.Type) string {
+ if n, ok := t.(*types.Named); ok {
+ return n.Obj().Name()
+ }
+ return t.String()
+}
+
+func (e *extractor) altType(typ types.Type) string {
+ ptr := types.NewPointer(typ)
+ for _, x := range toTop {
+ i := x.Underlying().(*types.Interface)
+ if types.Implements(typ, i) || types.Implements(ptr, i) {
+ t := shortTypeName(typ)
+ e.logf(" %v implements %s; setting type to _", t, x)
+ return "_"
+ }
+ }
+ for _, x := range toString {
+ i := x.Underlying().(*types.Interface)
+ if types.Implements(typ, i) || types.Implements(ptr, i) {
+ t := shortTypeName(typ)
+ e.logf(" %v implements %s; setting type to string", t, x)
+ return "string"
+ }
+ }
+ return ""
+}
+
+func (e *extractor) printDoc(doc *ast.CommentGroup, newline bool) {
+ if doc == nil {
+ return
+ }
+ if newline {
+ e.newLine()
+ }
+ for _, c := range doc.List {
+ fmt.Fprint(e.w, c.Text)
+ e.newLine()
+ }
+}
+
+func (e *extractor) newLine() {
+ fmt.Fprintln(e.w)
+ fmt.Fprint(e.w, strings.Repeat(" ", e.indent))
+}
+
+func supportedType(stack []types.Type, t types.Type) (ok bool) {
+ // handle recursive types
+ for _, t0 := range stack {
+ if t0 == t {
+ return true
+ }
+ }
+ stack = append(stack, t)
+
+ if named, ok := t.(*types.Named); ok {
+ obj := named.Obj()
+
+ // Redirect or drop Go standard library types.
+ if obj.Pkg() == nil {
+ // error interface
+ return true
+ }
+ switch obj.Pkg().Path() {
+ case "time":
+ switch named.Obj().Name() {
+ case "Time", "Duration", "Location", "Month", "Weekday":
+ return true
+ }
+ return false
+ case "math/big":
+ switch named.Obj().Name() {
+ case "Int", "Float":
+ return true
+ }
+ // case "net":
+ // // TODO: IP, Host, SRV, etc.
+ // case "url":
+ // // TODO: URL and Values
+ }
+ }
+
+ t = t.Underlying()
+ switch x := t.(type) {
+ case *types.Basic:
+ return x.String() != "invalid type"
+ case *types.Named:
+ return true
+ case *types.Pointer:
+ return supportedType(stack, x.Elem())
+ case *types.Slice:
+ return supportedType(stack, x.Elem())
+ case *types.Array:
+ return supportedType(stack, x.Elem())
+ case *types.Map:
+ if b, ok := x.Key().Underlying().(*types.Basic); !ok || b.Kind() != types.String {
+ return false
+ }
+ return supportedType(stack, x.Elem())
+ case *types.Struct:
+ // Eliminate structs with fields for which all fields are filtered.
+ if x.NumFields() == 0 {
+ return true
+ }
+ for i := 0; i < x.NumFields(); i++ {
+ f := x.Field(i)
+ if f.Exported() && supportedType(stack, f.Type()) {
+ return true
+ }
+ }
+ case *types.Interface:
+ return true
+ }
+ return false
+}
+
+func (e *extractor) printField(name string, opt bool, expr types.Type, doc *ast.CommentGroup, newline bool) (typename string) {
+ e.printDoc(doc, newline)
+ colon := ": "
+ if opt {
+ colon = "?: "
+ }
+ fmt.Fprint(e.w, name, colon)
+ pos := e.w.Len()
+ e.printType(expr)
+ return e.w.String()[pos:]
+}
+
+func (e *extractor) printType(expr types.Type) {
+ if x, ok := expr.(*types.Named); ok {
+ obj := x.Obj()
+ if obj.Pkg() == nil {
+ fmt.Fprint(e.w, "_")
+ return
+ }
+ // Check for builtin packages.
+ // TODO: replace these literal types with a reference to the fixed
+ // builtin type.
+ switch obj.Type().String() {
+ case "time.Time":
+ e.usedInFile["time"] = true
+ fmt.Fprint(e.w, e.pkgNames[obj.Pkg().Path()], ".", obj.Name())
+ return
+
+ case "math/big.Int":
+ fmt.Fprint(e.w, "int")
+ return
+
+ default:
+ if !strings.ContainsAny(obj.Pkg().Path(), ".") {
+ // Drop any standard library type if they haven't been handled
+ // above.
+ if s := e.altType(obj.Type()); s != "" {
+ fmt.Fprint(e.w, s)
+ return
+ }
+ }
+ }
+ if pkg := obj.Pkg(); pkg != nil {
+ if name := e.pkgNames[pkg.Path()]; name != "" {
+ fmt.Fprint(e.w, name, ".")
+ e.usedPkg(pkg.Path())
+ }
+ }
+ fmt.Fprint(e.w, obj.Name())
+ return
+ }
+
+ switch x := expr.(type) {
+ case *types.Pointer:
+ fmt.Fprintf(e.w, "null | ")
+ e.printType(x.Elem())
+
+ case *types.Struct:
+ for i := 0; i < x.NumFields(); i++ {
+ f := x.Field(i)
+ if f.Anonymous() && e.isInline(x.Tag(i)) {
+ typ := f.Type()
+ if _, ok := typ.(*types.Named); ok {
+ e.printType(typ)
+ fmt.Fprintf(e.w, " & ")
+ }
+ }
+ }
+ fmt.Fprint(e.w, "{")
+ e.indent++
+ e.printFields(x)
+ e.indent--
+ e.newLine()
+ fmt.Fprint(e.w, "}")
+
+ case *types.Slice:
+ // TODO: should this be x.Elem().Underlying().String()? One could
+ // argue either way.
+ if x.Elem().String() == "byte" {
+ fmt.Fprint(e.w, "bytes")
+ } else {
+ fmt.Fprint(e.w, "[...")
+ e.printType(x.Elem())
+ fmt.Fprint(e.w, "]")
+ }
+
+ case *types.Array:
+ if x.Elem().String() == "byte" {
+ // TODO: no way to constraint lengths of bytes for now, as regexps
+ // operate on Unicode, not bytes. So we need
+ // fmt.Fprint(e.w, fmt.Sprintf("=~ '^\C{%d}$'", x.Len())),
+ // but regexp does not support that.
+ // But translate to bytes, instead of [...byte] to be consistent.
+ fmt.Fprint(e.w, "bytes")
+ } else {
+ fmt.Fprintf(e.w, "%d*[", x.Len())
+ e.printType(x.Elem())
+ fmt.Fprint(e.w, "]")
+ }
+
+ case *types.Map:
+ if b, ok := x.Key().Underlying().(*types.Basic); !ok || b.Kind() != types.String {
+ log.Panicf("unsupported map key type %T", x.Key())
+ }
+ fmt.Fprintf(e.w, "{ <_>: ")
+ e.printType(x.Elem())
+ fmt.Fprintf(e.w, " }")
+
+ case *types.Basic:
+ fmt.Fprint(e.w, x.String())
+
+ case *types.Interface:
+ fmt.Fprintf(e.w, "_")
+
+ default:
+ // record error
+ panic(fmt.Sprintf("unsupported type %T", x))
+ }
+}
+
+func (e *extractor) printFields(x *types.Struct) {
+ s := e.orig[x]
+ docs := []*ast.CommentGroup{}
+ for _, f := range s.Fields.List {
+ if len(f.Names) == 0 {
+ docs = append(docs, f.Doc)
+ } else {
+ for range f.Names {
+ docs = append(docs, f.Doc)
+ }
+ }
+ }
+ count := 0
+ for i := 0; i < x.NumFields(); i++ {
+ f := x.Field(i)
+ if !ast.IsExported(f.Name()) {
+ continue
+ }
+ if !supportedType(nil, f.Type()) {
+ e.logf(" Dropped field %v for unsupported type %v", f.Name(), f.Type())
+ continue
+ }
+ if f.Anonymous() && e.isInline(x.Tag(i)) {
+ typ := f.Type()
+ if _, ok := typ.(*types.Named); !ok {
+ switch x := typ.(type) {
+ case *types.Struct:
+ e.printFields(x)
+ default:
+ panic(fmt.Sprintf("unimplemented embedding for type %T", x))
+ }
+ }
+ continue
+ }
+ tag := x.Tag(i)
+ name := getName(f.Name(), tag)
+ if name == "-" {
+ continue
+ }
+ e.newLine()
+ cueType := e.printField(name, e.isOptional(tag), f.Type(), docs[i], count > 0)
+
+ // Add field tag to convert back to Go.
+ typeName := f.Type().String()
+ // simplify type names:
+ for path, name := range e.pkgNames {
+ typeName = strings.Replace(typeName, path+".", name+".", -1)
+ }
+ typeName = strings.Replace(typeName, e.pkg.Types.Path()+".", "", -1)
+
+ // TODO: remove fields in @go attr that are the same as printed?
+ if name != f.Name() || typeName != cueType {
+ fmt.Fprint(e.w, "@go(")
+ if name != f.Name() {
+ fmt.Fprint(e.w, f.Name())
+ }
+ if typeName != cueType {
+ if strings.ContainsAny(typeName, `#"',()=`) {
+ typeName = strconv.Quote(typeName)
+ }
+ fmt.Fprint(e.w, ",", typeName)
+ }
+ fmt.Fprintf(e.w, ")")
+ }
+
+ // Carry over protobuf field tags with modifications.
+ if t := reflect.StructTag(tag).Get("protobuf"); t != "" {
+ split := strings.Split(t, ",")
+ k := 0
+ for _, s := range split {
+ if strings.HasPrefix(s, "name=") && s[len("name="):] == name {
+ continue
+ }
+ split[k] = s
+ k++
+ }
+ split = split[:k]
+
+ // Put tag first, as type could potentially be elided and is
+ // "more optional".
+ if len(split) >= 2 {
+ split[0], split[1] = split[1], split[0]
+ }
+ fmt.Fprintf(e.w, " @protobuf(%s)", strings.Join(split, ","))
+ }
+
+ // Carry over XML tags.
+ if t := reflect.StructTag(tag).Get("xml"); t != "" {
+ fmt.Fprintf(e.w, " @xml(%s)", t)
+ }
+
+ // Carry over TOML tags.
+ if t := reflect.StructTag(tag).Get("toml"); t != "" {
+ fmt.Fprintf(e.w, " @toml(%s)", t)
+ }
+
+ // TODO: should we in general carry over any unknown tag verbatim?
+
+ count++
+ }
+}
+
+func (e *extractor) isInline(tag string) bool {
+ return hasFlag(tag, "json", "inline", 1) ||
+ hasFlag(tag, "yaml", "inline", 1)
+}
+
+func (e *extractor) isOptional(tag string) bool {
+ // TODO: also when the type is a list or other kind of pointer.
+ return hasFlag(tag, "json", "omitempty", 1) ||
+ hasFlag(tag, "yaml", "omitempty", 1)
+}
+
+func hasFlag(tag, key, flag string, offset int) bool {
+ if t := reflect.StructTag(tag).Get(key); t != "" {
+ split := strings.Split(t, ",")
+ if offset >= len(split) {
+ return false
+ }
+ for _, str := range split[offset:] {
+ if str == flag {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+func getName(name string, tag string) string {
+ tags := reflect.StructTag(tag)
+ for _, s := range []string{"json", "yaml"} {
+ if tag, ok := tags.Lookup(s); ok {
+ if p := strings.Index(tag, ","); p >= 0 {
+ tag = tag[:p]
+ }
+ if tag != "" {
+ return tag
+ }
+ }
+ }
+ // TODO: should we also consider to protobuf name? Probably not.
+
+ return name
+}
diff --git a/cmd/cue/cmd/get_go_test.go b/cmd/cue/cmd/get_go_test.go
new file mode 100644
index 0000000..36b1884
--- /dev/null
+++ b/cmd/cue/cmd/get_go_test.go
@@ -0,0 +1,102 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+ "io/ioutil"
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "github.com/retr0h/go-gilt/copy"
+ "github.com/spf13/cobra"
+)
+
+func TestGetGo(t *testing.T) {
+ // Leave the current working directory outside the testdata directory
+ // so that Go loader finds the Go mod file and creates a proper path.
+ // We need to trick the command to generate the data within the testdata
+ // directory, though.
+ tmp, err := ioutil.TempDir("", "cue_get_go")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer os.RemoveAll(tmp)
+
+ cueTestRoot = tmp
+
+ // We don't use runCommand here, as we are interested in generated packages.
+ cmd := &cobra.Command{RunE: getGoCmd.RunE}
+ cmd.SetArgs([]string{"./testdata/code/go/..."})
+ err = cmd.Execute()
+ if err != nil {
+ log.Fatal(err)
+ }
+
+ // Packages will generate differently in modules versus GOPATH. Search
+ // for the common ground to not have breaking text if people run these
+ // test in GOPATH mode.
+ root := ""
+ filepath.Walk(tmp, func(path string, info os.FileInfo, err error) error {
+ if root != "" {
+ return filepath.SkipDir
+ }
+ if filepath.Base(path) == "cuelang.org" {
+ root = filepath.Dir(path)
+ return filepath.SkipDir
+ }
+ return nil
+ })
+
+ const dst = "testdata/pkg"
+
+ if *update {
+ os.RemoveAll(dst)
+ err := copy.Dir(filepath.Join(root), dst)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Skip("files updated")
+ }
+
+ prefix := "testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/"
+ filepath.Walk(dst, func(path string, info os.FileInfo, err error) error {
+ if info.IsDir() {
+ return nil
+ }
+ t.Run(path, func(t *testing.T) {
+ want := loadFile(t, path)
+ got := loadFile(t, filepath.Join(root, path[len(dst):]))
+
+ if want != got {
+ t.Errorf("contexts for file %s differ", path[len(prefix):])
+ }
+ })
+ return nil
+ })
+}
+
+func loadFile(t *testing.T, path string) string {
+ t.Helper()
+ b, err := ioutil.ReadFile(path)
+ if err != nil {
+ t.Fatalf("could not load file %s", path)
+ }
+ // Strip comments up till package clause. Local packages will generate
+ // differently using GOPATH versuse modules.
+ s := string(b)
+ return s[strings.Index(s, "package"):]
+}
diff --git a/cmd/cue/cmd/interfaces/text.go b/cmd/cue/cmd/interfaces/text.go
new file mode 100644
index 0000000..0aa0270
--- /dev/null
+++ b/cmd/cue/cmd/interfaces/text.go
@@ -0,0 +1,22 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package interfaces
+
+import "encoding"
+
+type (
+ textMarshaler = encoding.TextMarshaler
+ textUnmarshaler = encoding.TextUnmarshaler
+)
diff --git a/cmd/cue/cmd/interfaces/top.go b/cmd/cue/cmd/interfaces/top.go
new file mode 100644
index 0000000..0d2d9a5
--- /dev/null
+++ b/cmd/cue/cmd/interfaces/top.go
@@ -0,0 +1,29 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package interfaces
+
+import (
+ "encoding/json"
+)
+
+type (
+ jsonMarshaler = json.Marshaler
+ jsonUnmarshaler = json.Unmarshaler
+
+ yamlMarshal interface{ MarshalYAML() (interface{}, error) }
+ yamlUnmarshal interface {
+ UnmarshalYAML(func(interface{}) error) error
+ }
+)
diff --git a/cmd/cue/cmd/root.go b/cmd/cue/cmd/root.go
index a705c0c..ad6528e 100644
--- a/cmd/cue/cmd/root.go
+++ b/cmd/cue/cmd/root.go
@@ -28,7 +28,7 @@
// fix: rewrite/refactor configuration files
// -i interactive: open diff and ask to update
// serve: like cmd, but for servers
-// extract: extract cue from other languages, like proto and go.
+// get: convert cue from other languages, like proto and go.
// gen: generate files for other languages
// generate like go generate (also convert cue to go doc)
// test load and fully evaluate test files.
@@ -151,13 +151,20 @@
}
var (
- fDebug = rootCmd.PersistentFlags().Bool("debug", false, "give detailed error info")
- fTrace = rootCmd.PersistentFlags().Bool("trace", false, "trace computation")
- fDryrun = rootCmd.PersistentFlags().BoolP("dryrun", "n", false, "only run simulation")
- fPackage = rootCmd.PersistentFlags().StringP("package", "p", "", "CUE package to evaluate")
- fSimplify = rootCmd.PersistentFlags().BoolP("simplify", "s", false, "simplify output")
- fIgnore = rootCmd.PersistentFlags().BoolP("ignore", "i", false, "proceed in the presence of errors")
- fVerbose = rootCmd.PersistentFlags().BoolP("verbose", "v", false, "print information about progress")
+ fDebug = rootCmd.PersistentFlags().Bool("debug", false,
+ "give detailed error info")
+ fTrace = rootCmd.PersistentFlags().Bool("trace", false,
+ "trace computation")
+ fDryrun = rootCmd.PersistentFlags().BoolP("dryrun", "n", false,
+ "only run simulation")
+ fPackage = rootCmd.PersistentFlags().StringP("package", "p", "",
+ "CUE package to evaluate")
+ fSimplify = rootCmd.PersistentFlags().BoolP("simplify", "s", false,
+ "simplify output")
+ fIgnore = rootCmd.PersistentFlags().BoolP("ignore", "i", false,
+ "proceed in the presence of errors")
+ fVerbose = rootCmd.PersistentFlags().BoolP("verbose", "v", false,
+ "print information about progress")
)
// initConfig reads in config file and ENV variables if set.
diff --git a/cmd/cue/cmd/testdata/code/go/pkg1/file1.go b/cmd/cue/cmd/testdata/code/go/pkg1/file1.go
new file mode 100644
index 0000000..eaa4f2e
--- /dev/null
+++ b/cmd/cue/cmd/testdata/code/go/pkg1/file1.go
@@ -0,0 +1,104 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pkg1
+
+import (
+ "encoding"
+ "encoding/json"
+ "time"
+
+ p2 "cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2"
+)
+
+// Foozer foozes a jaman.
+type Foozer struct {
+ Int int
+ String string
+
+ Inline `json:",inline"`
+ NoInline
+
+ CustomJSON CustomJSON
+ CustomYAML *CustomYAML
+ AnyJSON json.Marshaler
+ AnyText encoding.TextMarshaler
+
+ Bar int `json:"bar,omitempty"`
+
+ exclude int
+
+ // Time is mapped to CUE's internal type.
+ Time time.Time
+
+ Barzer p2.Barzer
+
+ Map map[string]*CustomJSON
+ Slice1 []int
+ Slice2 []interface{}
+ Slice3 *[]json.Unmarshaler
+ Array1 [5]int
+ Array2 [5]interface{}
+ Array3 *[5]json.Marshaler
+
+ Intf Interface `protobuf:"varint,2,name=intf"`
+ Intf2 interface{}
+ Intf3 struct{ Interface }
+ Intf4 interface{ Foo() }
+
+ // Even though this struct as a type implements MarshalJSON, it is known
+ // that it is really only implemented by the embedded field.
+ Embed struct{ CustomJSON }
+
+ Unsupported map[int]string
+}
+
+// Level gives an indication of the extent of stuff.
+type Level int
+
+const (
+ Unknown Level = iota
+ Low
+ // Medium is neither High nor Low
+ Medium
+ High
+)
+
+type CustomJSON struct {
+}
+
+func (c *CustomJSON) MarshalJSON() ([]byte, error) {
+ return nil, nil
+}
+
+type CustomYAML struct {
+}
+
+func (c CustomYAML) MarshalYAML() ([]byte, error) {
+ return nil, nil
+}
+
+type excludeType int
+
+type Inline struct {
+ Kind string
+}
+
+type NoInline struct {
+ Kind string
+}
+
+type Interface interface {
+ Boomer() bool
+}
diff --git a/cmd/cue/cmd/testdata/code/go/pkg2/add.cue b/cmd/cue/cmd/testdata/code/go/pkg2/add.cue
new file mode 100644
index 0000000..e1721e8
--- /dev/null
+++ b/cmd/cue/cmd/testdata/code/go/pkg2/add.cue
@@ -0,0 +1,19 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pkg2
+
+Barzer: {
+ S: =~"cat$"
+}
diff --git a/cmd/cue/cmd/testdata/code/go/pkg2/pkg2.go b/cmd/cue/cmd/testdata/code/go/pkg2/pkg2.go
new file mode 100644
index 0000000..42195d8
--- /dev/null
+++ b/cmd/cue/cmd/testdata/code/go/pkg2/pkg2.go
@@ -0,0 +1,42 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package pkg2 does other stuff.
+package pkg2
+
+import (
+ "math/big"
+ t "time"
+)
+
+// A Barzer barzes.
+type Barzer struct {
+ A int `protobuf:"varint,2," json:"a"`
+
+ T t.Time
+ B *big.Int
+ C big.Int
+ F big.Float `xml:",attr"`
+ G *big.Float
+ H bool `json:"-"`
+ S string
+
+ Err error
+}
+
+const Perm = 0755
+
+const Few = 3
+
+const Couple int = 2
diff --git a/cmd/cue/cmd/testdata/cue.mod b/cmd/cue/cmd/testdata/cue.mod
new file mode 100644
index 0000000..ab9fbdd
--- /dev/null
+++ b/cmd/cue/cmd/testdata/cue.mod
@@ -0,0 +1,14 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
diff --git a/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg1/file1_go_gen.cue b/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg1/file1_go_gen.cue
new file mode 100644
index 0000000..cd9b143
--- /dev/null
+++ b/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg1/file1_go_gen.cue
@@ -0,0 +1,76 @@
+// Code generated by cue get go. DO NOT EDIT.
+
+//cue:generate cue get go cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg1
+
+package pkg1
+
+import (
+ p2 "cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2"
+ "time"
+)
+
+// Foozer foozes a jaman.
+Foozer: Inline & {
+ Int: int
+ String: string
+ NoInline: NoInline
+ CustomJSON: CustomJSON
+ CustomYAML: null | CustomYAML @go(,*CustomYAML)
+ AnyJSON: _ @go(,json.Marshaler)
+ AnyText: string @go(,encoding.TextMarshaler)
+ bar?: int @go(Bar)
+
+ // Time is mapped to CUE's internal type.
+ Time: time.Time
+ Barzer: p2.Barzer
+ Map: {<_>: null | CustomJSON} @go(,map[string]*CustomJSON)
+ Slice1: [...int] @go(,[]int)
+ Slice2: [...] @go(,[]interface{})
+ Slice3: null | [...] @go(,*[]json.Unmarshaler)
+ Array1: 5 * [int] @go(,[5]int)
+ Array2: 5 * [_] @go(,[5]interface{})
+ Array3: null | 5*[_] @go(,*[5]json.Marshaler)
+ Intf: Interface @protobuf(2,varint,name=intf)
+ Intf2: _ @go(,interface{})
+ Intf3: {
+ Interface: Interface
+ } @go(,struct{Interface})
+ Intf4: _ @go(,"interface{Foo()}")
+
+ // Even though this struct as a type implements MarshalJSON, it is known
+ // that it is really only implemented by the embedded field.
+ Embed: {
+ CustomJSON: CustomJSON
+ } @go(,struct{CustomJSON})
+}
+
+// Level gives an indication of the extent of stuff.
+Level: int // enumLevel
+
+enumLevel:
+ Unknown |
+ Low |
+ Medium |
+ High
+
+Unknown: Level & 0
+Low: Level & 1
+
+// Medium is neither High nor Low
+Medium: Level & 2
+High: Level & 3
+
+CustomJSON: _
+
+CustomYAML: {
+}
+
+Inline: {
+ Kind: string
+}
+
+NoInline: {
+ Kind: string
+}
+
+Interface: _
diff --git a/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2/add_gen.cue b/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2/add_gen.cue
new file mode 100644
index 0000000..9cb7264
--- /dev/null
+++ b/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2/add_gen.cue
@@ -0,0 +1,23 @@
+// Code generated by cue get go. DO NOT EDIT.
+
+//cue:generate cue get go cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2
+
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pkg2
+
+Barzer: {
+ S: =~"cat$"
+}
diff --git a/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2/pkg2_go_gen.cue b/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2/pkg2_go_gen.cue
new file mode 100644
index 0000000..1cebd7c
--- /dev/null
+++ b/cmd/cue/cmd/testdata/pkg/cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2/pkg2_go_gen.cue
@@ -0,0 +1,28 @@
+// Code generated by cue get go. DO NOT EDIT.
+
+//cue:generate cue get go cuelang.org/go/cmd/cue/cmd/testdata/code/go/pkg2
+
+// Package pkg2 does other stuff.
+package pkg2
+
+import (
+ t "time"
+)
+
+// A Barzer barzes.
+Barzer: {
+ a: int @go(A) @protobuf(2,varint,)
+ T: t.Time
+ B: null | int @go(,*big.Int)
+ C: int @go(,big.Int)
+ F: string @go(,big.Float) @xml(,attr)
+ G: null | string @go(,*big.Float)
+ S: string
+ Err: _ @go(,error)
+}
+
+Perm: 0o755
+
+Few: 3
+
+Couple: int & 2
diff --git a/go.mod b/go.mod
index 00ad7ec..eb5f5ea 100644
--- a/go.mod
+++ b/go.mod
@@ -5,10 +5,10 @@
github.com/cockroachdb/apd v1.1.0
github.com/ghodss/yaml v1.0.0
github.com/google/go-cmp v0.2.0
- github.com/inconshreveable/mousetrap v1.0.0 // indirect
github.com/lib/pq v1.0.0 // indirect
github.com/mitchellh/go-homedir v1.0.0
github.com/pkg/errors v0.8.0 // indirect
+ github.com/retr0h/go-gilt v0.0.0-20190206215556-f73826b37af2
github.com/spf13/cobra v0.0.3
github.com/spf13/viper v1.3.1
golang.org/x/exp/errors v0.0.0-20181221233300-b68661188fbf
diff --git a/go.sum b/go.sum
index 2aa9834..b88224a 100644
--- a/go.sum
+++ b/go.sum
@@ -6,6 +6,7 @@
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
@@ -18,8 +19,10 @@
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d/go.mod h1:P2viExyCEfeWGU259JnaQ34Inuec4R38JCyBx2edgD0=
github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A=
github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
+github.com/logrusorgru/aurora v0.0.0-20180419164547-d694e6f975a9/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/mitchellh/go-homedir v1.0.0 h1:vKb8ShqSby24Yrqr/yDYkuFz8d0WUjys40rvnGC8aR0=
@@ -32,36 +35,47 @@
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/retr0h/go-gilt v0.0.0-20190206215556-f73826b37af2 h1:vZ42M1tDiMLtirFA1K5k2QVFhWRqR4BjdSw0IMclzH4=
+github.com/retr0h/go-gilt v0.0.0-20190206215556-f73826b37af2/go.mod h1:7PJr6TwZ6FwyTMn8zrm5QbMfH7yCiv56Wi9hRPhpWSM=
github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.1/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8=
github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.0/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/viper v1.3.1 h1:5+8j8FTpnFV4nEImW/ofkzEt8VoOiLXxdYIDsB73T38=
github.com/spf13/viper v1.3.1/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
+github.com/stretchr/testify v1.2.0/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
+github.com/xeipuuv/gojsonpointer v0.0.0-20170225233418-6fe8760cad35/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
+github.com/xeipuuv/gojsonreference v0.0.0-20150808065054-e02fc20de94c/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
+github.com/xeipuuv/gojsonschema v0.0.0-20171230112544-511d08a359d1/go.mod h1:5yf86TLmAcydyeJq5YvxkGPE2fm/u4myDekKRoLuqhs=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/exp/errors v0.0.0-20181221233300-b68661188fbf h1:4SQtY0VxhI0RZe/PFmCCfHyaPVuC5DgyXEqehsAWjwc=
golang.org/x/exp/errors v0.0.0-20181221233300-b68661188fbf/go.mod h1:YgqsNsAu4fTvlab/7uiYK9LJrCIzKg/NiZUIH1/ayqo=
+golang.org/x/lint v0.0.0-20181011164241-5906bd5c48cd/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f h1:Bl/8QSvNqXvPGPGXa2z5xUTmV7VDcZyvRZ+QQXkXTZQ=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a h1:1n5lsVfiQW3yfsRGu98756EH1YthsFqr/5mxHduZW2A=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/tools v0.0.0-20181018182439-def26773749b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181210225255-6a3e9aa2ab77 h1:s+6psEFi3o1QryeA/qyvUoVaHMCQkYVvZ0i2ZolwSJc=
golang.org/x/tools v0.0.0-20181210225255-6a3e9aa2ab77/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373 h1:PPwnA7z1Pjf7XYaBP9GL1VAMZmcIWyFz7QCMSIIa3Bg=
golang.org/x/xerrors v0.0.0-20190410155217-1f06c39b4373/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v2 v2.0.0/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
