internal/legacy/cue: copy relevant cue files for new implementation
Change-Id: I9c2549e0c37fdb4802265ce9c40753b4cc681f29
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/6518
Reviewed-by: Marcel van Lohuizen <mpvl@golang.org>
diff --git a/internal/legacy/cue/alias.go b/internal/legacy/cue/alias.go
new file mode 100644
index 0000000..ee438fc
--- /dev/null
+++ b/internal/legacy/cue/alias.go
@@ -0,0 +1,69 @@
+// Copyright 2020 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 cue
+
+import "cuelang.org/go/internal/core/adt"
+
+type (
+ bottom = adt.Bottom
+ source = adt.Node
+ errCode = adt.ErrorCode
+ kind = adt.Kind
+ nullLit = adt.Null
+ boolLit = adt.Bool
+ numLit = adt.Num
+ stringLit = adt.String
+ bytesLit = adt.Bytes
+ context = adt.OpContext
+ structLit = adt.Vertex
+
+ arc = *adt.Vertex
+ value = adt.Expr
+ evaluated = adt.Value
+ label = adt.Feature
+ Op = adt.Op
+
+ listLit = adt.ListLit
+ top = adt.Top
+ basicType = adt.BasicType
+ boundExpr = adt.BoundExpr
+ boundValue = adt.BoundValue
+ selectorExpr = adt.SelectorExpr
+ indexExpr = adt.IndexExpr
+ sliceExpr = adt.SliceExpr
+ interpolation = adt.Interpolation
+ unaryExpr = adt.UnaryExpr
+ binaryExpr = adt.BinaryExpr
+ callExpr = adt.CallExpr
+)
+
+const (
+ topKind = adt.TopKind
+ nullKind = adt.NullKind
+ boolKind = adt.BoolKind
+ numKind = adt.NumKind
+ intKind = adt.IntKind
+ floatKind = adt.FloatKind
+ stringKind = adt.StringKind
+ bytesKind = adt.BytesKind
+ listKind = adt.ListKind
+ structKind = adt.StructKind
+ bottomKind = adt.BottomKind
+
+ NoOp = adt.NoOp
+
+ codeIncomplete = adt.IncompleteError
+ codeNotExist = adt.IncompleteError
+)
diff --git a/internal/legacy/cue/build.go b/internal/legacy/cue/build.go
new file mode 100644
index 0000000..9f86daf
--- /dev/null
+++ b/internal/legacy/cue/build.go
@@ -0,0 +1,248 @@
+// 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 cue
+
+import (
+ "sync"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/ast/astutil"
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/runtime"
+)
+
+// A Runtime is used for creating CUE interpretations.
+//
+// Any operation that involves two Values or Instances should originate from
+// the same Runtime.
+//
+// The zero value of a Runtime is ready to use.
+type Runtime struct {
+ ctx *build.Context // TODO: remove
+ idx *index
+}
+
+func init() {
+ internal.GetRuntime = func(instance interface{}) interface{} {
+ switch x := instance.(type) {
+ case Value:
+ return &Runtime{idx: x.idx}
+
+ case *Instance:
+ return &Runtime{idx: x.index}
+
+ default:
+ panic("argument must be Value or *Instance")
+ }
+ }
+
+ internal.CheckAndForkRuntime = func(runtime, value interface{}) interface{} {
+ r := runtime.(*Runtime)
+ idx := value.(Value).ctx().index
+ if idx != r.idx {
+ panic("value not from same runtime")
+ }
+ return &Runtime{idx: newIndex(idx)}
+ }
+}
+
+func dummyLoad(token.Pos, string) *build.Instance { return nil }
+
+func (r *Runtime) index() *index {
+ if r.idx == nil {
+ r.idx = newIndex(sharedIndex)
+ }
+ return r.idx
+}
+
+func (r *Runtime) buildContext() *build.Context {
+ ctx := r.ctx
+ if r.ctx == nil {
+ ctx = build.NewContext()
+ }
+ return ctx
+}
+
+func (r *Runtime) complete(p *build.Instance) (*Instance, error) {
+ idx := r.index()
+ if err := p.Complete(); err != nil {
+ return nil, err
+ }
+ inst := idx.loadInstance(p)
+ inst.ImportPath = p.ImportPath
+ if inst.Err != nil {
+ return nil, inst.Err
+ }
+ return inst, nil
+}
+
+// Compile compiles the given source into an Instance. The source code may be
+// provided as a string, byte slice, io.Reader. The name is used as the file
+// name in position information. The source may import builtin packages. Use
+// Build to allow importing non-builtin packages.
+func (r *Runtime) Compile(filename string, source interface{}) (*Instance, error) {
+ ctx := r.buildContext()
+ p := ctx.NewInstance(filename, dummyLoad)
+ if err := p.AddFile(filename, source); err != nil {
+ return nil, p.Err
+ }
+ return r.complete(p)
+}
+
+// CompileFile compiles the given source file into an Instance. The source may
+// import builtin packages. Use Build to allow importing non-builtin packages.
+func (r *Runtime) CompileFile(file *ast.File) (*Instance, error) {
+ ctx := r.buildContext()
+ p := ctx.NewInstance(file.Filename, dummyLoad)
+ err := p.AddSyntax(file)
+ if err != nil {
+ return nil, err
+ }
+ _, p.PkgName, _ = internal.PackageInfo(file)
+ return r.complete(p)
+}
+
+// CompileExpr compiles the given source expression into an Instance. The source
+// may import builtin packages. Use Build to allow importing non-builtin
+// packages.
+func (r *Runtime) CompileExpr(expr ast.Expr) (*Instance, error) {
+ f, err := astutil.ToFile(expr)
+ if err != nil {
+ return nil, err
+ }
+ return r.CompileFile(f)
+}
+
+// Parse parses a CUE source value into a CUE Instance. The source code may
+// be provided as a string, byte slice, or io.Reader. The name is used as the
+// file name in position information. The source may import builtin packages.
+//
+// Deprecated: use Compile
+func (r *Runtime) Parse(name string, source interface{}) (*Instance, error) {
+ return r.Compile(name, source)
+}
+
+// Build creates an Instance from the given build.Instance. A returned Instance
+// may be incomplete, in which case its Err field is set.
+func (r *Runtime) Build(instance *build.Instance) (*Instance, error) {
+ return r.complete(instance)
+}
+
+// Build creates one Instance for each build.Instance. A returned Instance
+// may be incomplete, in which case its Err field is set.
+//
+// Example:
+// inst := cue.Build(load.Instances(args))
+//
+func Build(instances []*build.Instance) []*Instance {
+ if len(instances) == 0 {
+ panic("cue: list of instances must not be empty")
+ }
+ var r Runtime
+ a, _ := r.build(instances)
+ return a
+}
+
+func (r *Runtime) build(instances []*build.Instance) ([]*Instance, error) {
+ index := r.index()
+
+ loaded := []*Instance{}
+
+ var errs errors.Error
+
+ for _, p := range instances {
+ _ = p.Complete()
+ errs = errors.Append(errs, p.Err)
+
+ i := index.loadInstance(p)
+ errs = errors.Append(errs, i.Err)
+ loaded = append(loaded, i)
+ }
+
+ // TODO: insert imports
+ return loaded, errs
+}
+
+// FromExpr creates an instance from an expression.
+// Any references must be resolved beforehand.
+//
+// Deprecated: use CompileExpr
+func (r *Runtime) FromExpr(expr ast.Expr) (*Instance, error) {
+ return r.CompileFile(&ast.File{
+ Decls: []ast.Decl{&ast.EmbedDecl{Expr: expr}},
+ })
+}
+
+// index maps conversions from label names to internal codes.
+//
+// All instances belonging to the same package should share this index.
+type index struct {
+ *runtime.Index
+
+ loaded map[*build.Instance]*Instance
+ mutex sync.Mutex
+}
+
+// sharedIndex is used for indexing builtins and any other labels common to
+// all instances.
+var sharedIndex = &index{
+ Index: runtime.SharedIndex,
+ loaded: map[*build.Instance]*Instance{},
+}
+
+// newIndex creates a new index.
+func newIndex(parent *index) *index {
+ return &index{
+ Index: runtime.NewIndex(parent.Index),
+ loaded: map[*build.Instance]*Instance{},
+ }
+}
+
+func isBuiltin(s string) bool {
+ _, ok := builtins[s]
+ return ok
+}
+
+func (idx *index) loadInstance(p *build.Instance) *Instance {
+ if inst := idx.loaded[p]; inst != nil {
+ if !inst.complete {
+ // cycles should be detected by the builder and it should not be
+ // possible to construct a build.Instance that has them.
+ panic("cue: cycle")
+ }
+ return inst
+ }
+ errs := runtime.ResolveFiles(idx.Index, p, isBuiltin)
+ files := p.Files
+ inst := newInstance(idx, p)
+ idx.loaded[p] = inst
+
+ if inst.Err == nil {
+ // inst.instance.index.state = s
+ // inst.instance.inst = p
+ inst.Err = errs
+ for _, f := range files {
+ err := inst.insertFile(f)
+ inst.Err = errors.Append(inst.Err, err)
+ }
+ }
+ inst.ImportPath = p.ImportPath
+
+ inst.complete = true
+ return inst
+}
diff --git a/internal/legacy/cue/build_test.go b/internal/legacy/cue/build_test.go
new file mode 100644
index 0000000..7817ec7
--- /dev/null
+++ b/internal/legacy/cue/build_test.go
@@ -0,0 +1,259 @@
+// 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 cue
+
+import (
+ "fmt"
+ "strings"
+ "testing"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/token"
+)
+
+func TestFromExpr(t *testing.T) {
+ testCases := []struct {
+ expr ast.Expr
+ out string
+ }{{
+ expr: ast.NewString("Hello"),
+ out: `"Hello"`,
+ }, {
+ expr: ast.NewList(
+ ast.NewString("Hello"),
+ ast.NewString("World"),
+ ),
+ out: `["Hello","World"]`,
+ }}
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ r := &Runtime{}
+ inst, err := r.CompileExpr(tc.expr)
+ if err != nil {
+ t.Fatal(err)
+ }
+ ctx := inst.newContext()
+ if got := debugStr(ctx, inst.eval(ctx)); got != tc.out {
+ t.Errorf("\n got: %v; want %v", got, tc.out)
+ }
+ })
+ }
+}
+
+func TestBuild(t *testing.T) {
+ files := func(s ...string) []string { return s }
+ insts := func(i ...*bimport) []*bimport { return i }
+ pkg1 := &bimport{
+ "pkg1",
+ files(`
+ package pkg1
+
+ Object: "World"
+ `),
+ }
+ pkg2 := &bimport{
+ "example.com/foo/pkg2:pkg",
+ files(`
+ package pkg
+
+ Number: 12
+ `),
+ }
+ pkg3 := &bimport{
+ "example.com/foo/v1:pkg3",
+ files(`
+ package pkg3
+
+ List: [1,2,3]
+ `),
+ }
+
+ testCases := []struct {
+ instances []*bimport
+ emit string
+ }{{
+ insts(&bimport{"", files(`test: "ok"`)}),
+ `{test: "ok"}`,
+ }, {
+ insts(&bimport{"",
+ files(
+ `package test
+
+ import "math"
+
+ "Pi: \(math.Pi)!"`)}),
+ `"Pi: 3.14159265358979323846264338327950288419716939937510582097494459!"`,
+ }, {
+ insts(&bimport{"",
+ files(
+ `package test
+
+ import math2 "math"
+
+ "Pi: \(math2.Pi)!"`)}),
+ `"Pi: 3.14159265358979323846264338327950288419716939937510582097494459!"`,
+ }, {
+ insts(pkg1, &bimport{"",
+ files(
+ `package test
+
+ import "pkg1"
+
+ "Hello \(pkg1.Object)!"`),
+ }),
+ `"Hello World!"`,
+ }, {
+ insts(pkg1, &bimport{"",
+ files(
+ `package test
+
+ import "pkg1"
+
+ "Hello \(pkg1.Object)!"`),
+ }),
+ `"Hello World!"`,
+ }, {
+ insts(pkg1, &bimport{"",
+ files(
+ `package test
+
+ import pkg2 "pkg1"
+ #pkg1: pkg2.Object
+
+ "Hello \(#pkg1)!"`),
+ }),
+ `"Hello World!"`,
+ }, {
+ insts(pkg1, pkg2, &bimport{"",
+ files(
+ `package test
+
+ import bar "pkg1"
+ import baz "example.com/foo/pkg2:pkg"
+
+ pkg1: Object: 3
+ "Hello \(pkg1.Object)!"`),
+ }),
+ `imported and not used: "pkg1" as bar (and 1 more errors)`,
+ }, {
+ insts(pkg2, &bimport{"",
+ files(
+ `package test
+
+ import "example.com/foo/pkg2:pkg"
+
+ "Hello \(pkg2.Number)!"`),
+ }),
+ `imported and not used: "example.com/foo/pkg2:pkg" (and 1 more errors)`,
+ // `file0.cue:5:14: unresolved reference pkg2`,
+ }, {
+ insts(pkg2, &bimport{"",
+ files(
+ `package test
+
+ import "example.com/foo/pkg2:pkg"
+
+ "Hello \(pkg.Number)!"`),
+ }),
+ `"Hello 12!"`,
+ }, {
+ insts(pkg3, &bimport{"",
+ files(
+ `package test
+
+ import "example.com/foo/v1:pkg3"
+
+ "Hello \(pkg3.List[1])!"`),
+ }),
+ `"Hello 2!"`,
+ }, {
+ insts(pkg3, &bimport{"",
+ files(
+ `package test
+
+ import "example.com/foo/v1:pkg3"
+
+ pkg3: 3
+
+ "Hello \(pkg3.List[1])!"`),
+ }),
+ `pkg3 redeclared as imported package name
+ previous declaration at file0.cue:5:5`,
+ }}
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ insts := Build(makeInstances(tc.instances))
+ var got string
+ if err := insts[0].Err; err != nil {
+ got = err.Error()
+ } else {
+ got = strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+ }
+ if got != tc.emit {
+ t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
+ }
+ })
+ }
+}
+
+type builder struct {
+ ctxt *build.Context
+ imports map[string]*bimport
+}
+
+func (b *builder) load(pos token.Pos, path string) *build.Instance {
+ bi := b.imports[path]
+ if bi == nil {
+ return nil
+ }
+ return b.build(bi)
+}
+
+type bimport struct {
+ path string // "" means top-level
+ files []string
+}
+
+func makeInstances(insts []*bimport) (instances []*build.Instance) {
+ b := builder{
+ ctxt: build.NewContext(),
+ imports: map[string]*bimport{},
+ }
+ for _, bi := range insts {
+ if bi.path != "" {
+ b.imports[bi.path] = bi
+ }
+ }
+ for _, bi := range insts {
+ if bi.path == "" {
+ instances = append(instances, b.build(bi))
+ }
+ }
+ return
+}
+
+func (b *builder) build(bi *bimport) *build.Instance {
+ path := bi.path
+ if path == "" {
+ path = "dir"
+ }
+ p := b.ctxt.NewInstance(path, b.load)
+ for i, f := range bi.files {
+ _ = p.AddFile(fmt.Sprintf("file%d.cue", i), f)
+ }
+ _ = p.Complete()
+ return p
+}
diff --git a/internal/legacy/cue/builtin.go b/internal/legacy/cue/builtin.go
new file mode 100644
index 0000000..cfd98a6
--- /dev/null
+++ b/internal/legacy/cue/builtin.go
@@ -0,0 +1,656 @@
+// 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.
+
+//go:generate go run gen.go
+//go:generate go run golang.org/x/tools/cmd/goimports -w -local cuelang.org/go builtins.go
+//go:generate gofmt -s -w builtins.go
+
+package cue
+
+import (
+ "encoding/json"
+ "fmt"
+ "io"
+ "math/big"
+ "path"
+ "sort"
+ "strings"
+
+ "github.com/cockroachdb/apd/v2"
+
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/parser"
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal"
+)
+
+// A builtin is a builtin function or constant.
+//
+// A function may return and a constant may be any of the following types:
+//
+// error (translates to bottom)
+// nil (translates to null)
+// bool
+// int*
+// uint*
+// float64
+// string
+// *big.Float
+// *big.Int
+//
+// For any of the above, including interface{} and these types recursively:
+// []T
+// map[string]T
+//
+type builtin struct {
+ baseValue
+ Name string
+ pkg label
+ Params []kind
+ Result kind
+ Func func(c *callCtxt)
+ // Const interface{}
+ Const string
+}
+
+type builtinPkg struct {
+ native []*builtin
+ cue string
+}
+
+func mustCompileBuiltins(ctx *context, p *builtinPkg, pkgName string) *structLit {
+ obj := &structLit{}
+ pkgLabel := ctx.Label(pkgName, false)
+ for _, b := range p.native {
+ b.pkg = pkgLabel
+
+ f := ctx.Label(b.Name, false) // never starts with _
+ // n := &node{baseValue: newBase(imp.Path)}
+ var v evaluated = b
+ if b.Const != "" {
+ v = mustParseConstBuiltin(ctx, b.Name, b.Const)
+ }
+ obj.Arcs = append(obj.Arcs, arc{Label: f, v: v})
+ }
+ sort.Sort(obj)
+
+ // Parse builtin CUE
+ if p.cue != "" {
+ expr, err := parser.ParseExpr(pkgName, p.cue)
+ if err != nil {
+ panic(fmt.Errorf("could not parse %v: %v", p.cue, err))
+ }
+ v := newVisitor(ctx.index, nil, nil, nil, false)
+ value := v.walk(expr)
+ pkg := value.evalPartial(ctx).(*structLit)
+ for _, a := range pkg.Arcs {
+ // Discard option status and attributes at top level.
+ // TODO: filter on capitalized fields?
+ obj.insertValue(ctx, a.Label, false, false, a.v, nil, a.docs)
+ }
+ }
+
+ return obj
+}
+
+// newConstBuiltin parses and creates any CUE expression that does not have
+// fields.
+func mustParseConstBuiltin(ctx *context, name, val string) evaluated {
+ expr, err := parser.ParseExpr("<builtin:"+name+">", val)
+ if err != nil {
+ panic(err)
+ }
+ v := newVisitor(ctx.index, nil, nil, nil, false)
+ value := v.walk(expr)
+ return value.evalPartial(ctx)
+}
+
+var _ caller = &builtin{}
+
+var lenBuiltin = &builtin{
+ Name: "len",
+ Params: []kind{stringKind | bytesKind | listKind | structKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ v := c.value(0)
+ switch k := v.IncompleteKind(); k {
+ case StructKind:
+ s, err := v.structValData(c.ctx)
+ if err != nil {
+ c.ret = err
+ break
+ }
+ c.ret = s.Len()
+ case ListKind:
+ i := 0
+ iter, err := v.List()
+ if err != nil {
+ c.ret = err
+ break
+ }
+ for ; iter.Next(); i++ {
+ }
+ c.ret = i
+ case BytesKind:
+ b, err := v.Bytes()
+ if err != nil {
+ c.ret = err
+ break
+ }
+ c.ret = len(b)
+ case StringKind:
+ s, err := v.String()
+ if err != nil {
+ c.ret = err
+ break
+ }
+ c.ret = len(s)
+ default:
+ c.ret = errors.Newf(token.NoPos,
+ "invalid argument type %v", k)
+ }
+ },
+}
+
+var closeBuiltin = &builtin{
+ Name: "close",
+ Params: []kind{structKind},
+ Result: structKind,
+ Func: func(c *callCtxt) {
+ s, ok := c.args[0].(*structLit)
+ if !ok {
+ c.ret = errors.Newf(c.args[0].Pos(), "struct argument must be concrete")
+ return
+ }
+ c.ret = s.close()
+ },
+}
+
+var andBuiltin = &builtin{
+ Name: "and",
+ Params: []kind{listKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ iter := c.iter(0)
+ if !iter.Next() {
+ c.ret = &top{baseValue{c.src}}
+ return
+ }
+ u := iter.Value().v.v
+ for iter.Next() {
+ u = mkBin(c.ctx, c.src.Pos(), opUnify, u, iter.Value().v.v)
+ }
+ c.ret = u
+ },
+}
+
+var orBuiltin = &builtin{
+ Name: "or",
+ Params: []kind{listKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ iter := c.iter(0)
+ d := []dValue{}
+ for iter.Next() {
+ d = append(d, dValue{iter.Value().v.v, false})
+ }
+ c.ret = &disjunction{baseValue{c.src}, d, nil, false}
+ if len(d) == 0 {
+ // TODO(manifest): This should not be unconditionally incomplete,
+ // but it requires results from comprehensions and all to have
+ // some special status. Maybe this can be solved by having results
+ // of list comprehensions be open if they result from iterating over
+ // an open list or struct. This would actually be exactly what
+ // that means. The error here could then only add an incomplete
+ // status if the source is open.
+ c.ret = c.ctx.mkErr(c.src, codeIncomplete, "empty list in call to or")
+ }
+ },
+}
+
+func (x *builtin) representedKind() kind {
+ if x.isValidator() {
+ return x.Params[0]
+ }
+ return x.Kind()
+}
+
+func (x *builtin) Kind() kind {
+ return lambdaKind
+}
+
+func (x *builtin) evalPartial(ctx *context) evaluated {
+ return x
+}
+
+func (x *builtin) subsumesImpl(s *subsumer, v value) bool {
+ if y, ok := v.(*builtin); ok {
+ return x == y
+ }
+ return false
+}
+
+func (x *builtin) name(ctx *context) string {
+ if x.pkg == 0 {
+ return x.Name
+ }
+ return fmt.Sprintf("%s.%s", ctx.LabelStr(x.pkg), x.Name)
+}
+
+func (x *builtin) isValidator() bool {
+ return len(x.Params) == 1 && x.Result == boolKind
+}
+
+func convertBuiltin(v evaluated) evaluated {
+ x, ok := v.(*builtin)
+ if ok && x.isValidator() {
+ return &customValidator{v.base(), x, []evaluated{}}
+ }
+ return v
+}
+
+func (x *builtin) call(ctx *context, src source, args ...evaluated) (ret value) {
+ if x.Func == nil {
+ return ctx.mkErr(x, "builtin %s is not a function", x.name(ctx))
+ }
+ if len(x.Params)-1 == len(args) && x.Result == boolKind {
+ // We have a custom builtin
+ return &customValidator{src.base(), x, args}
+ }
+ switch {
+ case len(x.Params) < len(args):
+ return ctx.mkErr(src, x, "too many arguments in call to %s (have %d, want %d)",
+ x.name(ctx), len(args), len(x.Params))
+ case len(x.Params) > len(args):
+ return ctx.mkErr(src, x, "not enough arguments in call to %s (have %d, want %d)",
+ x.name(ctx), len(args), len(x.Params))
+ }
+ for i, a := range args {
+ if x.Params[i] != bottomKind {
+ if unifyType(x.Params[i], a.Kind()) == bottomKind {
+ const msg = "cannot use %s (type %s) as %s in argument %d to %s"
+ return ctx.mkErr(src, x, msg, ctx.str(a), a.Kind(), x.Params[i], i+1, x.name(ctx))
+ }
+ }
+ }
+ call := callCtxt{src: src, ctx: ctx, builtin: x, args: args}
+ defer func() {
+ var errVal interface{} = call.err
+ if err := recover(); err != nil {
+ errVal = err
+ }
+ ret = processErr(&call, errVal, ret)
+ }()
+ x.Func(&call)
+ switch v := call.ret.(type) {
+ case value:
+ return v
+ case *valueError:
+ return v.err
+ }
+ return convertVal(ctx, x, true, call.ret)
+}
+
+func processErr(call *callCtxt, errVal interface{}, ret value) value {
+ ctx := call.ctx
+ x := call.builtin
+ src := call.src
+ const msg = "error in call to %s: %v"
+ switch err := errVal.(type) {
+ case nil:
+ case *callError:
+ ret = err.b
+ case *json.MarshalerError:
+ if err, ok := err.Err.(*marshalError); ok && err.b != nil {
+ ret = err.b
+ }
+ case *marshalError:
+ ret = err.b
+ ret = ctx.mkErr(src, x, ret, msg, x.name(ctx), err)
+ case *valueError:
+ ret = err.err
+ ret = ctx.mkErr(src, x, ret, msg, x.name(ctx), err)
+ default:
+ if call.err == internal.ErrIncomplete {
+ ret = ctx.mkErr(src, codeIncomplete, "incomplete value")
+ } else {
+ // TODO: store the underlying error explicitly
+ ret = ctx.mkErr(src, x, msg, x.name(ctx), err)
+ }
+ }
+ return ret
+}
+
+// callCtxt is passed to builtin implementations.
+type callCtxt struct {
+ src source
+ ctx *context
+ builtin *builtin
+ args []evaluated
+ err error
+ ret interface{}
+}
+
+func (c *callCtxt) name() string {
+ return c.builtin.name(c.ctx)
+}
+
+var builtins = map[string]*Instance{}
+
+func initBuiltins(pkgs map[string]*builtinPkg) {
+ ctx := sharedIndex.newContext()
+ keys := []string{}
+ for k := range pkgs {
+ keys = append(keys, k)
+ }
+ sort.Strings(keys)
+ for _, k := range keys {
+ b := pkgs[k]
+ e := mustCompileBuiltins(ctx, b, k)
+
+ i := sharedIndex.addInst(&Instance{
+ ImportPath: k,
+ PkgName: path.Base(k),
+ rootStruct: e,
+ rootValue: e,
+ })
+
+ builtins[k] = i
+ builtins["-/"+path.Base(k)] = i
+ }
+}
+
+func getBuiltinShorthandPkg(ctx *context, shorthand string) *structLit {
+ return getBuiltinPkg(ctx, "-/"+shorthand)
+}
+
+func getBuiltinPkg(ctx *context, path string) *structLit {
+ p, ok := builtins[path]
+ if !ok {
+ return nil
+ }
+ return p.rootStruct
+}
+
+func init() {
+ internal.UnifyBuiltin = func(val interface{}, kind string) interface{} {
+ v := val.(Value)
+ ctx := v.ctx()
+
+ p := strings.Split(kind, ".")
+ pkg, name := p[0], p[1]
+ s := getBuiltinPkg(ctx, pkg)
+ if s == nil {
+ return v
+ }
+ a := s.Lookup(ctx, ctx.Label(name, false))
+ if a.v == nil {
+ return v
+ }
+
+ return v.Unify(newValueRoot(ctx, a.v.evalPartial(ctx)))
+ }
+}
+
+// do returns whether the call should be done.
+func (c *callCtxt) do() bool {
+ return c.err == nil
+}
+
+type callError struct {
+ b *bottom
+}
+
+func (e *callError) Error() string {
+ return fmt.Sprint(e.b)
+}
+
+func (c *callCtxt) errf(src source, underlying error, format string, args ...interface{}) {
+ a := make([]interface{}, 0, 2+len(args))
+ if err, ok := underlying.(*valueError); ok {
+ a = append(a, err.err)
+ }
+ a = append(a, format)
+ a = append(a, args...)
+ err := c.ctx.mkErr(src, a...)
+ c.err = &callError{err}
+}
+
+func (c *callCtxt) value(i int) Value {
+ v := newValueRoot(c.ctx, c.args[i])
+ v, _ = v.Default()
+ if !v.IsConcrete() {
+ c.errf(c.src, v.toErr(c.ctx.mkErr(c.src, codeIncomplete,
+ "non-concrete value")), "incomplete")
+ }
+ return v
+}
+
+func (c *callCtxt) structVal(i int) *Struct {
+ v := newValueRoot(c.ctx, c.args[i])
+ s, err := v.Struct()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "struct", err)
+ return nil
+ }
+ return s
+}
+
+func (c *callCtxt) invalidArgType(arg value, i int, typ string, err error) {
+ if err != nil {
+ c.errf(c.src, err, "cannot use %s (type %s) as %s in argument %d to %s: %v",
+ c.ctx.str(arg), arg.Kind(), typ, i, c.name(), err)
+ } else {
+ c.errf(c.src, nil, "cannot use %s (type %s) as %s in argument %d to %s",
+ c.ctx.str(arg), arg.Kind(), typ, i, c.name())
+ }
+}
+
+func (c *callCtxt) int(i int) int { return int(c.intValue(i, 64, "int64")) }
+func (c *callCtxt) int8(i int) int8 { return int8(c.intValue(i, 8, "int8")) }
+func (c *callCtxt) int16(i int) int16 { return int16(c.intValue(i, 16, "int16")) }
+func (c *callCtxt) int32(i int) int32 { return int32(c.intValue(i, 32, "int32")) }
+func (c *callCtxt) rune(i int) rune { return rune(c.intValue(i, 32, "rune")) }
+func (c *callCtxt) int64(i int) int64 { return int64(c.intValue(i, 64, "int64")) }
+
+func (c *callCtxt) intValue(i, bits int, typ string) int64 {
+ arg := c.args[i]
+ x := newValueRoot(c.ctx, arg)
+ n, err := x.Int(nil)
+ if err != nil {
+ c.invalidArgType(arg, i, typ, err)
+ return 0
+ }
+ if n.BitLen() > bits {
+ c.errf(c.src, err, "int %s overflows %s in argument %d in call to %s",
+ n, typ, i, c.name())
+ }
+ res, _ := x.Int64()
+ return res
+}
+
+func (c *callCtxt) uint(i int) uint { return uint(c.uintValue(i, 64, "uint64")) }
+func (c *callCtxt) uint8(i int) uint8 { return uint8(c.uintValue(i, 8, "uint8")) }
+func (c *callCtxt) byte(i int) uint8 { return byte(c.uintValue(i, 8, "byte")) }
+func (c *callCtxt) uint16(i int) uint16 { return uint16(c.uintValue(i, 16, "uint16")) }
+func (c *callCtxt) uint32(i int) uint32 { return uint32(c.uintValue(i, 32, "uint32")) }
+func (c *callCtxt) uint64(i int) uint64 { return uint64(c.uintValue(i, 64, "uint64")) }
+
+func (c *callCtxt) uintValue(i, bits int, typ string) uint64 {
+ x := newValueRoot(c.ctx, c.args[i])
+ n, err := x.Int(nil)
+ if err != nil || n.Sign() < 0 {
+ c.invalidArgType(c.args[i], i, typ, err)
+ return 0
+ }
+ if n.BitLen() > bits {
+ c.errf(c.src, err, "int %s overflows %s in argument %d in call to %s",
+ n, typ, i, c.name())
+ }
+ res, _ := x.Uint64()
+ return res
+}
+
+func (c *callCtxt) decimal(i int) *apd.Decimal {
+ x := newValueRoot(c.ctx, c.args[i])
+ if _, err := x.MantExp(nil); err != nil {
+ c.invalidArgType(c.args[i], i, "Decimal", err)
+ return nil
+ }
+ return &c.args[i].(*numLit).X
+}
+
+func (c *callCtxt) float64(i int) float64 {
+ x := newValueRoot(c.ctx, c.args[i])
+ res, err := x.Float64()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "float64", err)
+ return 0
+ }
+ return res
+}
+
+func (c *callCtxt) bigInt(i int) *big.Int {
+ x := newValueRoot(c.ctx, c.args[i])
+ n, err := x.Int(nil)
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "int", err)
+ return nil
+ }
+ return n
+}
+
+func (c *callCtxt) bigFloat(i int) *big.Float {
+ x := newValueRoot(c.ctx, c.args[i])
+ var mant big.Int
+ exp, err := x.MantExp(&mant)
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "float", err)
+ return nil
+ }
+ f := &big.Float{}
+ f.SetInt(&mant)
+ if exp != 0 {
+ var g big.Float
+ e := big.NewInt(int64(exp))
+ f.Mul(f, g.SetInt(e.Exp(ten, e, nil)))
+ }
+ return f
+}
+
+func (c *callCtxt) string(i int) string {
+ x := newValueRoot(c.ctx, c.args[i])
+ v, err := x.String()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "string", err)
+ return ""
+ }
+ return v
+}
+
+func (c *callCtxt) bytes(i int) []byte {
+ x := newValueRoot(c.ctx, c.args[i])
+ v, err := x.Bytes()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "bytes", err)
+ return nil
+ }
+ return v
+}
+
+func (c *callCtxt) reader(i int) io.Reader {
+ x := newValueRoot(c.ctx, c.args[i])
+ // TODO: optimize for string and bytes cases
+ r, err := x.Reader()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "bytes|string", err)
+ return nil
+ }
+ return r
+}
+
+func (c *callCtxt) bool(i int) bool {
+ x := newValueRoot(c.ctx, c.args[i])
+ b, err := x.Bool()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "bool", err)
+ return false
+ }
+ return b
+}
+
+func (c *callCtxt) list(i int) (a []Value) {
+ arg := c.args[i]
+ x := newValueRoot(c.ctx, arg)
+ v, err := x.List()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "list", err)
+ return a
+ }
+ for v.Next() {
+ a = append(a, v.Value())
+ }
+ return a
+}
+
+func (c *callCtxt) iter(i int) (a Iterator) {
+ arg := c.args[i]
+ x := newValueRoot(c.ctx, arg)
+ v, err := x.List()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "list", err)
+ return Iterator{ctx: c.ctx}
+ }
+ return v
+}
+
+func (c *callCtxt) decimalList(i int) (a []*apd.Decimal) {
+ arg := c.args[i]
+ x := newValueRoot(c.ctx, arg)
+ v, err := x.List()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "list", err)
+ return nil
+ }
+ for j := 0; v.Next(); j++ {
+ num, err := v.Value().getNum(numKind)
+ if err != nil {
+ c.errf(c.src, err, "invalid list element %d in argument %d to %s: %v",
+ j, i, c.name(), err)
+ break
+ }
+ a = append(a, &num.X)
+ }
+ return a
+}
+
+func (c *callCtxt) strList(i int) (a []string) {
+ arg := c.args[i]
+ x := newValueRoot(c.ctx, arg)
+ v, err := x.List()
+ if err != nil {
+ c.invalidArgType(c.args[i], i, "list", err)
+ return nil
+ }
+ for j := 0; v.Next(); j++ {
+ str, err := v.Value().String()
+ if err != nil {
+ c.errf(c.src, err, "invalid list element %d in argument %d to %s: %v",
+ j, i, c.name(), err)
+ break
+ }
+ a = append(a, str)
+ }
+ return a
+}
diff --git a/internal/legacy/cue/builtin_test.go b/internal/legacy/cue/builtin_test.go
new file mode 100644
index 0000000..1901d34
--- /dev/null
+++ b/internal/legacy/cue/builtin_test.go
@@ -0,0 +1,678 @@
+// 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 cue
+
+import (
+ "fmt"
+ "math/big"
+ "strconv"
+ "strings"
+ "testing"
+)
+
+func TestBuiltins(t *testing.T) {
+ test := func(pkg, expr string) []*bimport {
+ return []*bimport{{"",
+ []string{fmt.Sprintf("import %q\n(%s)", pkg, expr)},
+ }}
+ }
+ testExpr := func(expr string) []*bimport {
+ return []*bimport{{"",
+ []string{fmt.Sprintf("(%s)", expr)},
+ }}
+ }
+ hexToDec := func(s string) string {
+ var x big.Int
+ x.SetString(s, 16)
+ return x.String()
+ }
+ testCases := []struct {
+ instances []*bimport
+ emit string
+ }{{
+ test("math", "math.Pi"),
+ `3.14159265358979323846264338327950288419716939937510582097494459`,
+ }, {
+ test("math", "math.Floor(math.Pi)"),
+ `3`,
+ }, {
+ test("math", "math.Pi(3)"),
+ `_|_(cannot call non-function Pi (type float))`,
+ }, {
+ test("math", "math.Floor(3, 5)"),
+ `_|_(too many arguments in call to math.Floor (have 2, want 1))`,
+ }, {
+ test("math", `math.Floor("foo")`),
+ `_|_(cannot use "foo" (type string) as number in argument 1 to math.Floor)`,
+ }, {
+ test("crypto/sha256", `sha256.Sum256("hash me")`),
+ `'\xeb \x1a\xf5\xaa\xf0\xd6\x06)\xd3Ò¦\x1eFl\xfc\x0f\xed\xb5\x17\xad\xd81\xec\xacR5\xe1Ú©c\xd6'`,
+ }, {
+ test("crypto/md5", `len(md5.Sum("hash me"))`),
+ `16`,
+ }, {
+ test("crypto/sha1", `len(sha1.Sum("hash me"))`),
+ `20`,
+ }, {
+ test("crypto/sha256", `len(sha256.Sum256("hash me"))`),
+ `32`,
+ }, {
+ test("crypto/sha256", `len(sha256.Sum224("hash me"))`),
+ `28`,
+ }, {
+ test("crypto/sha512", `len(sha512.Sum512("hash me"))`),
+ `64`,
+ }, {
+ test("crypto/sha512", `len(sha512.Sum384("hash me"))`),
+ `48`,
+ }, {
+ test("crypto/sha512", `len(sha512.Sum512_224("hash me"))`),
+ `28`,
+ }, {
+ test("crypto/sha512", `len(sha512.Sum512_256("hash me"))`),
+ `32`,
+ }, {
+ test("encoding/base64", `base64.Encode(null, "foo")`),
+ `"Zm9v"`,
+ }, {
+ test("encoding/base64", `base64.Decode(null, base64.Encode(null, "foo"))`),
+ `'foo'`,
+ }, {
+ test("encoding/base64", `base64.Decode(null, "foo")`),
+ `_|_(error in call to encoding/base64.Decode: illegal base64 data at input byte 0)`,
+ }, {
+ test("encoding/base64", `base64.Decode({}, "foo")`),
+ `_|_(error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null)`,
+ }, {
+ test("encoding/hex", `hex.Encode("foo")`),
+ `"666f6f"`,
+ }, {
+ test("encoding/hex", `hex.Decode(hex.Encode("foo"))`),
+ `'foo'`,
+ }, {
+ test("encoding/hex", `hex.Decode("foo")`),
+ `_|_(error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o')`,
+ }, {
+ test("encoding/hex", `hex.Dump('foo')`),
+ `"00000000 66 6f 6f |foo|\n"`,
+ }, {
+ test("encoding/json", `json.Validate("{\"a\":10}", {b:string})`),
+ `true`,
+ }, {
+ test("encoding/json", `json.Validate("{\"a\":10}", {a:<3})`),
+ `_|_(error in call to encoding/json.Validate: a: invalid value 10 (out of bound <3))`,
+ }, {
+ test("encoding/yaml", `yaml.Validate("a: 2\n---\na: 4", {a:<3})`),
+ `_|_(error in call to encoding/yaml.Validate: a: invalid value 4 (out of bound <3))`,
+ }, {
+ test("encoding/yaml", `yaml.Validate("a: 2\n---\na: 4", {a:<5})`),
+ `true`,
+ }, {
+ test("encoding/yaml", `yaml.Validate("a: 2\n", {a:<5, b:int})`),
+ `_|_(error in call to encoding/yaml.Validate: b: incomplete value (int))`,
+ }, {
+ test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<3})`),
+ `_|_(error in call to encoding/yaml.ValidatePartial: a: invalid value 4 (out of bound <3))`,
+ }, {
+ test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<5})`),
+ `true`,
+ }, {
+ test("encoding/yaml", `yaml.ValidatePartial("a: 2\n", {a:<5, b:int})`),
+ `true`,
+ }, {
+ test("strconv", `strconv.FormatUint(64, 16)`),
+ `"40"`,
+ }, {
+ // Find a better alternative, as this call should go.
+ test("strconv", `strconv.FormatFloat(3.02, 300, 4, 64)`),
+ `_|_(int 300 overflows byte in argument 1 in call to strconv.FormatFloat)`,
+ }, {
+ // Find a better alternative, as this call should go.
+ test("strconv", `strconv.FormatFloat(3.02, -1, 4, 64)`),
+ `_|_(cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat)`,
+ }, {
+ // Find a better alternative, as this call should go.
+ test("strconv", `strconv.FormatFloat(3.02, 1.0, 4, 64)`),
+ `_|_(cannot use 1.0 (type float) as int in argument 2 to strconv.FormatFloat)`,
+ }, {
+ test("list", `list.Avg([1, 2, 3, 4])`),
+ `2.5`,
+ }, {
+ test("list", `list.Avg([])`),
+ `_|_(error in call to list.Avg: empty list)`,
+ }, {
+ test("list", `list.Avg("foo")`),
+ `_|_(cannot use "foo" (type string) as list in argument 1 to list.Avg)`,
+ }, {
+ test("list", `list.Drop([1, 2, 3, 4], 0)`),
+ `[1,2,3,4]`,
+ }, {
+ test("list", `list.Drop([1, 2, 3, 4], 2)`),
+ `[3,4]`,
+ }, {
+ test("list", `list.Drop([1, 2, 3, 4], 10)`),
+ `[]`,
+ }, {
+ test("list", `list.Drop([1, 2, 3, 4], -1)`),
+ `_|_(error in call to list.Drop: negative index)`,
+ }, {
+ test("list", `list.FlattenN([1, [[2, 3], []], [4]], -1)`),
+ `[1,2,3,4]`,
+ }, {
+ test("list", `list.FlattenN([1, [[2, 3], []], [4]], 0)`),
+ `[1,[[2,3],[]],[4]]`,
+ }, {
+ test("list", `list.FlattenN([1, [[2, 3], []], [4]], 1)`),
+ `[1,[2,3],[],4]`,
+ }, {
+ test("list", `list.FlattenN([1, [[2, 3], []], [4]], 2)`),
+ `[1,2,3,4]`,
+ }, {
+ test("list", `list.FlattenN([[1, 2] | *[]], -1)`),
+ `[]`,
+ }, {
+ test("list", `list.FlattenN("foo", 1)`),
+ `_|_(error in call to list.FlattenN: cannot use value "foo" (type string) as list)`,
+ }, {
+ test("list", `list.FlattenN([], "foo")`),
+ `_|_(cannot use "foo" (type string) as int in argument 2 to list.FlattenN)`,
+ }, {
+ test("list", `list.Max([1, 2, 3, 4])`),
+ `4`,
+ }, {
+ test("list", `list.Max([])`),
+ `_|_(error in call to list.Max: empty list)`,
+ }, {
+ test("list", `list.Max("foo")`),
+ `_|_(cannot use "foo" (type string) as list in argument 1 to list.Max)`,
+ }, {
+ test("list", `list.Min([1, 2, 3, 4])`),
+ `1`,
+ }, {
+ test("list", `list.Min([])`),
+ `_|_(error in call to list.Min: empty list)`,
+ }, {
+ test("list", `list.Min("foo")`),
+ `_|_(cannot use "foo" (type string) as list in argument 1 to list.Min)`,
+ }, {
+ test("list", `list.Product([1, 2, 3, 4])`),
+ `24`,
+ }, {
+ test("list", `list.Product([])`),
+ `1`,
+ }, {
+ test("list", `list.Product("foo")`),
+ `_|_(cannot use "foo" (type string) as list in argument 1 to list.Product)`,
+ }, {
+ test("list", `list.Range(0, 5, 0)`),
+ `_|_(error in call to list.Range: step must be non zero)`,
+ }, {
+ test("list", `list.Range(5, 0, 1)`),
+ `_|_(error in call to list.Range: end must be greater than start when step is positive)`,
+ }, {
+ test("list", `list.Range(0, 5, -1)`),
+ `_|_(error in call to list.Range: end must be less than start when step is negative)`,
+ }, {
+ test("list", `list.Range(0, 5, 1)`),
+ `[0,1,2,3,4]`,
+ }, {
+ test("list", `list.Range(0, 1, 1)`),
+ `[0]`,
+ }, {
+ test("list", `list.Range(0, 5, 2)`),
+ `[0,2,4]`,
+ }, {
+ test("list", `list.Range(5, 0, -1)`),
+ `[5,4,3,2,1]`,
+ }, {
+ test("list", `list.Range(0, 5, 0.5)`),
+ `[0,0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0,4.5]`,
+ }, {
+ test("list", `list.Slice([1, 2, 3, 4], 1, 3)`),
+ `[2,3]`,
+ }, {
+ test("list", `list.Slice([1, 2, 3, 4], -1, 3)`),
+ `_|_(error in call to list.Slice: negative index)`,
+ }, {
+ test("list", `list.Slice([1, 2, 3, 4], 3, 1)`),
+ `_|_(error in call to list.Slice: invalid index: 3 > 1)`,
+ }, {
+ test("list", `list.Slice([1, 2, 3, 4], 5, 5)`),
+ `_|_(error in call to list.Slice: slice bounds out of range)`,
+ }, {
+ test("list", `list.Slice([1, 2, 3, 4], 1, 5)`),
+ `_|_(error in call to list.Slice: slice bounds out of range)`,
+ }, {
+ test("list", `list.Sort([], list.Ascending)`),
+ `[]`,
+ }, {
+ test("list", `list.Sort([2, 3, 1, 4], {x:_, y:_, less: x<y})`),
+ `[1,2,3,4]`,
+ }, {
+ test("list", `list.SortStable([{a:2,v:1}, {a:1,v:2}, {a:1,v:3}], {
+ x:_,
+ y:_,
+ less: (x.a < y.a)
+ })`),
+ `[{a: 1, v: 2},{a: 1, v: 3},{a: 2, v: 1}]`,
+ }, {
+ test("list", `list.Sort([{a:1}, {b:2}], list.Ascending)`),
+ `_|_(error in call to list.Sort: less: conflicting values close(T, close(T)) and {b: 2} (mismatched types number|string and struct))`,
+ }, {
+ test("list", `list.SortStrings(["b", "a"])`),
+ `["a","b"]`,
+ }, {
+ test("list", `list.SortStrings([1, 2])`),
+ `_|_(invalid list element 0 in argument 0 to list.SortStrings: 0: cannot use value 1 (type int) as string)`,
+ }, {
+ test("list", `list.Sum([1, 2, 3, 4])`),
+ `10`,
+ }, {
+ test("list", `list.Sum([])`),
+ `0`,
+ }, {
+ test("list", `list.Sum("foo")`),
+ `_|_(cannot use "foo" (type string) as list in argument 1 to list.Sum)`,
+ }, {
+ test("list", `list.Take([1, 2, 3, 4], 0)`),
+ `[]`,
+ }, {
+ test("list", `list.Take([1, 2, 3, 4], 2)`),
+ `[1,2]`,
+ }, {
+ test("list", `list.Take([1, 2, 3, 4], 10)`),
+ `[1,2,3,4]`,
+ }, {
+ test("list", `list.Take([1, 2, 3, 4], -1)`),
+ `_|_(error in call to list.Take: negative index)`,
+ }, {
+ test("list", `list.MinItems([1, 2, 3, 4], 2)`),
+ `true`,
+ }, {
+ test("list", `list.MinItems([1, 2, 3, 4], 5)`),
+ `false`,
+ }, {
+ test("list", `list.MaxItems([1, 2, 3, 4], 5)`),
+ `true`,
+ }, {
+ test("list", `list.MaxItems([1, 2, 3, 4], 2)`),
+ `false`,
+ }, {
+ // Panics
+ test("math", `math.Jacobi(1000, 2000)`),
+ `_|_(error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000)`,
+ }, {
+ test("math", `math.Jacobi(1000, 201)`),
+ `1`,
+ }, {
+ test("math", `math.Asin(2.0e400)`),
+ `_|_(cannot use 2.0e+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up)`,
+ }, {
+ test("math", `math.MultipleOf(4, 2)`), `true`,
+ }, {
+ test("math", `math.MultipleOf(5, 2)`), `false`,
+ }, {
+ test("math", `math.MultipleOf(5, 0)`),
+ `_|_(error in call to math.MultipleOf: division by zero)`,
+ }, {
+ test("math", `math.MultipleOf(100, 1.00001)`), `false`,
+ }, {
+ test("math", `math.MultipleOf(1, 1)`), `true`,
+ }, {
+ test("math", `math.MultipleOf(5, 2.5)`), `true`,
+ }, {
+ test("math", `math.MultipleOf(100e100, 10)`), `true`,
+ }, {
+ test("encoding/csv", `csv.Decode("1,2,3\n4,5,6")`),
+ `[["1","2","3"],["4","5","6"]]`,
+ }, {
+ test("regexp", `regexp.Find(#"f\w\w"#, "afoot")`),
+ `"foo"`,
+ }, {
+ test("regexp", `regexp.Find(#"f\w\w"#, "bar")`),
+ `_|_(error in call to regexp.Find: no match)`,
+ }, {
+ test("regexp", `regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)`),
+ `["foo","flo"]`,
+ }, {
+ test("regexp", `regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)`),
+ `["foo","flo"]`,
+ }, {
+ test("regexp", `regexp.FindAll(#"f\w\w"#, "bla bla", -1)`),
+ `_|_(error in call to regexp.FindAll: no match)`,
+ }, {
+ test("regexp", `regexp.FindSubmatch(#"f(\w)(\w)"#, "afloat afoot from")`),
+ `["flo","l","o"]`,
+ }, {
+ test("regexp", `regexp.FindAllSubmatch(#"f(\w)(\w)"#, "afloat afoot from", -1)`),
+ `[["flo","l","o"],["foo","o","o"],["fro","r","o"]]`,
+ }, {
+ test("regexp", `regexp.FindAllSubmatch(#"f(\w)(\w)"#, "aglom", -1)`),
+ `_|_(error in call to regexp.FindAllSubmatch: no match)`,
+ }, {
+ test("regexp", `regexp.FindNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from")`),
+ `{A: "l", B: "o"}`,
+ }, {
+ test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from", -1)`),
+ `[{A: "l", B: "o"},{A: "o", B: "o"},{A: "r", B: "o"}]`,
+ }, {
+ test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>optional)?"#, "fbla", -1)`),
+ `[{A: ""}]`,
+ }, {
+ test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "aglom", -1)`),
+ `_|_(error in call to regexp.FindAllNamedSubmatch: no match)`,
+ }, {
+ test("regexp", `regexp.Valid & "valid"`),
+ `"valid"`,
+ }, {
+ test("regexp", `regexp.Valid & "invalid)"`),
+ "_|_(error in call to regexp.Valid: error parsing regexp: unexpected ): `invalid)`)",
+ }, {
+ test("strconv", `strconv.FormatBool(true)`),
+ `"true"`,
+ }, {
+ test("strings", `strings.Join(["Hello", "World!"], " ")`),
+ `"Hello World!"`,
+ }, {
+ test("strings", `strings.Join([1, 2], " ")`),
+ `_|_(invalid list element 0 in argument 0 to strings.Join: 0: cannot use value 1 (type int) as string)`,
+ }, {
+ test("strings", `strings.ByteAt("a", 0)`),
+ strconv.Itoa('a'),
+ }, {
+ test("strings", `strings.ByteSlice("Hello", 2, 5)`),
+ `'llo'`,
+ }, {
+ test("strings", `strings.SliceRunes("✓ Hello", 0, 3)`),
+ `"✓ H"`,
+ }, {
+ test("strings", `strings.Runes("Café")`),
+ strings.Replace(fmt.Sprint([]rune{'C', 'a', 'f', 'é'}), " ", ",", -1),
+ }, {
+ test("math/bits", `bits.Or(0x8, 0x1)`),
+ `9`,
+ }, {
+ testExpr(`len({})`),
+ `0`,
+ }, {
+ testExpr(`len({a: 1, b: 2, {[foo=_]: int}, _c: 3})`),
+ `2`,
+ }, {
+ testExpr(`len([1, 2, 3])`),
+ `3`,
+ }, {
+ testExpr(`len("foo")`),
+ `3`,
+ }, {
+ testExpr(`len('f\x20\x20')`),
+ `3`,
+ }, {
+ testExpr(`and([string, "foo"])`),
+ `"foo"`,
+ }, {
+ testExpr(`and([string, =~"fo"]) & "foo"`),
+ `"foo"`,
+ }, {
+ testExpr(`and([])`),
+ `{}`, // _ & top scope
+ }, {
+ testExpr(`or([1, 2, 3]) & 2`),
+ `2`,
+ }, {
+ testExpr(`or([])`),
+ `_|_(empty list in call to or)`,
+ }, {
+ test("encoding/csv", `csv.Encode([[1,2,3],[4,5],[7,8,9]])`),
+ `"1,2,3\n4,5\n7,8,9\n"`,
+ }, {
+ test("encoding/csv", `csv.Encode([["a", "b"], ["c"]])`),
+ `"a,b\nc\n"`,
+ }, {
+ test("encoding/json", `json.Valid("1")`),
+ `true`,
+ }, {
+ test("encoding/json", `json.Compact("[1, 2]")`),
+ `"[1,2]"`,
+ }, {
+ test("encoding/json", `json.Indent(#"{"a": 1, "b": 2}"#, "", " ")`),
+ `"{\n \"a\": 1,\n \"b\": 2\n}"`,
+ }, {
+ test("encoding/json", `json.Unmarshal("1")`),
+ `1`,
+ }, {
+ test("encoding/json", `json.MarshalStream([{a: 1}, {b: 2}])`),
+ `"{\"a\":1}\n{\"b\":2}\n"`,
+ }, {
+ test("encoding/json", `{
+ x: int
+ y: json.Marshal({a: x})
+ }`),
+ `{x: int, y: Marshal ({a: x})}`,
+ }, {
+ test("encoding/yaml", `yaml.MarshalStream([{a: 1}, {b: 2}])`),
+ `"a: 1\n---\nb: 2\n"`,
+ }, {
+ test("net", `net.FQDN & "foo.bar."`),
+ `"foo.bar."`,
+ }, {
+ test("net", `net.FQDN("foo.bararararararararararararararararararararararararararararararararara")`),
+ `false`,
+ }, {
+ test("net", `net.SplitHostPort("[::%lo0]:80")`),
+ `["::%lo0","80"]`,
+ }, {
+ test("net", `net.JoinHostPort("example.com", "80")`),
+ `"example.com:80"`,
+ }, {
+ test("net", `net.JoinHostPort("2001:db8::1", 80)`),
+ `"[2001:db8::1]:80"`,
+ }, {
+ test("net", `net.JoinHostPort([192,30,4,2], 80)`),
+ `"192.30.4.2:80"`,
+ }, {
+ test("net", `net.JoinHostPort([192,30,4], 80)`),
+ `_|_(error in call to net.JoinHostPort: invalid host [192,30,4])`,
+ }, {
+ test("net", `net.IP("23.23.23.23")`),
+ `true`,
+ }, {
+ test("net", `net.IPv4 & "23.23.23.2333"`),
+ `_|_(invalid value "23.23.23.2333" (does not satisfy net.IPv4()))`,
+ }, {
+ test("net", `net.IP("23.23.23.23")`),
+ `true`,
+ }, {
+ test("net", `net.IP("2001:db8::1")`),
+ `true`,
+ }, {
+ test("net", `net.IPv4("2001:db8::1")`),
+ `false`,
+ }, {
+ test("net", `net.IPv4() & "ff02::1:3"`),
+ `_|_(invalid value "ff02::1:3" (does not satisfy net.IPv4()))`,
+ }, {
+ test("net", `net.LoopbackIP([127, 0, 0, 1])`),
+ `true`,
+ }, {
+ test("net", `net.LoopbackIP("127.0.0.1")`),
+ `true`,
+ }, {
+ test("net", `net.ToIP4("127.0.0.1")`),
+ `[127,0,0,1]`,
+ }, {
+ test("net", `net.ToIP16("127.0.0.1")`),
+ `[0,0,0,0,0,0,0,0,0,0,255,255,127,0,0,1]`,
+ }, {
+ test("strings", `strings.ToCamel("AlphaBeta")`),
+ `"alphaBeta"`,
+ }, {
+ test("strings", `strings.ToTitle("alpha")`),
+ `"Alpha"`,
+ }, {
+ test("strings", `strings.MaxRunes(3) & "foo"`),
+ `"foo"`,
+ }, {
+ test("strings", `strings.MaxRunes(3) & "quux"`),
+ `_|_(invalid value "quux" (does not satisfy strings.MaxRunes(3)))`,
+ }, {
+ test("strings", `strings.MinRunes(1) & "e"`),
+ `"e"`,
+ }, {
+ test("strings", `strings.MaxRunes(0) & "e"`),
+ `_|_(invalid value "e" (does not satisfy strings.MaxRunes(0)))`,
+ }, {
+ test("strings", `strings.MaxRunes(0) & ""`),
+ `""`,
+ }, {
+ test("strings", `strings.MinRunes(3) & "hello"`),
+ `"hello"`,
+ }, {
+ test("strings", `strings.MaxRunes(10) & "hello"`),
+ `"hello"`,
+ }, {
+ test("strings", `strings.MaxRunes(3) & "hello"`),
+ `_|_(invalid value "hello" (does not satisfy strings.MaxRunes(3)))`,
+ }, {
+ test("strings", `strings.MinRunes(10) & "hello"`),
+ `_|_(invalid value "hello" (does not satisfy strings.MinRunes(10)))`,
+ }, {
+ test("struct", `struct.MinFields(0) & ""`),
+ `_|_(conflicting values MinFields (0) and "" (mismatched types struct and string))`,
+ }, {
+ test("struct", `struct.MinFields(0) & {a: 1}`),
+ `{a: 1}`,
+ }, {
+ test("struct", `struct.MinFields(2) & {a: 1}`),
+ `_|_(invalid value {a: 1} (does not satisfy struct.MinFields(2)))`,
+ }, {
+ test("struct", `struct.MaxFields(0) & {a: 1}`),
+ `_|_(invalid value {a: 1} (does not satisfy struct.MaxFields(0)))`,
+ }, {
+ test("struct", `struct.MaxFields(2) & {a: 1}`),
+ `{a: 1}`,
+ }, {
+ test("math", `math.Pow(8, 4)`), `4096`,
+ }, {
+ test("math", `math.Pow10(4)`), `10000`,
+ }, {
+ test("math", `math.Signbit(-4)`), `true`,
+ }, {
+ test("math", `math.Round(2.5)`), `3`,
+ }, {
+ test("math", `math.Round(-2.5)`), `-3`,
+ }, {
+ test("math", `math.RoundToEven(2.5)`), `2`,
+ }, {
+ test("math", `math.RoundToEven(-2.5)`), `-2`,
+ }, {
+ test("math", `math.Abs(2.5)`), `2.5`,
+ }, {
+ test("math", `math.Abs(-2.2)`), `2.2`,
+ }, {
+ test("math", `math.Cbrt(2)`), `1.25992104989487316476721`,
+ }, {
+ test("math", `math.Copysign(5, -2.2)`), `-5`,
+ }, {
+ test("math", `math.Exp(3)`), `20.0855369231876677409285`,
+ }, {
+ test("math", `math.Exp2(3.5)`), `11.3137084989847603904135`,
+ }, {
+ test("math", `math.Log(4)`), `1.38629436111989061883446`,
+ }, {
+ test("math", `math.Log10(4)`), `0.602059991327962390427478`,
+ }, {
+ test("math", `math.Log2(5)`),
+ `2.32192809488736234787032`,
+ }, {
+ test("math", `math.Dim(3, 2.5)`), `0.5`,
+ }, {
+ test("math", `math.Dim(5, 7.2)`), `0`,
+ }, {
+ test("math", `math.Ceil(2.5)`), `3`,
+ }, {
+ test("math", `math.Ceil(-2.2)`), `-2`,
+ }, {
+ test("math", `math.Floor(2.9)`), `2`,
+ }, {
+ test("math", `math.Floor(-2.2)`), `-3`,
+ }, {
+ test("math", `math.Trunc(2.5)`), `2`,
+ }, {
+ test("math", `math.Trunc(-2.9)`), `-2`,
+ }, {
+ test("math/bits", `bits.Lsh(0x8, 4)`), `128`,
+ }, {
+ test("math/bits", `bits.Rsh(0x100, 4)`), `16`,
+ }, {
+ test("math/bits", `bits.At(0x100, 8)`), `1`,
+ }, {
+ test("math/bits", `bits.At(0x100, 9)`), `0`,
+ }, {
+ test("math/bits", `bits.Set(0x100, 7, 1)`), `384`,
+ }, {
+ test("math/bits", `bits.Set(0x100, 8, 0)`), `0`,
+ }, {
+ test("math/bits", `bits.And(0x10000000000000F0E, 0xF0F7)`), `6`,
+ }, {
+ test("math/bits", `bits.Or(0x100000000000000F0, 0x0F)`),
+ hexToDec("100000000000000FF"),
+ }, {
+ test("math/bits", `bits.Xor(0x10000000000000F0F, 0xFF0)`),
+ hexToDec("100000000000000FF"),
+ }, {
+ test("math/bits", `bits.Xor(0xFF0, 0x10000000000000F0F)`),
+ hexToDec("100000000000000FF"),
+ }, {
+ test("math/bits", `bits.Clear(0xF, 0x100000000000008)`), `7`,
+ }, {
+ test("math/bits", `bits.Clear(0x1000000000000000008, 0xF)`),
+ hexToDec("1000000000000000000"),
+ }, {
+ test("text/tabwriter", `tabwriter.Write("""
+ a\tb\tc
+ aaa\tbb\tvv
+ """)`),
+ `"a b c\naaa bb vv"`,
+ }, {
+ test("text/tabwriter", `tabwriter.Write([
+ "a\tb\tc",
+ "aaa\tbb\tvv"])`),
+ `"a b c\naaa bb vv\n"`,
+ }, {
+ test("text/template", `template.Execute("{{.}}-{{.}}", "foo")`),
+ `"foo-foo"`,
+ }, {
+ test("time", `time.Time & "1937-01-01T12:00:27.87+00:20"`),
+ `"1937-01-01T12:00:27.87+00:20"`,
+ }, {
+ test("time", `time.Time & "no time"`),
+ `_|_(error in call to time.Time: invalid time "no time")`,
+ }, {
+ test("time", `time.Unix(1500000000, 123456)`),
+ `"2017-07-14T02:40:00.000123456Z"`,
+ }}
+ for i, tc := range testCases {
+ t.Run(fmt.Sprint(i), func(t *testing.T) {
+ insts := Build(makeInstances(tc.instances))
+ if err := insts[0].Err; err != nil {
+ t.Fatal(err)
+ }
+ got := strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+ if got != tc.emit {
+ t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
+ }
+ })
+ }
+}
diff --git a/internal/legacy/cue/builtins.go b/internal/legacy/cue/builtins.go
new file mode 100644
index 0000000..290ab79
--- /dev/null
+++ b/internal/legacy/cue/builtins.go
@@ -0,0 +1,3782 @@
+// Code generated by go generate. DO NOT EDIT.
+
+package cue
+
+import (
+ "bytes"
+ "crypto/md5"
+ "crypto/sha1"
+ "crypto/sha256"
+ "crypto/sha512"
+ "encoding/base64"
+ "encoding/csv"
+ "encoding/hex"
+ "encoding/json"
+ "fmt"
+ "html"
+ "io"
+ "math"
+ "math/big"
+ "math/bits"
+ "net"
+ "path"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "text/tabwriter"
+ "text/template"
+ "time"
+ "unicode"
+ "unicode/utf8"
+
+ "github.com/cockroachdb/apd/v2"
+ "golang.org/x/net/idna"
+
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/literal"
+ "cuelang.org/go/cue/parser"
+ "cuelang.org/go/internal"
+ cueyaml "cuelang.org/go/internal/encoding/yaml"
+ "cuelang.org/go/internal/third_party/yaml"
+)
+
+func init() {
+ initBuiltins(builtinPackages)
+}
+
+var _ io.Reader
+
+var roundTruncContext = apd.Context{Rounding: apd.RoundDown}
+
+var roundUpContext = apd.Context{Rounding: apd.RoundHalfUp}
+
+var roundEvenContext = apd.Context{Rounding: apd.RoundHalfEven}
+
+var mulContext = apd.BaseContext.WithPrecision(1)
+
+var apdContext = apd.BaseContext.WithPrecision(24)
+
+var zero = apd.New(0, 0)
+
+var two = apd.New(2, 0)
+
+var idnaProfile = idna.New(
+ idna.ValidateLabels(true),
+ idna.VerifyDNSLength(true),
+ idna.StrictDomainName(true),
+)
+
+func netGetIP(ip Value) (goip net.IP) {
+ switch ip.Kind() {
+ case StringKind:
+ s, err := ip.String()
+ if err != nil {
+ return nil
+ }
+ goip := net.ParseIP(s)
+ if goip == nil {
+ return nil
+ }
+ return goip
+
+ case BytesKind:
+ b, err := ip.Bytes()
+ if err != nil {
+ return nil
+ }
+ goip := net.ParseIP(string(b))
+ if goip == nil {
+ return nil
+ }
+ return goip
+
+ case ListKind:
+ iter, err := ip.List()
+ if err != nil {
+ return nil
+ }
+ for iter.Next() {
+ v, err := iter.Value().Int64()
+ if err != nil {
+ return nil
+ }
+ if v < 0 || 255 < v {
+ return nil
+ }
+ goip = append(goip, byte(v))
+ }
+ return goip
+
+ default:
+
+ return nil
+ }
+}
+
+func netToList(ip net.IP) []uint {
+ a := make([]uint, len(ip))
+ for i, p := range ip {
+ a[i] = uint(p)
+ }
+ return a
+}
+
+var split = path.Split
+
+var pathClean = path.Clean
+
+var pathExt = path.Ext
+
+var pathBase = path.Base
+
+var pathIsAbs = path.IsAbs
+
+var pathDir = path.Dir
+
+var errNoMatch = errors.New("no match")
+
+var errNoNamedGroup = errors.New("no named groups")
+
+func timeFormat(value, layout string) (bool, error) {
+ _, err := time.Parse(layout, value)
+ if err != nil {
+
+ return false, fmt.Errorf("invalid time %q", value)
+ }
+ return true, nil
+}
+
+var builtinPackages = map[string]*builtinPkg{
+ "": {
+ native: []*builtin{},
+ },
+ "crypto/md5": {
+ native: []*builtin{{
+ Name: "Size",
+ Const: "16",
+ }, {
+ Name: "BlockSize",
+ Const: "64",
+ }, {
+ Name: "Sum",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := md5.Sum(data)
+ return a[:]
+ }()
+ }
+ },
+ }},
+ },
+ "crypto/sha1": {
+ native: []*builtin{{
+ Name: "Size",
+ Const: "20",
+ }, {
+ Name: "BlockSize",
+ Const: "64",
+ }, {
+ Name: "Sum",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha1.Sum(data)
+ return a[:]
+ }()
+ }
+ },
+ }},
+ },
+ "crypto/sha256": {
+ native: []*builtin{{
+ Name: "Size",
+ Const: "32",
+ }, {
+ Name: "Size224",
+ Const: "28",
+ }, {
+ Name: "BlockSize",
+ Const: "64",
+ }, {
+ Name: "Sum256",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha256.Sum256(data)
+ return a[:]
+ }()
+ }
+ },
+ }, {
+ Name: "Sum224",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha256.Sum224(data)
+ return a[:]
+ }()
+ }
+ },
+ }},
+ },
+ "crypto/sha512": {
+ native: []*builtin{{
+ Name: "Size",
+ Const: "64",
+ }, {
+ Name: "Size224",
+ Const: "28",
+ }, {
+ Name: "Size256",
+ Const: "32",
+ }, {
+ Name: "Size384",
+ Const: "48",
+ }, {
+ Name: "BlockSize",
+ Const: "128",
+ }, {
+ Name: "Sum512",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha512.Sum512(data)
+ return a[:]
+ }()
+ }
+ },
+ }, {
+ Name: "Sum384",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha512.Sum384(data)
+ return a[:]
+ }()
+ }
+ },
+ }, {
+ Name: "Sum512_224",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha512.Sum512_224(data)
+ return a[:]
+ }()
+ }
+ },
+ }, {
+ Name: "Sum512_256",
+ Params: []kind{bytesKind | stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ a := sha512.Sum512_256(data)
+ return a[:]
+ }()
+ }
+ },
+ }},
+ },
+ "encoding/base64": {
+ native: []*builtin{{
+ Name: "EncodedLen",
+ Params: []kind{topKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ encoding, n := c.value(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if err := encoding.Null(); err != nil {
+ return 0, fmt.Errorf("base64: unsupported encoding: %v", err)
+ }
+ return base64.StdEncoding.EncodedLen(n), nil
+ }()
+ }
+ },
+ }, {
+ Name: "DecodedLen",
+ Params: []kind{topKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ encoding, x := c.value(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if err := encoding.Null(); err != nil {
+ return 0, fmt.Errorf("base64: unsupported encoding: %v", err)
+ }
+ return base64.StdEncoding.DecodedLen(x), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Encode",
+ Params: []kind{topKind, bytesKind | stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ encoding, src := c.value(0), c.bytes(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if err := encoding.Null(); err != nil {
+ return "", fmt.Errorf("base64: unsupported encoding: %v", err)
+ }
+ return base64.StdEncoding.EncodeToString(src), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Decode",
+ Params: []kind{topKind, stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ encoding, s := c.value(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if err := encoding.Null(); err != nil {
+ return nil, fmt.Errorf("base64: unsupported encoding: %v", err)
+ }
+ return base64.StdEncoding.DecodeString(s)
+ }()
+ }
+ },
+ }},
+ },
+ "encoding/csv": {
+ native: []*builtin{{
+ Name: "Encode",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ x := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ buf := &bytes.Buffer{}
+ w := csv.NewWriter(buf)
+ iter, err := x.List()
+ if err != nil {
+ return "", err
+ }
+ for iter.Next() {
+ row, err := iter.Value().List()
+ if err != nil {
+ return "", err
+ }
+ a := []string{}
+ for row.Next() {
+ col := row.Value()
+ if str, err := col.String(); err == nil {
+ a = append(a, str)
+ } else {
+ b, err := col.MarshalJSON()
+ if err != nil {
+ return "", err
+ }
+ a = append(a, string(b))
+ }
+ }
+ _ = w.Write(a)
+ }
+ w.Flush()
+ return buf.String(), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Decode",
+ Params: []kind{bytesKind | stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ r := c.reader(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return csv.NewReader(r).ReadAll()
+ }()
+ }
+ },
+ }},
+ },
+ "encoding/hex": {
+ native: []*builtin{{
+ Name: "EncodedLen",
+ Params: []kind{intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ n := c.int(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return hex.EncodedLen(n)
+ }()
+ }
+ },
+ }, {
+ Name: "DecodedLen",
+ Params: []kind{intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x := c.int(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return hex.DecodedLen(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Decode",
+ Params: []kind{stringKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return hex.DecodeString(s)
+ }()
+ }
+ },
+ }, {
+ Name: "Dump",
+ Params: []kind{bytesKind | stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return hex.Dump(data)
+ }()
+ }
+ },
+ }, {
+ Name: "Encode",
+ Params: []kind{bytesKind | stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ src := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return hex.EncodeToString(src)
+ }()
+ }
+ },
+ }},
+ },
+ "encoding/json": {
+ native: []*builtin{{
+ Name: "Valid",
+ Params: []kind{bytesKind | stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return json.Valid(data)
+ }()
+ }
+ },
+ }, {
+ Name: "Compact",
+ Params: []kind{bytesKind | stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ src := c.bytes(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ dst := bytes.Buffer{}
+ if err := json.Compact(&dst, src); err != nil {
+ return "", err
+ }
+ return dst.String(), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Indent",
+ Params: []kind{bytesKind | stringKind, stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ src, prefix, indent := c.bytes(0), c.string(1), c.string(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ dst := bytes.Buffer{}
+ if err := json.Indent(&dst, src, prefix, indent); err != nil {
+ return "", err
+ }
+ return dst.String(), nil
+ }()
+ }
+ },
+ }, {
+ Name: "HTMLEscape",
+ Params: []kind{bytesKind | stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ src := c.bytes(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ dst := &bytes.Buffer{}
+ json.HTMLEscape(dst, src)
+ return dst.String()
+ }()
+ }
+ },
+ }, {
+ Name: "Marshal",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ v := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ b, err := json.Marshal(v)
+ return string(b), err
+ }()
+ }
+ },
+ }, {
+ Name: "MarshalStream",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ v := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+
+ iter, err := v.List()
+ if err != nil {
+ return "", err
+ }
+ buf := &bytes.Buffer{}
+ for iter.Next() {
+ b, err := json.Marshal(iter.Value())
+ if err != nil {
+ return "", err
+ }
+ buf.Write(b)
+ buf.WriteByte('\n')
+ }
+ return buf.String(), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Unmarshal",
+ Params: []kind{bytesKind | stringKind},
+ Result: topKind,
+ Func: func(c *callCtxt) {
+ b := c.bytes(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if !json.Valid(b) {
+ return nil, fmt.Errorf("json: invalid JSON")
+ }
+ expr, err := parser.ParseExpr("json", b)
+ if err != nil {
+
+ return nil, fmt.Errorf("json: could not parse JSON: %v", err)
+ }
+ return expr, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Validate",
+ Params: []kind{bytesKind | stringKind, topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ b, v := c.bytes(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if !json.Valid(b) {
+ return false, fmt.Errorf("json: invalid JSON")
+ }
+ r := internal.GetRuntime(v).(*Runtime)
+ inst, err := r.Compile("json.Validate", b)
+ if err != nil {
+ return false, err
+ }
+
+ v = v.Unify(inst.Value())
+ if v.Err() != nil {
+ return false, v.Err()
+ }
+ return true, nil
+ }()
+ }
+ },
+ }},
+ },
+ "encoding/yaml": {
+ native: []*builtin{{
+ Name: "Marshal",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ v := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if err := v.Validate(Concrete(true)); err != nil {
+ if err := v.Validate(); err != nil {
+ return "", err
+ }
+ return "", internal.ErrIncomplete
+ }
+ n := v.Syntax(Final(), Concrete(true))
+ b, err := cueyaml.Encode(n)
+ return string(b), err
+ }()
+ }
+ },
+ }, {
+ Name: "MarshalStream",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ v := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+
+ iter, err := v.List()
+ if err != nil {
+ return "", err
+ }
+ buf := &bytes.Buffer{}
+ for i := 0; iter.Next(); i++ {
+ if i > 0 {
+ buf.WriteString("---\n")
+ }
+ v := iter.Value()
+ if err := v.Validate(Concrete(true)); err != nil {
+ if err := v.Validate(); err != nil {
+ return "", err
+ }
+ return "", internal.ErrIncomplete
+ }
+ n := v.Syntax(Final(), Concrete(true))
+ b, err := cueyaml.Encode(n)
+ if err != nil {
+ return "", err
+ }
+ buf.Write(b)
+ }
+ return buf.String(), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Unmarshal",
+ Params: []kind{bytesKind | stringKind},
+ Result: topKind,
+ Func: func(c *callCtxt) {
+ data := c.bytes(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return yaml.Unmarshal("", data)
+ }()
+ }
+ },
+ }, {
+ Name: "Validate",
+ Params: []kind{bytesKind | stringKind, topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ b, v := c.bytes(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ d, err := yaml.NewDecoder("yaml.Validate", b)
+ if err != nil {
+ return false, err
+ }
+ r := internal.GetRuntime(v).(*Runtime)
+ for {
+ expr, err := d.Decode()
+ if err != nil {
+ if err == io.EOF {
+ return true, nil
+ }
+ return false, err
+ }
+
+ inst, err := r.CompileExpr(expr)
+ if err != nil {
+ return false, err
+ }
+
+ x := v.Unify(inst.Value())
+ if err := x.Err(); err != nil {
+ return false, err
+ }
+ if err := x.Validate(Concrete(true)); err != nil {
+ return false, err
+ }
+
+ }
+ }()
+ }
+ },
+ }, {
+ Name: "ValidatePartial",
+ Params: []kind{bytesKind | stringKind, topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ b, v := c.bytes(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ d, err := yaml.NewDecoder("yaml.ValidatePartial", b)
+ if err != nil {
+ return false, err
+ }
+ r := internal.GetRuntime(v).(*Runtime)
+ for {
+ expr, err := d.Decode()
+ if err != nil {
+ if err == io.EOF {
+ return true, nil
+ }
+ return false, err
+ }
+
+ inst, err := r.CompileExpr(expr)
+ if err != nil {
+ return false, err
+ }
+
+ if x := v.Unify(inst.Value()); x.Err() != nil {
+ return false, x.Err()
+ }
+ }
+ }()
+ }
+ },
+ }},
+ },
+ "html": {
+ native: []*builtin{{
+ Name: "Escape",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return html.EscapeString(s)
+ }()
+ }
+ },
+ }, {
+ Name: "Unescape",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return html.UnescapeString(s)
+ }()
+ }
+ },
+ }},
+ },
+ "list": {
+ native: []*builtin{{
+ Name: "Drop",
+ Params: []kind{listKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ x, n := c.list(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if n < 0 {
+ return nil, fmt.Errorf("negative index")
+ }
+
+ if n > len(x) {
+ return []Value{}, nil
+ }
+
+ return x[n:], nil
+ }()
+ }
+ },
+ }, {
+ Name: "FlattenN",
+ Params: []kind{topKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ xs, depth := c.value(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var flattenN func(Value, int) ([]Value, error)
+ flattenN = func(xs Value, depth int) ([]Value, error) {
+ var res []Value
+ iter, err := xs.List()
+ if err != nil {
+ return nil, err
+ }
+ for iter.Next() {
+ val, _ := iter.Value().Default()
+ if val.Kind() == ListKind && depth != 0 {
+ d := depth - 1
+ values, err := flattenN(val, d)
+ if err != nil {
+ return nil, err
+ }
+ res = append(res, values...)
+ } else {
+ res = append(res, val)
+ }
+ }
+ return res, nil
+ }
+ return flattenN(xs, depth)
+ }()
+ }
+ },
+ }, {
+ Name: "Take",
+ Params: []kind{listKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ x, n := c.list(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if n < 0 {
+ return nil, fmt.Errorf("negative index")
+ }
+
+ if n > len(x) {
+ return x, nil
+ }
+
+ return x[:n], nil
+ }()
+ }
+ },
+ }, {
+ Name: "Slice",
+ Params: []kind{listKind, intKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ x, i, j := c.list(0), c.int(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if i < 0 {
+ return nil, fmt.Errorf("negative index")
+ }
+
+ if i > j {
+ return nil, fmt.Errorf("invalid index: %v > %v", i, j)
+ }
+
+ if i > len(x) {
+ return nil, fmt.Errorf("slice bounds out of range")
+ }
+
+ if j > len(x) {
+ return nil, fmt.Errorf("slice bounds out of range")
+ }
+
+ return x[i:j], nil
+ }()
+ }
+ },
+ }, {
+ Name: "MinItems",
+ Params: []kind{listKind, intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ a, n := c.list(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return len(a) >= n
+ }()
+ }
+ },
+ }, {
+ Name: "MaxItems",
+ Params: []kind{listKind, intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ a, n := c.list(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return len(a) <= n
+ }()
+ }
+ },
+ }, {
+ Name: "UniqueItems",
+ Params: []kind{listKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ a := c.list(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ b := []string{}
+ for _, v := range a {
+ b = append(b, fmt.Sprint(v))
+ }
+ sort.Strings(b)
+ for i := 1; i < len(b); i++ {
+ if b[i-1] == b[i] {
+ return false
+ }
+ }
+ return true
+ }()
+ }
+ },
+ }, {
+ Name: "Contains",
+ Params: []kind{listKind, topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ a, v := c.list(0), c.value(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ for _, w := range a {
+ if v.Equals(w) {
+ return true
+ }
+ }
+ return false
+ }()
+ }
+ },
+ }, {
+ Name: "Avg",
+ Params: []kind{listKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ xs := c.decimalList(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if 0 == len(xs) {
+ return nil, fmt.Errorf("empty list")
+ }
+
+ s := apd.New(0, 0)
+ for _, x := range xs {
+ _, err := internal.BaseContext.Add(s, x, s)
+ if err != nil {
+ return nil, err
+ }
+ }
+
+ var d apd.Decimal
+ l := apd.New(int64(len(xs)), 0)
+ _, err := internal.BaseContext.Quo(&d, s, l)
+ if err != nil {
+ return nil, err
+ }
+ return &d, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Max",
+ Params: []kind{listKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ xs := c.decimalList(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if 0 == len(xs) {
+ return nil, fmt.Errorf("empty list")
+ }
+
+ max := xs[0]
+ for _, x := range xs[1:] {
+ if -1 == max.Cmp(x) {
+ max = x
+ }
+ }
+ return max, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Min",
+ Params: []kind{listKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ xs := c.decimalList(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if 0 == len(xs) {
+ return nil, fmt.Errorf("empty list")
+ }
+
+ min := xs[0]
+ for _, x := range xs[1:] {
+ if +1 == min.Cmp(x) {
+ min = x
+ }
+ }
+ return min, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Product",
+ Params: []kind{listKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ xs := c.decimalList(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ d := apd.New(1, 0)
+ for _, x := range xs {
+ _, err := internal.BaseContext.Mul(d, x, d)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return d, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Range",
+ Params: []kind{numKind, numKind, numKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ start, limit, step := c.decimal(0), c.decimal(1), c.decimal(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if step.IsZero() {
+ return nil, fmt.Errorf("step must be non zero")
+ }
+
+ if !step.Negative && +1 == start.Cmp(limit) {
+ return nil, fmt.Errorf("end must be greater than start when step is positive")
+ }
+
+ if step.Negative && -1 == start.Cmp(limit) {
+ return nil, fmt.Errorf("end must be less than start when step is negative")
+ }
+
+ var vals []*internal.Decimal
+ num := start
+ for {
+ if !step.Negative && -1 != num.Cmp(limit) {
+ break
+ }
+
+ if step.Negative && +1 != num.Cmp(limit) {
+ break
+ }
+
+ vals = append(vals, num)
+ d := apd.New(0, 0)
+ _, err := internal.BaseContext.Add(d, step, num)
+ if err != nil {
+ return nil, err
+ }
+ num = d
+ }
+ return vals, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Sum",
+ Params: []kind{listKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ xs := c.decimalList(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ d := apd.New(0, 0)
+ for _, x := range xs {
+ _, err := internal.BaseContext.Add(d, x, d)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return d, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Sort",
+ Params: []kind{listKind, topKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ list, cmp := c.list(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ s := valueSorter{list, cmp, nil}
+
+ sort.Sort(&s)
+ return s.ret()
+ }()
+ }
+ },
+ }, {
+ Name: "SortStable",
+ Params: []kind{listKind, topKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ list, cmp := c.list(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ s := valueSorter{list, cmp, nil}
+ sort.Stable(&s)
+ return s.ret()
+ }()
+ }
+ },
+ }, {
+ Name: "SortStrings",
+ Params: []kind{listKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ a := c.strList(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ sort.Strings(a)
+ return a
+ }()
+ }
+ },
+ }, {
+ Name: "IsSorted",
+ Params: []kind{listKind, topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ list, cmp := c.list(0), c.value(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ s := valueSorter{list, cmp, nil}
+ return sort.IsSorted(&s)
+ }()
+ }
+ },
+ }, {
+ Name: "IsSortedStrings",
+ Params: []kind{listKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ a := c.strList(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return sort.StringsAreSorted(a)
+ }()
+ }
+ },
+ }},
+ cue: `{
+ Comparer: {
+ T: _
+ less: bool
+ x: T
+ y: T
+ }
+ Ascending: {
+ T: number | string
+ less: true && x < y
+ x: T
+ y: T
+ Comparer
+ }
+ Descending: {
+ T: number | string
+ less: x > y
+ x: T
+ y: T
+ Comparer
+ }
+}`,
+ },
+ "math": {
+ native: []*builtin{{
+ Name: "MaxExp",
+ Const: "2147483647",
+ }, {
+ Name: "MinExp",
+ Const: "-2147483648",
+ }, {
+ Name: "MaxPrec",
+ Const: "4294967295",
+ }, {
+ Name: "ToNearestEven",
+ Const: "0",
+ }, {
+ Name: "ToNearestAway",
+ Const: "1",
+ }, {
+ Name: "ToZero",
+ Const: "2",
+ }, {
+ Name: "AwayFromZero",
+ Const: "3",
+ }, {
+ Name: "ToNegativeInf",
+ Const: "4",
+ }, {
+ Name: "ToPositiveInf",
+ Const: "5",
+ }, {
+ Name: "Below",
+ Const: "-1",
+ }, {
+ Name: "Exact",
+ Const: "0",
+ }, {
+ Name: "Above",
+ Const: "1",
+ }, {
+ Name: "Jacobi",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x, y := c.bigInt(0), c.bigInt(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return big.Jacobi(x, y)
+ }()
+ }
+ },
+ }, {
+ Name: "MaxBase",
+ Const: "62",
+ }, {
+ Name: "Floor",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Floor(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Ceil",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Ceil(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Trunc",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := roundTruncContext.RoundToIntegralExact(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Round",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := roundUpContext.RoundToIntegralExact(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "RoundToEven",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := roundEvenContext.RoundToIntegralExact(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "MultipleOf",
+ Params: []kind{numKind, numKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ x, y := c.decimal(0), c.decimal(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d apd.Decimal
+ cond, err := mulContext.Quo(&d, x, y)
+ return !cond.Inexact(), err
+ }()
+ }
+ },
+ }, {
+ Name: "Abs",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Abs(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Acosh",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Acosh(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Asin",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Asin(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Acos",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Acos(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Asinh",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Asinh(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Atan",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Atan(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Atan2",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ y, x := c.float64(0), c.float64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Atan2(y, x)
+ }()
+ }
+ },
+ }, {
+ Name: "Atanh",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Atanh(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Cbrt",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Cbrt(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "E",
+ Const: "2.71828182845904523536028747135266249775724709369995957496696763",
+ }, {
+ Name: "Pi",
+ Const: "3.14159265358979323846264338327950288419716939937510582097494459",
+ }, {
+ Name: "Phi",
+ Const: "1.61803398874989484820458683436563811772030917980576286213544861",
+ }, {
+ Name: "Sqrt2",
+ Const: "1.41421356237309504880168872420969807856967187537694807317667974",
+ }, {
+ Name: "SqrtE",
+ Const: "1.64872127070012814684865078781416357165377610071014801157507931",
+ }, {
+ Name: "SqrtPi",
+ Const: "1.77245385090551602729816748334114518279754945612238712821380779",
+ }, {
+ Name: "SqrtPhi",
+ Const: "1.27201964951406896425242246173749149171560804184009624861664038",
+ }, {
+ Name: "Ln2",
+ Const: "0.693147180559945309417232121458176568075500134360255254120680009",
+ }, {
+ Name: "Log2E",
+ Const: "1.442695040888963407359924681001892137426645954152985934135449408",
+ }, {
+ Name: "Ln10",
+ Const: "2.3025850929940456840179914546843642076011014886287729760333278",
+ }, {
+ Name: "Log10E",
+ Const: "0.43429448190325182765112891891660508229439700580366656611445378",
+ }, {
+ Name: "Copysign",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x, y := c.decimal(0), c.decimal(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var d internal.Decimal
+ d.Set(x)
+ d.Negative = y.Negative
+ return &d
+ }()
+ }
+ },
+ }, {
+ Name: "Dim",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x, y := c.decimal(0), c.decimal(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Sub(&d, x, y)
+ if err != nil {
+ return nil, err
+ }
+ if d.Negative {
+ return zero, nil
+ }
+ return &d, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Erf",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Erf(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Erfc",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Erfc(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Erfinv",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Erfinv(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Erfcinv",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Erfcinv(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Exp",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Exp(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Exp2",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Pow(&d, two, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Expm1",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Expm1(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Gamma",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Gamma(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Hypot",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ p, q := c.float64(0), c.float64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Hypot(p, q)
+ }()
+ }
+ },
+ }, {
+ Name: "J0",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.J0(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Y0",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Y0(x)
+ }()
+ }
+ },
+ }, {
+ Name: "J1",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.J1(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Y1",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Y1(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Jn",
+ Params: []kind{intKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ n, x := c.int(0), c.float64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Jn(n, x)
+ }()
+ }
+ },
+ }, {
+ Name: "Yn",
+ Params: []kind{intKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ n, x := c.int(0), c.float64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Yn(n, x)
+ }()
+ }
+ },
+ }, {
+ Name: "Ldexp",
+ Params: []kind{numKind, intKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ frac, exp := c.float64(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Ldexp(frac, exp)
+ }()
+ }
+ },
+ }, {
+ Name: "Log",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Ln(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Log10",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Log10(&d, x)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Log2",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d, ln2 internal.Decimal
+ _, _ = apdContext.Ln(&ln2, two)
+ _, err := apdContext.Ln(&d, x)
+ if err != nil {
+ return &d, err
+ }
+ _, err = apdContext.Quo(&d, &d, &ln2)
+ return &d, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Log1p",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Log1p(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Logb",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Logb(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Ilogb",
+ Params: []kind{numKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Ilogb(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Mod",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x, y := c.float64(0), c.float64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Mod(x, y)
+ }()
+ }
+ },
+ }, {
+ Name: "Pow",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x, y := c.decimal(0), c.decimal(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var d internal.Decimal
+ _, err := apdContext.Pow(&d, x, y)
+ return &d, err
+ }()
+ }
+ },
+ }, {
+ Name: "Pow10",
+ Params: []kind{intKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ n := c.int32(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return apd.New(1, n)
+ }()
+ }
+ },
+ }, {
+ Name: "Remainder",
+ Params: []kind{numKind, numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x, y := c.float64(0), c.float64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Remainder(x, y)
+ }()
+ }
+ },
+ }, {
+ Name: "Signbit",
+ Params: []kind{numKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ x := c.decimal(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return x.Negative
+ }()
+ }
+ },
+ }, {
+ Name: "Cos",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Cos(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Sin",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Sin(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Sinh",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Sinh(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Cosh",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Cosh(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Sqrt",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Sqrt(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Tan",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Tan(x)
+ }()
+ }
+ },
+ }, {
+ Name: "Tanh",
+ Params: []kind{numKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ x := c.float64(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return math.Tanh(x)
+ }()
+ }
+ },
+ }},
+ },
+ "math/bits": {
+ native: []*builtin{{
+ Name: "Lsh",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x, n := c.bigInt(0), c.uint(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.Lsh(x, n)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "Rsh",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x, n := c.bigInt(0), c.uint(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.Rsh(x, n)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "At",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x, i := c.bigInt(0), c.uint(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if i > math.MaxInt32 {
+ return 0, fmt.Errorf("bit index too large")
+ }
+ return x.Bit(int(i)), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Set",
+ Params: []kind{intKind, intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x, i, bit := c.bigInt(0), c.int(1), c.uint(2)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.SetBit(x, i, bit)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "And",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ a, b := c.bigInt(0), c.bigInt(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.And(a, b)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "Or",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ a, b := c.bigInt(0), c.bigInt(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.Or(a, b)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "Xor",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ a, b := c.bigInt(0), c.bigInt(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.Xor(a, b)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "Clear",
+ Params: []kind{intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ a, b := c.bigInt(0), c.bigInt(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ var z big.Int
+ z.AndNot(a, b)
+ return &z
+ }()
+ }
+ },
+ }, {
+ Name: "OnesCount",
+ Params: []kind{intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x := c.bigInt(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ var count int
+ for _, w := range x.Bits() {
+ count += bits.OnesCount64(uint64(w))
+ }
+ return count
+ }()
+ }
+ },
+ }, {
+ Name: "Len",
+ Params: []kind{intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ x := c.bigInt(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return x.BitLen()
+ }()
+ }
+ },
+ }},
+ },
+ "net": {
+ native: []*builtin{{
+ Name: "SplitHostPort",
+ Params: []kind{stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ host, port, err := net.SplitHostPort(s)
+ if err != nil {
+ return nil, err
+ }
+ return []string{host, port}, nil
+ }()
+ }
+ },
+ }, {
+ Name: "JoinHostPort",
+ Params: []kind{topKind, topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ host, port := c.value(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ var err error
+ hostStr := ""
+ switch host.Kind() {
+ case ListKind:
+ ipdata := netGetIP(host)
+ if len(ipdata) != 4 && len(ipdata) != 16 {
+ err = fmt.Errorf("invalid host %q", host)
+ }
+ hostStr = ipdata.String()
+ case BytesKind:
+ var b []byte
+ b, err = host.Bytes()
+ hostStr = string(b)
+ default:
+ hostStr, err = host.String()
+ }
+ if err != nil {
+ return "", err
+ }
+
+ portStr := ""
+ switch port.Kind() {
+ case StringKind:
+ portStr, err = port.String()
+ case BytesKind:
+ var b []byte
+ b, err = port.Bytes()
+ portStr = string(b)
+ default:
+ var i int64
+ i, err = port.Int64()
+ portStr = strconv.Itoa(int(i))
+ }
+ if err != nil {
+ return "", err
+ }
+
+ return net.JoinHostPort(hostStr, portStr), nil
+ }()
+ }
+ },
+ }, {
+ Name: "FQDN",
+ Params: []kind{stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ for i := 0; i < len(s); i++ {
+ if s[i] >= utf8.RuneSelf {
+ return false
+ }
+ }
+ _, err := idnaProfile.ToASCII(s)
+ return err == nil
+ }()
+ }
+ },
+ }, {
+ Name: "IPv4len",
+ Const: "4",
+ }, {
+ Name: "IPv6len",
+ Const: "16",
+ }, {
+ Name: "ParseIP",
+ Params: []kind{stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ goip := net.ParseIP(s)
+ if goip == nil {
+ return nil, fmt.Errorf("invalid IP address %q", s)
+ }
+ return netToList(goip), nil
+ }()
+ }
+ },
+ }, {
+ Name: "IPv4",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+
+ return netGetIP(ip).To4() != nil
+ }()
+ }
+ },
+ }, {
+ Name: "IP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+
+ return netGetIP(ip) != nil
+ }()
+ }
+ },
+ }, {
+ Name: "LoopbackIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsLoopback()
+ }()
+ }
+ },
+ }, {
+ Name: "MulticastIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsMulticast()
+ }()
+ }
+ },
+ }, {
+ Name: "InterfaceLocalMulticastIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsInterfaceLocalMulticast()
+ }()
+ }
+ },
+ }, {
+ Name: "LinkLocalMulticastIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsLinkLocalMulticast()
+ }()
+ }
+ },
+ }, {
+ Name: "LinkLocalUnicastIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsLinkLocalUnicast()
+ }()
+ }
+ },
+ }, {
+ Name: "GlobalUnicastIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsGlobalUnicast()
+ }()
+ }
+ },
+ }, {
+ Name: "UnspecifiedIP",
+ Params: []kind{topKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return netGetIP(ip).IsUnspecified()
+ }()
+ }
+ },
+ }, {
+ Name: "ToIP4",
+ Params: []kind{topKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ ipdata := netGetIP(ip)
+ if ipdata == nil {
+ return nil, fmt.Errorf("invalid IP %q", ip)
+ }
+ ipv4 := ipdata.To4()
+ if ipv4 == nil {
+ return nil, fmt.Errorf("cannot convert %q to IPv4", ipdata)
+ }
+ return netToList(ipv4), nil
+ }()
+ }
+ },
+ }, {
+ Name: "ToIP16",
+ Params: []kind{topKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ ipdata := netGetIP(ip)
+ if ipdata == nil {
+ return nil, fmt.Errorf("invalid IP %q", ip)
+ }
+ return netToList(ipdata), nil
+ }()
+ }
+ },
+ }, {
+ Name: "IPString",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ ip := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ ipdata := netGetIP(ip)
+ if ipdata == nil {
+ return "", fmt.Errorf("invalid IP %q", ip)
+ }
+ return ipdata.String(), nil
+ }()
+ }
+ },
+ }},
+ },
+ "path": {
+ native: []*builtin{{
+ Name: "Split",
+ Params: []kind{stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ path := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ file, dir := split(path)
+ return []string{file, dir}
+ }()
+ }
+ },
+ }, {
+ Name: "Match",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ pattern, name := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return path.Match(pattern, name)
+ }()
+ }
+ },
+ }, {
+ Name: "Clean",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ path := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return pathClean(path)
+ }()
+ }
+ },
+ }, {
+ Name: "Ext",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ path := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return pathExt(path)
+ }()
+ }
+ },
+ }, {
+ Name: "Base",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ path := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return pathBase(path)
+ }()
+ }
+ },
+ }, {
+ Name: "IsAbs",
+ Params: []kind{stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ path := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return pathIsAbs(path)
+ }()
+ }
+ },
+ }, {
+ Name: "Dir",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ path := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return pathDir(path)
+ }()
+ }
+ },
+ }},
+ },
+ "regexp": {
+ native: []*builtin{{
+ Name: "Valid",
+ Params: []kind{stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ pattern := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ _, err := regexp.Compile(pattern)
+ return err == nil, err
+ }()
+ }
+ },
+ }, {
+ Name: "Find",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ pattern, s := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return "", err
+ }
+ m := re.FindStringIndex(s)
+ if m == nil {
+ return "", errNoMatch
+ }
+ return s[m[0]:m[1]], nil
+ }()
+ }
+ },
+ }, {
+ Name: "FindAll",
+ Params: []kind{stringKind, stringKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ pattern, s, n := c.string(0), c.string(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return nil, err
+ }
+ m := re.FindAllString(s, n)
+ if m == nil {
+ return nil, errNoMatch
+ }
+ return m, nil
+ }()
+ }
+ },
+ }, {
+ Name: "FindSubmatch",
+ Params: []kind{stringKind, stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ pattern, s := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return nil, err
+ }
+ m := re.FindStringSubmatch(s)
+ if m == nil {
+ return nil, errNoMatch
+ }
+ return m, nil
+ }()
+ }
+ },
+ }, {
+ Name: "FindAllSubmatch",
+ Params: []kind{stringKind, stringKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ pattern, s, n := c.string(0), c.string(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return nil, err
+ }
+ m := re.FindAllStringSubmatch(s, n)
+ if m == nil {
+ return nil, errNoMatch
+ }
+ return m, nil
+ }()
+ }
+ },
+ }, {
+ Name: "FindNamedSubmatch",
+ Params: []kind{stringKind, stringKind},
+ Result: structKind,
+ Func: func(c *callCtxt) {
+ pattern, s := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return nil, err
+ }
+ names := re.SubexpNames()
+ if len(names) == 0 {
+ return nil, errNoNamedGroup
+ }
+ m := re.FindStringSubmatch(s)
+ if m == nil {
+ return nil, errNoMatch
+ }
+ r := make(map[string]string, len(names)-1)
+ for k, name := range names {
+ if name != "" {
+ r[name] = m[k]
+ }
+ }
+ return r, nil
+ }()
+ }
+ },
+ }, {
+ Name: "FindAllNamedSubmatch",
+ Params: []kind{stringKind, stringKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ pattern, s, n := c.string(0), c.string(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ re, err := regexp.Compile(pattern)
+ if err != nil {
+ return nil, err
+ }
+ names := re.SubexpNames()
+ if len(names) == 0 {
+ return nil, errNoNamedGroup
+ }
+ m := re.FindAllStringSubmatch(s, n)
+ if m == nil {
+ return nil, errNoMatch
+ }
+ result := make([]map[string]string, len(m))
+ for i, m := range m {
+ r := make(map[string]string, len(names)-1)
+ for k, name := range names {
+ if name != "" {
+ r[name] = m[k]
+ }
+ }
+ result[i] = r
+ }
+ return result, nil
+ }()
+ }
+ },
+ }, {
+ Name: "Match",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ pattern, s := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return regexp.MatchString(pattern, s)
+ }()
+ }
+ },
+ }, {
+ Name: "QuoteMeta",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return regexp.QuoteMeta(s)
+ }()
+ }
+ },
+ }},
+ },
+ "strconv": {
+ native: []*builtin{{
+ Name: "Unquote",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return literal.Unquote(s)
+ }()
+ }
+ },
+ }, {
+ Name: "ParseBool",
+ Params: []kind{stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ str := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return strconv.ParseBool(str)
+ }()
+ }
+ },
+ }, {
+ Name: "FormatBool",
+ Params: []kind{boolKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ b := c.bool(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.FormatBool(b)
+ }()
+ }
+ },
+ }, {
+ Name: "ParseFloat",
+ Params: []kind{stringKind, intKind},
+ Result: numKind,
+ Func: func(c *callCtxt) {
+ s, bitSize := c.string(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return strconv.ParseFloat(s, bitSize)
+ }()
+ }
+ },
+ }, {
+ Name: "IntSize",
+ Const: "64",
+ }, {
+ Name: "ParseUint",
+ Params: []kind{stringKind, intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, base, bitSize := c.string(0), c.int(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return strconv.ParseUint(s, base, bitSize)
+ }()
+ }
+ },
+ }, {
+ Name: "ParseInt",
+ Params: []kind{stringKind, intKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, base, bitSize := c.string(0), c.int(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return strconv.ParseInt(s, base, bitSize)
+ }()
+ }
+ },
+ }, {
+ Name: "Atoi",
+ Params: []kind{stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return strconv.Atoi(s)
+ }()
+ }
+ },
+ }, {
+ Name: "FormatFloat",
+ Params: []kind{numKind, intKind, intKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ f, fmt, prec, bitSize := c.float64(0), c.byte(1), c.int(2), c.int(3)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.FormatFloat(f, fmt, prec, bitSize)
+ }()
+ }
+ },
+ }, {
+ Name: "FormatUint",
+ Params: []kind{intKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ i, base := c.uint64(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.FormatUint(i, base)
+ }()
+ }
+ },
+ }, {
+ Name: "FormatInt",
+ Params: []kind{intKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ i, base := c.int64(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.FormatInt(i, base)
+ }()
+ }
+ },
+ }, {
+ Name: "Quote",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.Quote(s)
+ }()
+ }
+ },
+ }, {
+ Name: "QuoteToASCII",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.QuoteToASCII(s)
+ }()
+ }
+ },
+ }, {
+ Name: "QuoteToGraphic",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.QuoteToGraphic(s)
+ }()
+ }
+ },
+ }, {
+ Name: "QuoteRune",
+ Params: []kind{intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ r := c.rune(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.QuoteRune(r)
+ }()
+ }
+ },
+ }, {
+ Name: "QuoteRuneToASCII",
+ Params: []kind{intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ r := c.rune(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.QuoteRuneToASCII(r)
+ }()
+ }
+ },
+ }, {
+ Name: "QuoteRuneToGraphic",
+ Params: []kind{intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ r := c.rune(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.QuoteRuneToGraphic(r)
+ }()
+ }
+ },
+ }, {
+ Name: "IsPrint",
+ Params: []kind{intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ r := c.rune(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.IsPrint(r)
+ }()
+ }
+ },
+ }, {
+ Name: "IsGraphic",
+ Params: []kind{intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ r := c.rune(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strconv.IsGraphic(r)
+ }()
+ }
+ },
+ }},
+ },
+ "strings": {
+ native: []*builtin{{
+ Name: "ByteAt",
+ Params: []kind{bytesKind | stringKind, intKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ b, i := c.bytes(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if i < 0 || i >= len(b) {
+ return 0, fmt.Errorf("index out of range")
+ }
+ return b[i], nil
+ }()
+ }
+ },
+ }, {
+ Name: "ByteSlice",
+ Params: []kind{bytesKind | stringKind, intKind, intKind},
+ Result: bytesKind | stringKind,
+ Func: func(c *callCtxt) {
+ b, start, end := c.bytes(0), c.int(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if start < 0 || start > end || end > len(b) {
+ return nil, fmt.Errorf("index out of range")
+ }
+ return b[start:end], nil
+ }()
+ }
+ },
+ }, {
+ Name: "Runes",
+ Params: []kind{stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return []rune(s)
+ }()
+ }
+ },
+ }, {
+ Name: "MinRunes",
+ Params: []kind{stringKind, intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s, min := c.string(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+
+ return len([]rune(s)) >= min
+ }()
+ }
+ },
+ }, {
+ Name: "MaxRunes",
+ Params: []kind{stringKind, intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s, max := c.string(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+
+ return len([]rune(s)) <= max
+ }()
+ }
+ },
+ }, {
+ Name: "ToTitle",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+
+ prev := ' '
+ return strings.Map(
+ func(r rune) rune {
+ if unicode.IsSpace(prev) {
+ prev = r
+ return unicode.ToTitle(r)
+ }
+ prev = r
+ return r
+ },
+ s)
+ }()
+ }
+ },
+ }, {
+ Name: "ToCamel",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+
+ prev := ' '
+ return strings.Map(
+ func(r rune) rune {
+ if unicode.IsSpace(prev) {
+ prev = r
+ return unicode.ToLower(r)
+ }
+ prev = r
+ return r
+ },
+ s)
+ }()
+ }
+ },
+ }, {
+ Name: "SliceRunes",
+ Params: []kind{stringKind, intKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, start, end := c.string(0), c.int(1), c.int(2)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ runes := []rune(s)
+ if start < 0 || start > end || end > len(runes) {
+ return "", fmt.Errorf("index out of range")
+ }
+ return string(runes[start:end]), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Compare",
+ Params: []kind{stringKind, stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ a, b := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Compare(a, b)
+ }()
+ }
+ },
+ }, {
+ Name: "Count",
+ Params: []kind{stringKind, stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, substr := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Count(s, substr)
+ }()
+ }
+ },
+ }, {
+ Name: "Contains",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s, substr := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Contains(s, substr)
+ }()
+ }
+ },
+ }, {
+ Name: "ContainsAny",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s, chars := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.ContainsAny(s, chars)
+ }()
+ }
+ },
+ }, {
+ Name: "LastIndex",
+ Params: []kind{stringKind, stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, substr := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.LastIndex(s, substr)
+ }()
+ }
+ },
+ }, {
+ Name: "IndexAny",
+ Params: []kind{stringKind, stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, chars := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.IndexAny(s, chars)
+ }()
+ }
+ },
+ }, {
+ Name: "LastIndexAny",
+ Params: []kind{stringKind, stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, chars := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.LastIndexAny(s, chars)
+ }()
+ }
+ },
+ }, {
+ Name: "SplitN",
+ Params: []kind{stringKind, stringKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s, sep, n := c.string(0), c.string(1), c.int(2)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.SplitN(s, sep, n)
+ }()
+ }
+ },
+ }, {
+ Name: "SplitAfterN",
+ Params: []kind{stringKind, stringKind, intKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s, sep, n := c.string(0), c.string(1), c.int(2)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.SplitAfterN(s, sep, n)
+ }()
+ }
+ },
+ }, {
+ Name: "Split",
+ Params: []kind{stringKind, stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s, sep := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Split(s, sep)
+ }()
+ }
+ },
+ }, {
+ Name: "SplitAfter",
+ Params: []kind{stringKind, stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s, sep := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.SplitAfter(s, sep)
+ }()
+ }
+ },
+ }, {
+ Name: "Fields",
+ Params: []kind{stringKind},
+ Result: listKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Fields(s)
+ }()
+ }
+ },
+ }, {
+ Name: "Join",
+ Params: []kind{listKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ elems, sep := c.strList(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Join(elems, sep)
+ }()
+ }
+ },
+ }, {
+ Name: "HasPrefix",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s, prefix := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.HasPrefix(s, prefix)
+ }()
+ }
+ },
+ }, {
+ Name: "HasSuffix",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s, suffix := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.HasSuffix(s, suffix)
+ }()
+ }
+ },
+ }, {
+ Name: "Repeat",
+ Params: []kind{stringKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, count := c.string(0), c.int(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Repeat(s, count)
+ }()
+ }
+ },
+ }, {
+ Name: "ToUpper",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.ToUpper(s)
+ }()
+ }
+ },
+ }, {
+ Name: "ToLower",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.ToLower(s)
+ }()
+ }
+ },
+ }, {
+ Name: "Trim",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, cutset := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Trim(s, cutset)
+ }()
+ }
+ },
+ }, {
+ Name: "TrimLeft",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, cutset := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.TrimLeft(s, cutset)
+ }()
+ }
+ },
+ }, {
+ Name: "TrimRight",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, cutset := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.TrimRight(s, cutset)
+ }()
+ }
+ },
+ }, {
+ Name: "TrimSpace",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.TrimSpace(s)
+ }()
+ }
+ },
+ }, {
+ Name: "TrimPrefix",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, prefix := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.TrimPrefix(s, prefix)
+ }()
+ }
+ },
+ }, {
+ Name: "TrimSuffix",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, suffix := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.TrimSuffix(s, suffix)
+ }()
+ }
+ },
+ }, {
+ Name: "Replace",
+ Params: []kind{stringKind, stringKind, stringKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s, old, new, n := c.string(0), c.string(1), c.string(2), c.int(3)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Replace(s, old, new, n)
+ }()
+ }
+ },
+ }, {
+ Name: "Index",
+ Params: []kind{stringKind, stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s, substr := c.string(0), c.string(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ return strings.Index(s, substr)
+ }()
+ }
+ },
+ }},
+ },
+ "struct": {
+ native: []*builtin{{
+ Name: "MinFields",
+ Params: []kind{structKind, intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ object, n := c.structVal(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ iter := object.Fields(Hidden(false), Optional(false))
+ count := 0
+ for iter.Next() {
+ count++
+ }
+ return count >= n, nil
+ }()
+ }
+ },
+ }, {
+ Name: "MaxFields",
+ Params: []kind{structKind, intKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ object, n := c.structVal(0), c.int(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ iter := object.Fields(Hidden(false), Optional(false))
+ count := 0
+ for iter.Next() {
+ count++
+ }
+ return count <= n, nil
+ }()
+ }
+ },
+ }},
+ },
+ "text/tabwriter": {
+ native: []*builtin{{
+ Name: "Write",
+ Params: []kind{topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ data := c.value(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ buf := &bytes.Buffer{}
+ tw := tabwriter.NewWriter(buf, 0, 4, 1, ' ', 0)
+
+ write := func(v Value) error {
+ b, err := v.Bytes()
+ if err != nil {
+ return err
+ }
+ _, err = tw.Write(b)
+ if err != nil {
+ return err
+ }
+ return nil
+ }
+
+ switch data.Kind() {
+ case BytesKind, StringKind:
+ if err := write(data); err != nil {
+ return "", err
+ }
+ case ListKind:
+ for i, _ := data.List(); i.Next(); {
+ if err := write(i.Value()); err != nil {
+ return "", err
+ }
+ _, _ = tw.Write([]byte{'\n'})
+ }
+ default:
+ return "", fmt.Errorf("tabwriter.Write: unsupported type %v", data.Kind())
+ }
+
+ err := tw.Flush()
+ return buf.String(), err
+ }()
+ }
+ },
+ }},
+ },
+ "text/template": {
+ native: []*builtin{{
+ Name: "Execute",
+ Params: []kind{stringKind, topKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ templ, data := c.string(0), c.value(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ t, err := template.New("").Parse(templ)
+ if err != nil {
+ return "", err
+ }
+ var x interface{}
+ if err := data.Decode(&x); err != nil {
+ return "", err
+ }
+ buf := &bytes.Buffer{}
+ if err := t.Execute(buf, x); err != nil {
+ return "", err
+ }
+ return buf.String(), nil
+ }()
+ }
+ },
+ }, {
+ Name: "HTMLEscape",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return template.HTMLEscapeString(s)
+ }()
+ }
+ },
+ }, {
+ Name: "JSEscape",
+ Params: []kind{stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret = func() interface{} {
+ return template.JSEscapeString(s)
+ }()
+ }
+ },
+ }},
+ },
+ "time": {
+ native: []*builtin{{
+ Name: "Nanosecond",
+ Const: "1",
+ }, {
+ Name: "Microsecond",
+ Const: "1000",
+ }, {
+ Name: "Millisecond",
+ Const: "1000000",
+ }, {
+ Name: "Second",
+ Const: "1000000000",
+ }, {
+ Name: "Minute",
+ Const: "60000000000",
+ }, {
+ Name: "Hour",
+ Const: "3600000000000",
+ }, {
+ Name: "Duration",
+ Params: []kind{stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ if _, err := time.ParseDuration(s); err != nil {
+ return false, err
+ }
+ return true, nil
+ }()
+ }
+ },
+ }, {
+ Name: "ParseDuration",
+ Params: []kind{stringKind},
+ Result: intKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ d, err := time.ParseDuration(s)
+ if err != nil {
+ return 0, err
+ }
+ return int64(d), nil
+ }()
+ }
+ },
+ }, {
+ Name: "ANSIC",
+ Const: "\"Mon Jan _2 15:04:05 2006\"",
+ }, {
+ Name: "UnixDate",
+ Const: "\"Mon Jan _2 15:04:05 MST 2006\"",
+ }, {
+ Name: "RubyDate",
+ Const: "\"Mon Jan 02 15:04:05 -0700 2006\"",
+ }, {
+ Name: "RFC822",
+ Const: "\"02 Jan 06 15:04 MST\"",
+ }, {
+ Name: "RFC822Z",
+ Const: "\"02 Jan 06 15:04 -0700\"",
+ }, {
+ Name: "RFC850",
+ Const: "\"Monday, 02-Jan-06 15:04:05 MST\"",
+ }, {
+ Name: "RFC1123",
+ Const: "\"Mon, 02 Jan 2006 15:04:05 MST\"",
+ }, {
+ Name: "RFC1123Z",
+ Const: "\"Mon, 02 Jan 2006 15:04:05 -0700\"",
+ }, {
+ Name: "RFC3339",
+ Const: "\"2006-01-02T15:04:05Z07:00\"",
+ }, {
+ Name: "RFC3339Nano",
+ Const: "\"2006-01-02T15:04:05.999999999Z07:00\"",
+ }, {
+ Name: "RFC3339Date",
+ Const: "\"2006-01-02\"",
+ }, {
+ Name: "Kitchen",
+ Const: "\"3:04PM\"",
+ }, {
+ Name: "Kitchen24",
+ Const: "\"15:04\"",
+ }, {
+ Name: "January",
+ Const: "1",
+ }, {
+ Name: "February",
+ Const: "2",
+ }, {
+ Name: "March",
+ Const: "3",
+ }, {
+ Name: "April",
+ Const: "4",
+ }, {
+ Name: "May",
+ Const: "5",
+ }, {
+ Name: "June",
+ Const: "6",
+ }, {
+ Name: "July",
+ Const: "7",
+ }, {
+ Name: "August",
+ Const: "8",
+ }, {
+ Name: "September",
+ Const: "9",
+ }, {
+ Name: "October",
+ Const: "10",
+ }, {
+ Name: "November",
+ Const: "11",
+ }, {
+ Name: "December",
+ Const: "12",
+ }, {
+ Name: "Sunday",
+ Const: "0",
+ }, {
+ Name: "Monday",
+ Const: "1",
+ }, {
+ Name: "Tuesday",
+ Const: "2",
+ }, {
+ Name: "Wednesday",
+ Const: "3",
+ }, {
+ Name: "Thursday",
+ Const: "4",
+ }, {
+ Name: "Friday",
+ Const: "5",
+ }, {
+ Name: "Saturday",
+ Const: "6",
+ }, {
+ Name: "Time",
+ Params: []kind{stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ s := c.string(0)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return timeFormat(s, time.RFC3339Nano)
+ }()
+ }
+ },
+ }, {
+ Name: "Format",
+ Params: []kind{stringKind, stringKind},
+ Result: boolKind,
+ Func: func(c *callCtxt) {
+ value, layout := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ return timeFormat(value, layout)
+ }()
+ }
+ },
+ }, {
+ Name: "Parse",
+ Params: []kind{stringKind, stringKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ layout, value := c.string(0), c.string(1)
+ if c.do() {
+ c.ret, c.err = func() (interface{}, error) {
+ t, err := time.Parse(layout, value)
+ if err != nil {
+ return "", err
+ }
+ return t.UTC().Format(time.RFC3339Nano), nil
+ }()
+ }
+ },
+ }, {
+ Name: "Unix",
+ Params: []kind{intKind, intKind},
+ Result: stringKind,
+ Func: func(c *callCtxt) {
+ sec, nsec := c.int64(0), c.int64(1)
+ if c.do() {
+ c.ret = func() interface{} {
+ t := time.Unix(sec, nsec)
+ return t.UTC().Format(time.RFC3339Nano)
+ }()
+ }
+ },
+ }},
+ },
+ "tool": {
+ native: []*builtin{},
+ cue: `{
+ Command: {
+ $usage?: string
+ $short?: string
+ $long?: string
+ Tasks
+ }
+ Tasks: Task | {
+ [name=string]: Tasks
+ }
+ Task: {
+ $type: "tool.Task"
+ $id: =~"\\."
+ $after?: Task | [...Task]
+ }
+ Name: =~"^\\PL([-](\\PL|\\PN))*$"
+}`,
+ },
+ "tool/cli": {
+ native: []*builtin{},
+ cue: `{
+ Print: {
+ $id: *"tool/cli.Print" | "print"
+ text: string
+ }
+}`,
+ },
+ "tool/exec": {
+ native: []*builtin{},
+ cue: `{
+ Run: {
+ $id: *"tool/exec.Run" | "exec"
+ cmd: string | [string, ...string]
+ env: {
+ [string]: string | [...=~"="]
+ }
+ stdout: *null | string | bytes
+ stderr: *null | string | bytes
+ stdin: *null | string | bytes
+ success: bool
+ }
+}`,
+ },
+ "tool/file": {
+ native: []*builtin{},
+ cue: `{
+ Read: {
+ $id: "tool/file.Read"
+ filename: !=""
+ contents: *bytes | string
+ }
+ Create: {
+ $id: "tool/file.Create"
+ filename: !=""
+ contents: bytes | string
+ permissions: int | *420
+ }
+ Append: {
+ $id: "tool/file.Append"
+ filename: !=""
+ contents: bytes | string
+ permissions: int | *420
+ }
+ Glob: {
+ $id: "tool/file.Glob"
+ glob: !=""
+ files: [...string]
+ }
+}`,
+ },
+ "tool/http": {
+ native: []*builtin{},
+ cue: `{
+ Get: Do & {
+ method: "GET"
+ }
+ Do: {
+ $id: *"tool/http.Do" | "http"
+ method: string
+ response: {
+ body: *bytes | string
+ header: {
+ [string]: string | [...string]
+ }
+ trailer: {
+ [string]: string | [...string]
+ }
+ status: string
+ statusCode: int
+ }
+ url: string
+ request: {
+ body: *bytes | string
+ header: {
+ [string]: string | [...string]
+ }
+ trailer: {
+ [string]: string | [...string]
+ }
+ }
+ }
+ Post: Do & {
+ method: "POST"
+ }
+ Put: Do & {
+ method: "PUT"
+ }
+ Delete: Do & {
+ method: "DELETE"
+ }
+}`,
+ },
+ "tool/os": {
+ native: []*builtin{},
+ cue: `{
+ Name: !="" & !~"^[$]"
+ Value: bool | number | *string | null
+ Setenv: {
+ $id: "tool/os.Setenv"
+ {[Name]: Value}
+ }
+ Getenv: {
+ $id: "tool/os.Getenv"
+ {[Name]: Value}
+ }
+ Environ: {
+ $id: "tool/os.Environ"
+ {[Name]: Value}
+ }
+ Clearenv: {
+ $id: "tool/os.Clearenv"
+ }
+}`,
+ },
+}
diff --git a/internal/legacy/cue/builtinutil.go b/internal/legacy/cue/builtinutil.go
new file mode 100644
index 0000000..df22d71
--- /dev/null
+++ b/internal/legacy/cue/builtinutil.go
@@ -0,0 +1,57 @@
+// 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 cue
+
+// TODO: this code could be generated, but currently isn't.
+
+type valueSorter struct {
+ a []Value
+ cmp Value
+ err error
+}
+
+func (s *valueSorter) ret() ([]Value, error) {
+ if s.err != nil {
+ return nil, s.err
+ }
+ // The input slice is already a copy and that we can modify it safely.
+ return s.a, nil
+}
+
+func (s *valueSorter) Len() int { return len(s.a) }
+func (s *valueSorter) Swap(i, j int) { s.a[i], s.a[j] = s.a[j], s.a[i] }
+func (s *valueSorter) Less(i, j int) bool {
+ x := fill(s.cmp, s.a[i], "x")
+ x = fill(x, s.a[j], "y")
+ isLess, err := x.Lookup("less").Bool()
+ if err != nil && s.err == nil {
+ s.err = err
+ return true
+ }
+ return isLess
+}
+
+// fill creates a new value with the old value unified with the given value.
+// TODO: consider making this a method on Value.
+func fill(v Value, x interface{}, path ...string) Value {
+ ctx := v.ctx()
+ root := v.v.val()
+ for i := len(path) - 1; i >= 0; i-- {
+ x = map[string]interface{}{path[i]: x}
+ }
+ value := convertVal(ctx, root, false, x)
+ eval := binOp(ctx, baseValue{}, opUnify, root, value)
+ return newValueRoot(ctx, eval)
+}
diff --git a/internal/legacy/cue/context.go b/internal/legacy/cue/context.go
new file mode 100644
index 0000000..a63e3e9
--- /dev/null
+++ b/internal/legacy/cue/context.go
@@ -0,0 +1,121 @@
+// 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 cue
+
+import (
+ "github.com/cockroachdb/apd/v2"
+)
+
+// context manages evaluation state.
+type context struct {
+ *apd.Context
+
+ *index
+
+ forwardMap []scope // pairs
+ oldSize []int
+
+ // constraints are to be evaluated at the end values to be evaluated later.
+ constraints []*binaryExpr
+ evalStack []bottom
+
+ inDefinition int
+ inSum int
+ cycleErr bool
+
+ // for debug strings
+ nodeRefs map[scope]string
+
+ // tracing
+ trace bool
+ level int
+
+ // TODO: replace with proper structural cycle detection/ occurs check.
+ // See Issue #29.
+ maxDepth int
+}
+
+func (c *context) incEvalDepth() {
+ if len(c.evalStack) > 0 {
+ c.evalStack[len(c.evalStack)-1].exprDepth++
+ }
+}
+
+func (c *context) decEvalDepth() {
+ if len(c.evalStack) > 0 {
+ c.evalStack[len(c.evalStack)-1].exprDepth--
+ }
+}
+
+var baseContext apd.Context
+
+func init() {
+ baseContext = apd.BaseContext
+ baseContext.Precision = 24
+}
+
+// newContext returns a new evaluation context.
+func (idx *index) newContext() *context {
+ c := &context{
+ Context: &baseContext,
+ index: idx,
+ }
+ return c
+}
+
+// delayConstraint schedules constraint to be evaluated and returns ret. If
+// delaying constraints is currently not allowed, it returns an error instead.
+func (c *context) delayConstraint(ret evaluated, constraint *binaryExpr) evaluated {
+ c.cycleErr = true
+ c.constraints = append(c.constraints, constraint)
+ return ret
+}
+
+func (c *context) processDelayedConstraints() evaluated {
+ cons := c.constraints
+ c.constraints = c.constraints[:0]
+ for _, dc := range cons {
+ v := binOp(c, dc, dc.Op, dc.X.evalPartial(c), dc.Y.evalPartial(c))
+ if isBottom(v) {
+ return v
+ }
+ }
+ return nil
+}
+
+func (c *context) deref(f scope) scope {
+outer:
+ for {
+ for i := 0; i < len(c.forwardMap); i += 2 {
+ if c.forwardMap[i] == f {
+ f = c.forwardMap[i+1]
+ continue outer
+ }
+ }
+ return f
+ }
+}
+
+func (c *context) pushForwards(pairs ...scope) *context {
+ c.oldSize = append(c.oldSize, len(c.forwardMap))
+ c.forwardMap = append(c.forwardMap, pairs...)
+ return c
+}
+
+func (c *context) popForwards() {
+ last := len(c.oldSize) - 1
+ c.forwardMap = c.forwardMap[:c.oldSize[last]]
+ c.oldSize = c.oldSize[:last]
+}
diff --git a/internal/legacy/cue/cue.go b/internal/legacy/cue/cue.go
new file mode 100644
index 0000000..2e0a031
--- /dev/null
+++ b/internal/legacy/cue/cue.go
@@ -0,0 +1,17 @@
+// Copyright 2020 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 cue is a transition package for supporting the cue.Value API.
+// It aims to be plugin compatible with the old API.
+package cue
diff --git a/internal/legacy/cue/errors.go b/internal/legacy/cue/errors.go
new file mode 100644
index 0000000..467254f
--- /dev/null
+++ b/internal/legacy/cue/errors.go
@@ -0,0 +1,311 @@
+// 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 cue
+
+import (
+ "fmt"
+ "reflect"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal/core/adt"
+)
+
+var _ errors.Error = &nodeError{}
+
+// A nodeError is an error associated with processing an AST node.
+type nodeError struct {
+ path []string // optional
+ n ast.Node
+
+ errors.Message
+}
+
+func (n *nodeError) Error() string {
+ return errors.String(n)
+}
+
+func nodeErrorf(n ast.Node, format string, args ...interface{}) *nodeError {
+ return &nodeError{
+ n: n,
+ Message: errors.NewMessage(format, args),
+ }
+}
+
+func (e *nodeError) Position() token.Pos {
+ return e.n.Pos()
+}
+
+func (e *nodeError) InputPositions() []token.Pos { return nil }
+
+func (e *nodeError) Path() []string {
+ return e.path
+}
+
+func (v Value) appendErr(err errors.Error, b *bottom) errors.Error {
+ switch {
+ case len(b.sub) > 0:
+ for _, b := range b.sub {
+ err = v.appendErr(err, b)
+ }
+ fallthrough
+ case b.err != nil:
+ err = errors.Append(err, b.err)
+ default:
+ err = errors.Append(err, &valueError{
+ v: v,
+ err: b,
+ })
+ }
+ return err
+}
+
+func (v Value) toErr(b *bottom) (err errors.Error) {
+ return v.appendErr(nil, b)
+}
+
+var _ errors.Error = &valueError{}
+
+// A valueError is returned as a result of evaluating a value.
+type valueError struct {
+ v Value
+ err *bottom
+}
+
+func (e *valueError) Error() string {
+ return errors.String(e)
+}
+
+func (e *valueError) Position() token.Pos {
+ return e.err.Pos()
+}
+
+func (e *valueError) InputPositions() []token.Pos {
+ return e.err.Positions(e.v.ctx())
+}
+
+func (e *valueError) Msg() (string, []interface{}) {
+ return e.err.Msg()
+}
+
+func (e *valueError) Path() (a []string) {
+ if e.v.v == nil {
+ return nil
+ }
+ a, _ = e.v.v.appendPath(a, e.v.idx)
+ return a
+}
+
+type errCode = adt.ErrorCode
+
+const (
+ codeNone errCode = 0
+ codeFatal = adt.EvalError
+ codeNotExist = adt.NotExistError
+ codeTypeError = adt.EvalError
+ codeIncomplete = adt.IncompleteError
+ codeUser = adt.UserError
+ codeCycle = adt.CycleError
+)
+
+func isIncomplete(v value) bool {
+ if err, ok := v.(*bottom); ok {
+ return err.Code == codeIncomplete || err.Code == codeCycle
+ }
+ return false
+}
+
+func isLiteralBottom(v value) bool {
+ if err, ok := v.(*bottom); ok {
+ return err.Code == codeUser
+ }
+ return false
+}
+
+var errNotExists = &bottom{Code: codeNotExist, format: "undefined value"}
+
+func exists(v value) bool {
+ if err, ok := v.(*bottom); ok {
+ return err.Code != codeNotExist
+ }
+ return true
+}
+
+// bottom is the bottom of the value lattice. It is subsumed by all values.
+type bottom struct {
+ baseValue
+
+ index *index
+ Code errCode
+ exprDepth int
+ pos source
+ format string
+ args []interface{}
+
+ err errors.Error // pass-through from higher-level API
+ sub []*bottom // sub errors
+ value value
+ wrapped *bottom
+}
+
+func (x *bottom) Kind() kind { return bottomKind }
+
+func (x *bottom) Positions(ctx *context) []token.Pos {
+ var a []token.Pos
+ if x.index != nil { // TODO: remove check?
+ a = appendPositions(ctx, nil, x.pos)
+ }
+ if w := x.wrapped; w != nil {
+ a = append(a, w.Positions(ctx)...)
+ }
+ for _, sub := range x.sub {
+ a = append(a, sub.Positions(ctx)...)
+ }
+ return a
+}
+
+func appendPositions(ctx *context, pos []token.Pos, src source) []token.Pos {
+ if len(pos) > 15 {
+ return pos
+ }
+ if src != nil {
+ if p := src.Pos(); p != token.NoPos {
+ pos = append(pos, src.Pos())
+ }
+ if c := src.computed(); c != nil {
+ pos = appendPositions(ctx, pos, c.x)
+ pos = appendPositions(ctx, pos, c.y)
+ }
+ switch x := src.(type) {
+ case evaluated:
+ case value:
+ pos = appendPositions(ctx, pos, x.evalPartial(ctx))
+ }
+ }
+ return pos
+}
+
+func (x *bottom) Msg() (format string, args []interface{}) {
+ ctx := x.index.newContext()
+ // We need to copy to avoid races.
+ args = make([]interface{}, len(x.args))
+ copy(args, x.args)
+ preEvalArgs(ctx, args)
+ return x.format, x.args
+}
+
+func (x *bottom) msg() string {
+ return fmt.Sprint(x)
+}
+
+func (x *bottom) Format(s fmt.State, verb rune) {
+ msg, args := x.Msg()
+ fmt.Fprintf(s, msg, args...)
+}
+
+func cycleError(v evaluated) *bottom {
+ if err, ok := v.(*bottom); ok && err.Code == codeCycle {
+ return err
+ }
+ return nil
+}
+
+func (c *context) mkIncompatible(src source, op op, a, b evaluated) evaluated {
+ if err := firstBottom(a, b); err != nil {
+ return err
+ }
+ e := mkBin(c, src.Pos(), op, a, b)
+ return c.mkErr(e, "invalid operation %s %s %s (mismatched types %s and %s)",
+ c.str(a), op, c.str(b), a.Kind(), b.Kind())
+}
+
+func (idx *index) mkErr(src source, args ...interface{}) *bottom {
+ e := &bottom{index: idx, pos: src}
+ if src != nil {
+ e.baseValue = src.base()
+ }
+ if v, ok := src.(value); ok {
+ e.value = v
+ }
+outer:
+ for i, a := range args {
+ switch x := a.(type) {
+ case errCode:
+ e.Code = x
+ case *bottom:
+ e.wrapped = x
+ case []*bottom:
+ e.sub = x
+ case errors.Error:
+ e.err = x
+ case value:
+ case string:
+ e.format = x
+ e.args = args[i+1:]
+ // Do not expand message so that errors can be localized.
+ for i, a := range e.args {
+ e.args[i] = fixArg(idx, a)
+ }
+ break outer
+ }
+ }
+ if e.Code == codeNone && e.wrapped != nil {
+ e.Code = e.wrapped.Code
+ }
+ return e
+}
+
+func fixArg(idx *index, x interface{}) interface{} {
+ switch x.(type) {
+ case uint, int, string:
+ return x
+ case value:
+ return x
+ }
+ t := reflect.TypeOf(x)
+ // Store all non-ptr types as is, as they cannot change.
+ if k := t.Kind(); k == reflect.String || k <= reflect.Complex128 {
+ return x
+ }
+ return fmt.Sprint(x)
+}
+
+// preEvalArgs is used to expand value arguments just before printing.
+func preEvalArgs(ctx *context, args []interface{}) {
+ for i, a := range args {
+ switch v := a.(type) {
+ case *bottom:
+ args[i] = v.msg()
+ case value:
+ // TODO: convert to Go values so that localization frameworks
+ // can format values accordingly.
+ args[i] = ctx.str(v)
+ }
+ }
+}
+
+func isBottom(n value) bool {
+ return n.Kind() == bottomKind
+}
+
+func firstBottom(v ...value) *bottom {
+ for _, b := range v {
+ if isBottom(b) {
+ return b.(*bottom)
+ }
+ }
+ return nil
+}
diff --git a/internal/legacy/cue/instance.go b/internal/legacy/cue/instance.go
new file mode 100644
index 0000000..a779041
--- /dev/null
+++ b/internal/legacy/cue/instance.go
@@ -0,0 +1,365 @@
+// 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 cue
+
+import (
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/runtime"
+)
+
+// An Instance defines a single configuration based on a collection of
+// underlying CUE files.
+type Instance struct {
+ *index
+
+ rootStruct *structLit // the struct to insert root values into
+ rootValue value // the value to evaluate: may add comprehensions
+
+ // scope is used as an additional top-level scope between the package scope
+ // and the predeclared identifiers.
+ scope *structLit
+
+ ImportPath string
+ Dir string
+ PkgName string
+ DisplayName string
+
+ Incomplete bool // true if Pkg and all its dependencies are free of errors
+ Err errors.Error // non-nil if the package had errors
+
+ inst *build.Instance
+
+ complete bool // for cycle detection
+}
+
+func (x *index) addInst(p *Instance) *Instance {
+ x.Index.AddInst(p.ImportPath, p.rootStruct, p)
+ p.index = x
+ return p
+}
+
+func (x *index) getImportFromNode(v value) *Instance {
+ p := x.Index.GetImportFromNode(v)
+ if p == nil {
+ return nil
+ }
+ return p.(*Instance)
+}
+
+func (x *index) getImportFromPath(id string) *Instance {
+ node := x.Index.GetImportFromPath(id)
+ if node == nil {
+ return nil
+ }
+ return x.Index.GetImportFromNode(node).(*Instance)
+}
+
+func init() {
+ internal.MakeInstance = func(value interface{}) interface{} {
+ v := value.(Value)
+ x := v.eval(v.ctx())
+ st, ok := x.(*structLit)
+ if !ok {
+ st = &structLit{baseValue: x.base(), emit: x}
+ }
+ return v.ctx().index.addInst(&Instance{
+ rootStruct: st,
+ rootValue: v.v.v,
+ })
+ }
+}
+
+// newInstance creates a new instance. Use Insert to populate the instance.
+func newInstance(x *index, p *build.Instance) *Instance {
+ // TODO: associate root source with structLit.
+ st := &structLit{baseValue: baseValue{nil}}
+ i := &Instance{
+ rootStruct: st,
+ rootValue: st,
+ inst: p,
+ }
+ if p != nil {
+ i.ImportPath = p.ImportPath
+ i.Dir = p.Dir
+ i.PkgName = p.PkgName
+ i.DisplayName = p.ImportPath
+ if p.Err != nil {
+ i.setListOrError(p.Err)
+ }
+ }
+ return x.addInst(i)
+}
+
+func (inst *Instance) setListOrError(err errors.Error) {
+ inst.Incomplete = true
+ inst.Err = errors.Append(inst.Err, err)
+}
+
+func (inst *Instance) setError(err errors.Error) {
+ inst.Incomplete = true
+ inst.Err = errors.Append(inst.Err, err)
+}
+
+func (inst *Instance) eval(ctx *context) evaluated {
+ // TODO: remove manifest here?
+ v := ctx.manifest(inst.rootValue)
+ if s, ok := v.(*structLit); ok && s.emit != nil {
+ e := s.emit.evalPartial(ctx)
+ src := binSrc(token.NoPos, opUnify, v, e)
+ outer:
+ switch e.(type) {
+ case *structLit, *top:
+ v = binOp(ctx, src, opUnifyUnchecked, v, e)
+ if s, ok := v.(*structLit); ok {
+ s.emit = nil
+ }
+
+ default:
+ for _, a := range s.Arcs {
+ if !a.definition {
+ v = binOp(ctx, src, opUnify, v, e)
+ break outer
+ }
+ }
+ return e
+ }
+ }
+ return v
+}
+
+func init() {
+ internal.EvalExpr = func(value, expr interface{}) interface{} {
+ v := value.(Value)
+ e := expr.(ast.Expr)
+ ctx := v.idx.newContext()
+ return newValueRoot(ctx, evalExpr(ctx, v.eval(ctx), e))
+ }
+}
+
+func evalExpr(ctx *context, x value, expr ast.Expr) evaluated {
+ if isBottom(x) {
+ return ctx.mkErr(x, "error evaluating instance: %v", x)
+ }
+ obj, ok := x.(*structLit)
+ if !ok {
+ return ctx.mkErr(x, "instance is not a struct, found %s", x.Kind())
+ }
+ v := newVisitor(ctx.index, nil, nil, obj, true)
+ return v.walk(expr).evalPartial(ctx)
+}
+
+// Doc returns the package comments for this instance.
+func (inst *Instance) Doc() []*ast.CommentGroup {
+ var docs []*ast.CommentGroup
+ if inst.inst == nil {
+ return nil
+ }
+ for _, f := range inst.inst.Files {
+ if c := internal.FileComment(f); c != nil {
+ docs = append(docs, c)
+ }
+ }
+ return docs
+}
+
+// Value returns the root value of the configuration. If the configuration
+// defines in emit value, it will be that value. Otherwise it will be all
+// top-level values.
+func (inst *Instance) Value() Value {
+ ctx := inst.newContext()
+ return newValueRoot(ctx, inst.eval(ctx))
+}
+
+// Eval evaluates an expression within an existing instance.
+//
+// Expressions may refer to builtin packages if they can be uniquely identified.
+func (inst *Instance) Eval(expr ast.Expr) Value {
+ ctx := inst.newContext()
+ result := evalExpr(ctx, inst.eval(ctx), expr)
+ return newValueRoot(ctx, result)
+}
+
+// Merge unifies the given instances into a single one.
+//
+// Errors regarding conflicts are included in the result, but not reported, so
+// that these will only surface during manifestation. This allows
+// non-conflicting parts to be used.
+func Merge(inst ...*Instance) *Instance {
+ switch len(inst) {
+ case 0:
+ return nil
+ case 1:
+ return inst[0]
+ }
+
+ values := []value{}
+ for _, i := range inst {
+ if i.Err != nil {
+ return i
+ }
+ values = append(values, i.rootValue)
+ }
+ merged := &mergedValues{values: values}
+
+ ctx := inst[0].newContext()
+
+ st, ok := ctx.manifest(merged).(*structLit)
+ if !ok {
+ return nil
+ }
+
+ p := ctx.index.addInst(&Instance{
+ rootStruct: st,
+ rootValue: merged,
+ complete: true,
+ })
+ return p
+}
+
+// Build creates a new instance from the build instances, allowing unbound
+// identifier to bind to the top-level field in inst. The top-level fields in
+// inst take precedence over predeclared identifier and builtin functions.
+func (inst *Instance) Build(p *build.Instance) *Instance {
+ p.Complete()
+
+ idx := inst.index
+
+ i := newInstance(idx, p)
+ if i.Err != nil {
+ return i
+ }
+
+ ctx := inst.newContext()
+ val := newValueRoot(ctx, inst.rootValue)
+ v, err := val.structValFull(ctx)
+ if err != nil {
+ i.setError(val.toErr(err))
+ return i
+ }
+ i.scope = v.obj
+
+ if err := runtime.ResolveFiles(idx.Index, p, isBuiltin); err != nil {
+ i.setError(err)
+ return i
+ }
+ for _, f := range p.Files {
+ if err := i.insertFile(f); err != nil {
+ i.setListOrError(err)
+ }
+ }
+ i.complete = true
+
+ return i
+}
+
+func (inst *Instance) value() Value {
+ return newValueRoot(inst.newContext(), inst.rootValue)
+}
+
+// Lookup reports the value at a path starting from the top level struct. The
+// Exists method of the returned value will report false if the path did not
+// exist. The Err method reports if any error occurred during evaluation. The
+// empty path returns the top-level configuration struct. Use LookupDef for definitions or LookupField for
+// any kind of field.
+func (inst *Instance) Lookup(path ...string) Value {
+ return inst.value().Lookup(path...)
+}
+
+// LookupDef reports the definition with the given name within struct v. The
+// Exists method of the returned value will report false if the definition did
+// not exist. The Err method reports if any error occurred during evaluation.
+func (inst *Instance) LookupDef(path string) Value {
+ return inst.value().LookupDef(path)
+}
+
+// LookupField reports a Field at a path starting from v, or an error if the
+// path is not. The empty path returns v itself.
+//
+// It cannot look up hidden or unexported fields.
+//
+// Deprecated: this API does not work with new-style definitions. Use
+// FieldByName defined on inst.Value().
+func (inst *Instance) LookupField(path ...string) (f FieldInfo, err error) {
+ v := inst.value()
+ for _, k := range path {
+ s, err := v.Struct()
+ if err != nil {
+ return f, err
+ }
+
+ f, err = s.FieldByName(k, true)
+ if err != nil {
+ return f, err
+ }
+ if f.IsHidden {
+ return f, errNotFound
+ }
+ v = f.Value
+ }
+ return f, err
+}
+
+// Fill creates a new instance with the values of the old instance unified with
+// the given value. It is not possible to update the emit value.
+//
+// Values may be any Go value that can be converted to CUE, an ast.Expr or
+// a Value. In the latter case, it will panic if the Value is not from the same
+// Runtime.
+func (inst *Instance) Fill(x interface{}, path ...string) (*Instance, error) {
+ ctx := inst.newContext()
+ root := ctx.manifest(inst.rootValue)
+ for i := len(path) - 1; i >= 0; i-- {
+ x = map[string]interface{}{path[i]: x}
+ }
+ value := convertVal(ctx, root, true, x)
+ eval := binOp(ctx, baseValue{}, opUnify, root, value)
+ // TODO: validate recursively?
+ err := inst.Err
+ var st *structLit
+ var stVal evaluated
+ switch x := eval.(type) {
+ case *structLit:
+ st = x
+ stVal = x
+ default:
+ // This should not happen.
+ b := ctx.mkErr(eval, "error filling struct")
+ err = inst.Value().toErr(b)
+ st = &structLit{emit: b}
+ stVal = b
+ case *bottom:
+ err = inst.Value().toErr(x)
+ st = &structLit{emit: x}
+ stVal = x
+ }
+ inst = inst.index.addInst(&Instance{
+ rootStruct: st,
+ rootValue: stVal,
+ inst: nil,
+
+ // Omit ImportPath to indicate this is not an importable package.
+ Dir: inst.Dir,
+ PkgName: inst.PkgName,
+ Incomplete: inst.Incomplete,
+ Err: err,
+
+ complete: err != nil,
+ })
+ return inst, err
+}
diff --git a/internal/legacy/cue/marshal.go b/internal/legacy/cue/marshal.go
new file mode 100644
index 0000000..fd3cbe1
--- /dev/null
+++ b/internal/legacy/cue/marshal.go
@@ -0,0 +1,215 @@
+// 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 cue
+
+import (
+ "bytes"
+ "compress/gzip"
+ "encoding/gob"
+ "path/filepath"
+ "strings"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/ast/astutil"
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/format"
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal"
+)
+
+// root.
+type instanceData struct {
+ Root bool
+ Path string
+ Files []fileData
+}
+
+type fileData struct {
+ Name string
+ Data []byte
+}
+
+const version = 1
+
+type unmarshaller struct {
+ ctxt *build.Context
+ imports map[string]*instanceData
+}
+
+func (b *unmarshaller) load(pos token.Pos, path string) *build.Instance {
+ bi := b.imports[path]
+ if bi == nil {
+ return nil
+ }
+ return b.build(bi)
+}
+
+func (b *unmarshaller) build(bi *instanceData) *build.Instance {
+ p := b.ctxt.NewInstance(bi.Path, b.load)
+ p.ImportPath = bi.Path
+ for _, f := range bi.Files {
+ _ = p.AddFile(f.Name, f.Data)
+ }
+ p.Complete()
+ return p
+}
+
+func compileInstances(r *Runtime, data []*instanceData) (instances []*Instance, err error) {
+ b := unmarshaller{
+ ctxt: r.buildContext(),
+ imports: map[string]*instanceData{},
+ }
+ for _, i := range data {
+ if i.Path == "" {
+ if !i.Root {
+ return nil, errors.Newf(token.NoPos,
+ "data contains non-root package without import path")
+ }
+ continue
+ }
+ b.imports[i.Path] = i
+ }
+
+ builds := []*build.Instance{}
+ for _, i := range data {
+ if !i.Root {
+ continue
+ }
+ builds = append(builds, b.build(i))
+ }
+
+ return r.build(builds)
+}
+
+// Unmarshal creates an Instance from bytes generated by the MarshalBinary
+// method of an instance.
+func (r *Runtime) Unmarshal(b []byte) ([]*Instance, error) {
+ if len(b) == 0 {
+ return nil, errors.Newf(token.NoPos, "unmarshal failed: empty buffer")
+ }
+
+ switch b[0] {
+ case version:
+ default:
+ return nil, errors.Newf(token.NoPos,
+ "unmarshal failed: unsupported version %d, regenerate data", b[0])
+ }
+
+ reader, err := gzip.NewReader(bytes.NewReader(b[1:]))
+ if err != nil {
+ return nil, errors.Newf(token.NoPos, "unmarshal failed: %v", err)
+ }
+
+ data := []*instanceData{}
+ err = gob.NewDecoder(reader).Decode(&data)
+ if err != nil {
+ return nil, errors.Newf(token.NoPos, "unmarshal failed: %v", err)
+ }
+
+ return compileInstances(r, data)
+}
+
+// Marshal creates bytes from a group of instances. Imported instances will
+// be included in the emission.
+//
+// The stored instances are functionally the same, but preserving of file
+// information is only done on a best-effort basis.
+func (r *Runtime) Marshal(instances ...*Instance) (b []byte, err error) {
+ ctx := r.index().newContext()
+
+ staged := []instanceData{}
+ done := map[string]int{}
+
+ var errs errors.Error
+
+ var stageInstance func(i *Instance) (pos int)
+ stageInstance = func(i *Instance) (pos int) {
+ if p, ok := done[i.ImportPath]; ok {
+ return p
+ }
+ // TODO: support exporting instance
+ file, _ := exportFile(ctx, nil, i.rootValue, options{raw: true})
+ imports := []string{}
+ for _, i := range internal.Imports(file) {
+ for _, spec := range i.(*ast.ImportDecl).Specs {
+ info, _ := astutil.ParseImportSpec(spec)
+ imports = append(imports, info.ID)
+ }
+ }
+
+ if i.PkgName != "" {
+ pkg := &ast.Package{Name: ast.NewIdent(i.PkgName)}
+ file.Decls = append([]ast.Decl{pkg}, file.Decls...)
+ }
+
+ b, err := format.Node(file)
+ errs = errors.Append(errs, errors.Promote(err, "marshal"))
+
+ filename := "unmarshal"
+ if i.inst != nil && len(i.inst.Files) == 1 {
+ filename = i.inst.Files[0].Filename
+
+ dir := i.Dir
+ if i.inst != nil && i.inst.Root != "" {
+ dir = i.inst.Root
+ }
+ if dir != "" {
+ filename = filepath.FromSlash(filename)
+ filename, _ = filepath.Rel(dir, filename)
+ filename = filepath.ToSlash(filename)
+ }
+ }
+ // TODO: this should probably be changed upstream, but as the path
+ // is for reference purposes only, this is safe.
+ importPath := filepath.ToSlash(i.ImportPath)
+
+ staged = append(staged, instanceData{
+ Path: importPath,
+ Files: []fileData{{filename, b}},
+ })
+
+ p := len(staged) - 1
+
+ for _, imp := range imports {
+ i := ctx.getImportFromPath(imp)
+ if i == nil || !strings.Contains(imp, ".") {
+ continue // a builtin package.
+ }
+ stageInstance(i)
+ }
+
+ return p
+ }
+
+ for _, i := range instances {
+ staged[stageInstance(i)].Root = true
+ }
+
+ buf := &bytes.Buffer{}
+ buf.WriteByte(version)
+
+ zw := gzip.NewWriter(buf)
+ if err := gob.NewEncoder(zw).Encode(staged); err != nil {
+ return nil, err
+ }
+
+ if err := zw.Close(); err != nil {
+ return nil, err
+ }
+
+ return buf.Bytes(), nil
+
+}
diff --git a/internal/legacy/cue/marshal_test.go b/internal/legacy/cue/marshal_test.go
new file mode 100644
index 0000000..b380b1a
--- /dev/null
+++ b/internal/legacy/cue/marshal_test.go
@@ -0,0 +1,202 @@
+// 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 cue
+
+import (
+ "fmt"
+ "strings"
+ "testing"
+
+ "github.com/google/go-cmp/cmp"
+)
+
+func TestMarshalling(t *testing.T) {
+ testCases := []struct {
+ filename string
+ input string
+ pkg string
+ }{{
+ filename: "foo.cue",
+ pkg: "foo",
+ input: `package foo
+
+ A: int
+ B: string
+ `,
+ }, {
+ filename: "bar.cue",
+ pkg: "bar",
+ input: `package bar
+
+ "Hello world!"
+ `,
+ }, {
+ filename: "qux.cue",
+ input: `
+ "Hello world!"
+ `,
+ }, {
+ filename: "baz.cue",
+ pkg: "baz",
+ input: `package baz
+
+ import "strings"
+
+ a: strings.TrimSpace(" Hello world! ")
+ `}}
+ for _, tc := range testCases {
+ t.Run(tc.filename, func(t *testing.T) {
+ r := &Runtime{}
+ inst, err := r.Compile(tc.filename, tc.input)
+ if err != nil {
+ t.Fatal(err)
+ }
+ inst.ImportPath = "test/pkg"
+ want := fmt.Sprint(inst.Value())
+
+ b, err := r.Marshal(inst)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ r2 := &Runtime{}
+ instances, err := r2.Unmarshal(b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ inst = instances[0]
+
+ if inst.ImportPath != "test/pkg" {
+ t.Error("import path was not restored")
+ }
+ got := fmt.Sprint(inst.Value())
+
+ if got != want {
+ t.Errorf("\ngot: %q;\nwant: %q", got, want)
+ }
+ })
+ }
+}
+
+func TestMarshalMultiPackage(t *testing.T) {
+ files := func(s ...string) (a []fileData) {
+ for i, s := range s {
+ a = append(a, fileData{fmt.Sprintf("file%d.cue", i), []byte(s)})
+ }
+ return a
+ }
+ insts := func(i ...*instanceData) []*instanceData { return i }
+ pkg1 := &instanceData{
+ true,
+ "pkg1",
+ files(`
+ package pkg1
+
+ Object: "World"
+ `),
+ }
+ pkg2 := &instanceData{
+ true,
+ "example.com/foo/pkg2",
+ files(`
+ package pkg
+
+ Number: 12
+ `),
+ }
+
+ testCases := []struct {
+ instances []*instanceData
+ emit string
+ }{{
+ insts(&instanceData{true, "", files(`test: "ok"`)}),
+ `{test: "ok"}`,
+ }, {
+ insts(&instanceData{true, "",
+ files(
+ `package test
+
+ import math2 "math"
+
+ "Pi: \(math2.Pi)!"`)}),
+ `"Pi: 3.14159265358979323846264338327950288419716939937510582097494459!"`,
+ }, {
+ insts(pkg1, &instanceData{true, "",
+ files(
+ `package test
+
+ import "pkg1"
+
+ "Hello \(pkg1.Object)!"`),
+ }),
+ `"Hello World!"`,
+ }, {
+ insts(pkg1, &instanceData{true, "",
+ files(
+ `package test
+
+ import pkg2 "pkg1"
+ pkg1: pkg2.Object
+
+ "Hello \(pkg1)!"`),
+ }),
+ `"Hello World!"`,
+ }, {
+ insts(pkg2, &instanceData{true, "",
+ files(
+ `package test
+
+ import "example.com/foo/pkg2"
+
+ "Hello \(pkg.Number)!"`),
+ }),
+ `"Hello 12!"`,
+ }}
+
+ strValue := func(a []*Instance) (ret []string) {
+ for _, i := range a {
+ ret = append(ret, strings.TrimSpace((fmt.Sprint(i.Value()))))
+ }
+ return ret
+ }
+
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ r := &Runtime{}
+
+ insts, err := compileInstances(r, tc.instances)
+ if err != nil {
+ t.Fatal(err)
+ }
+ want := strValue(insts)
+
+ b, err := r.Marshal(insts...)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ r2 := &Runtime{}
+ insts, err = r2.Unmarshal(b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ got := strValue(insts)
+
+ if !cmp.Equal(got, want) {
+ t.Error(cmp.Diff(got, want))
+ }
+ })
+ }
+}
diff --git a/internal/legacy/cue/op.go b/internal/legacy/cue/op.go
new file mode 100644
index 0000000..b313289
--- /dev/null
+++ b/internal/legacy/cue/op.go
@@ -0,0 +1,219 @@
+// 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 cue
+
+import (
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal/core/adt"
+)
+
+// Op indicates the operation at the top of an expression tree of the expression
+// use to evaluate a value.
+type Op = adt.Op
+
+// Values of Op.
+const (
+ NoOp = adt.NoOp
+
+ AndOp = adt.AndOp
+ OrOp = adt.OrOp
+
+ SelectorOp = adt.SelectorOp
+ IndexOp = adt.IndexOp
+ SliceOp = adt.SliceOp
+ CallOp = adt.CallOp
+
+ BooleanAndOp = adt.BoolAndOp
+ BooleanOrOp = adt.BoolOrOp
+
+ EqualOp = adt.EqualOp
+ NotOp = adt.NotOp
+ NotEqualOp = adt.NotEqualOp
+ LessThanOp = adt.LessThanOp
+ LessThanEqualOp = adt.LessEqualOp
+ GreaterThanOp = adt.GreaterThanOp
+ GreaterThanEqualOp = adt.GreaterEqualOp
+
+ RegexMatchOp = adt.MatchOp
+ NotRegexMatchOp = adt.NotMatchOp
+
+ AddOp = adt.AddOp
+ SubtractOp = adt.SubtractOp
+ MultiplyOp = adt.MultiplyOp
+ FloatQuotientOp = adt.FloatQuotientOp
+ IntQuotientOp = adt.IntQuotientOp
+ IntRemainderOp = adt.IntRemainderOp
+ IntDivideOp = adt.IntDivideOp
+ IntModuloOp = adt.IntModuloOp
+
+ InterpolationOp = adt.InterpolationOp
+)
+
+var opToOp = map[op]Op{
+ opUnify: AndOp,
+ // TODO(eval): opUnifyUnchecked is not the same as opUnify and should have its own
+ // category, if needed. More likely opUnifyUnchecked, should be
+ // represented as a separate embedding method.
+ opUnifyUnchecked: AndOp,
+ opDisjunction: OrOp,
+ opLand: BooleanAndOp,
+ opLor: BooleanOrOp,
+ opEql: EqualOp,
+ opNot: NotOp,
+ opNeq: NotEqualOp,
+ opLss: LessThanOp,
+ opLeq: LessThanEqualOp,
+ opGtr: GreaterThanOp,
+ opGeq: GreaterThanEqualOp,
+ opMat: RegexMatchOp,
+ opNMat: NotRegexMatchOp,
+ opAdd: AddOp,
+ opSub: SubtractOp,
+ opMul: MultiplyOp,
+ opQuo: FloatQuotientOp,
+ opIQuo: IntQuotientOp,
+ opIRem: IntRemainderOp,
+ opIDiv: IntDivideOp,
+ opIMod: IntModuloOp,
+}
+
+func opIn(op op, anyOf ...op) bool {
+ for _, o := range anyOf {
+ if o == op {
+ return true
+ }
+ }
+ return false
+}
+
+// isCmp reports whether an op is a comparator.
+func (op op) isCmp() bool {
+ return opEql <= op && op <= opGeq
+}
+
+func (op op) unifyType() (unchecked, ok bool) {
+ if op == opUnifyUnchecked {
+ return true, true
+ }
+ return false, op == opUnify
+}
+
+type op uint16
+
+const (
+ opUnknown op = iota
+
+ opUnify
+ opUnifyUnchecked
+ opDisjunction
+
+ opLand
+ opLor
+ opNot
+
+ opEql
+ opNeq
+ opMat
+ opNMat
+
+ opLss
+ opGtr
+ opLeq
+ opGeq
+
+ opAdd
+ opSub
+ opMul
+ opQuo
+ opRem
+
+ opIDiv
+ opIMod
+ opIQuo
+ opIRem
+)
+
+var opStrings = []string{
+ opUnknown: "??",
+
+ opUnify: "&",
+ // opUnifyUnchecked is internal only. Syntactically this is
+ // represented as embedding.
+ opUnifyUnchecked: "&!",
+ opDisjunction: "|",
+
+ opLand: "&&",
+ opLor: "||",
+ opNot: "!",
+
+ opEql: "==",
+ opNeq: "!=",
+ opMat: "=~",
+ opNMat: "!~",
+
+ opLss: "<",
+ opGtr: ">",
+ opLeq: "<=",
+ opGeq: ">=",
+
+ opAdd: "+",
+ opSub: "-",
+ opMul: "*",
+ opQuo: "/",
+
+ opIDiv: "div",
+ opIMod: "mod",
+ opIQuo: "quo",
+ opIRem: "rem",
+}
+
+func (op op) String() string { return opStrings[op] }
+
+var tokenMap = map[token.Token]op{
+ token.OR: opDisjunction, // |
+ token.AND: opUnify, // &
+
+ token.ADD: opAdd, // +
+ token.SUB: opSub, // -
+ token.MUL: opMul, // *
+ token.QUO: opQuo, // /
+
+ token.IDIV: opIDiv, // div
+ token.IMOD: opIMod, // mod
+ token.IQUO: opIQuo, // quo
+ token.IREM: opIRem, // rem
+
+ token.LAND: opLand, // &&
+ token.LOR: opLor, // ||
+
+ token.EQL: opEql, // ==
+ token.LSS: opLss, // <
+ token.GTR: opGtr, // >
+ token.NOT: opNot, // !
+
+ token.NEQ: opNeq, // !=
+ token.LEQ: opLeq, // <=
+ token.GEQ: opGeq, // >=
+ token.MAT: opMat, // =~
+ token.NMAT: opNMat, // !~
+}
+
+var opMap = map[op]token.Token{}
+
+func init() {
+ for t, o := range tokenMap {
+ opMap[o] = t
+ }
+}
diff --git a/internal/legacy/cue/resolve_test.go b/internal/legacy/cue/resolve_test.go
new file mode 100644
index 0000000..e7480da
--- /dev/null
+++ b/internal/legacy/cue/resolve_test.go
@@ -0,0 +1,3052 @@
+// 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 cue
+
+import (
+ "flag"
+ "strings"
+ "testing"
+)
+
+var traceOn = flag.Bool("debug", false, "enable tracing")
+
+func compileFileWithErrors(t *testing.T, body string) (*context, *structLit, error) {
+ t.Helper()
+ ctx, inst, err := compileInstance(t, body)
+ return ctx, inst.rootValue.evalPartial(ctx).(*structLit), err
+}
+
+func compileFile(t *testing.T, body string) (*context, *structLit) {
+ t.Helper()
+ ctx, inst, errs := compileInstance(t, body)
+ if errs != nil {
+ t.Fatal(errs)
+ }
+ return ctx, inst.rootValue.evalPartial(ctx).(*structLit)
+}
+
+func compileInstance(t *testing.T, body string) (*context, *Instance, error) {
+ var r Runtime
+ inst, err := r.Compile("test", body)
+
+ if err != nil {
+ x := newInstance(newIndex(sharedIndex), nil)
+ ctx := x.newContext()
+ return ctx, x, err
+ }
+
+ return r.index().newContext(), inst, nil
+}
+
+func rewriteHelper(t *testing.T, cases []testCase, r rewriteMode) {
+ for _, tc := range cases {
+ t.Run(tc.desc, func(t *testing.T) {
+ ctx, obj := compileFile(t, tc.in)
+ ctx.trace = *traceOn
+ root := testResolve(ctx, obj, r)
+
+ got := debugStr(ctx, root)
+
+ // Copy the result
+ if got != tc.out {
+ fn := t.Errorf
+ if tc.skip {
+ fn = t.Skipf
+ }
+ fn("output differs:\ngot %s\nwant %s", got, tc.out)
+ }
+ })
+ }
+}
+
+type testCase struct {
+ desc string
+ in string
+ out string
+ skip bool
+}
+
+func TestBasicRewrite(t *testing.T) {
+ testCases := []testCase{{
+ desc: "errors",
+ in: `
+ a: _|_ & _|_
+ b: null & _|_
+ c: b.a == _|_
+ d: _|_ != b.a
+ e: _|_ == _|_
+ `,
+ out: `<0>{a: _|_(from source), b: _|_(from source), c: true, d: false, e: true}`,
+ }, {
+ desc: "regexp",
+ in: `
+ c1: "a" =~ "a"
+ c2: "foo" =~ "[a-z]{3}"
+ c3: "foo" =~ "[a-z]{4}"
+ c4: "foo" !~ "[a-z]{4}"
+
+ b1: =~ "a"
+ b1: "a"
+ b2: =~ "[a-z]{3}"
+ b2: "foo"
+ b3: =~ "[a-z]{4}"
+ b3: "foo"
+ b4: !~ "[a-z]{4}"
+ b4: "foo"
+
+ s1: != "b" & =~"c" // =~"c"
+ s2: != "b" & =~"[a-z]" // != "b" & =~"[a-z]"
+
+ e1: "foo" =~ 1
+ e2: "foo" !~ true
+ e3: != "a" & <5
+ `,
+ out: `<0>{c1: true, ` +
+ `c2: true, ` +
+ `c3: false, ` +
+ `c4: true, ` +
+
+ `b1: "a", ` +
+ `b2: "foo", ` +
+ `b3: _|_((=~"[a-z]{4}" & "foo"):invalid value "foo" (does not match =~"[a-z]{4}")), ` +
+ `b4: "foo", ` +
+
+ `s1: =~"c", ` +
+ `s2: (!="b" & =~"[a-z]"), ` +
+
+ `e1: _|_(("foo" =~ 1):invalid operation "foo" =~ 1 (mismatched types string and int)), ` +
+ `e2: _|_(("foo" !~ true):invalid operation "foo" !~ true (mismatched types string and bool)), ` +
+ `e3: _|_((!="a" & <5):conflicting values !="a" and <5 (mismatched types string and number))}`,
+ }, {
+ desc: "arithmetic",
+ in: `
+ i1: 1 & int
+ i2: 2 & int
+
+ sum: -1 + +2 // 1
+ div1: 2.0 / 3 * 6 // 4
+ div2: 2 / 3 * 6 // 4
+ div3: 1.00 / 1.00
+ divZero: 1.0 / 0
+ div00: 0 / 0
+ b: 1 != 4
+ add: div1 + 1.0
+
+ idiv00: 0 div 0
+ imod00: 0 mod 0
+ iquo00: 0 quo 0
+ irem00: 0 rem 0
+
+ v1: 1.0T/2.0
+ v2: 2.0 == 2
+ v3: 2.0/3.0
+ v5: i1 div i2
+
+ e0: 2 + "a"
+ // these are now all alloweed
+ // e1: 2.0 / i1
+ // e2: i1 / 2.0
+ // e3: 3.0 % i2
+ // e4: i1 % 2.0
+ e5: 1.0 div 2
+ e6: 2 rem 2.0
+ e7: 2 quo 2.0
+ e8: 1.0 mod 1
+ `,
+ out: `<0>{i1: 1, i2: 2, ` +
+ `sum: 1, ` +
+ `div1: 4.00000000000000000000000, ` +
+ `div2: 4.00000000000000000000000, ` +
+ `div3: 1., ` +
+ `divZero: _|_((1.0 / 0):division by zero), ` +
+ `div00: _|_((0 / 0):division undefined), ` +
+ `b: true, ` +
+ `add: 5.00000000000000000000000, ` +
+ `idiv00: _|_((0 div 0):division by zero), ` +
+ `imod00: _|_((0 mod 0):division by zero), ` +
+ `iquo00: _|_((0 quo 0):division by zero), ` +
+ `irem00: _|_((0 rem 0):division by zero), ` +
+ `v1: 5.0000000000e+11, ` +
+ `v2: true, ` +
+ `v3: 0.666666666666666666666667, ` +
+ `v5: 0, ` +
+
+ `e0: _|_((2 + "a"):invalid operation 2 + "a" (mismatched types int and string)), ` +
+ // `e1: _|_((2.0 / 1):unsupported op /(float, int)), ` +
+ // `e2: _|_((1 / 2.0):unsupported op /(int, float)), ` +
+ // `e3: _|_((3.0 % 2):unsupported op %(float, int)), ` +
+ // `e4: _|_((1 % 2.0):unsupported op %(int, float)), ` +
+ `e5: _|_((1.0 div 2):invalid operation 1.0 div 2 (mismatched types float and int)), ` +
+ `e6: _|_((2 rem 2.0):invalid operation 2 rem 2.0 (mismatched types int and float)), ` +
+ `e7: _|_((2 quo 2.0):invalid operation 2 quo 2.0 (mismatched types int and float)), ` +
+ `e8: _|_((1.0 mod 1):invalid operation 1.0 mod 1 (mismatched types float and int))}`,
+ }, {
+ desc: "integer-specific arithmetic",
+ in: `
+ q1: 5 quo 2 // 2
+ q2: 5 quo -2 // -2
+ q3: -5 quo 2 // -2
+ q4: -5 quo -2 // 2
+ qe1: 2.0 quo 1
+ qe2: 2 quo 1.0
+
+ r1: 5 rem 2 // 1
+ r2: 5 rem -2 // 1
+ r3: -5 rem 2 // -1
+ r4: -5 rem -2 // -1
+ re1: 2.0 rem 1
+ re2: 2 rem 1.0
+
+ d1: 5 div 2 // 2
+ d2: 5 div -2 // -2
+ d3: -5 div 2 // -3
+ d4: -5 div -2 // 3
+ de1: 2.0 div 1
+ de2: 2 div 1.0
+
+ m1: 5 mod 2 // 1
+ m2: 5 mod -2 // 1
+ m3: -5 mod 2 // 1
+ m4: -5 mod -2 // 1
+ me1: 2.0 mod 1
+ me2: 2 mod 1.0
+ `,
+ out: `<0>{q1: 2, q2: -2, q3: -2, q4: 2, ` +
+ `qe1: _|_((2.0 quo 1):invalid operation 2.0 quo 1 (mismatched types float and int)), ` +
+ `qe2: _|_((2 quo 1.0):invalid operation 2 quo 1.0 (mismatched types int and float)), ` +
+ `r1: 1, r2: 1, r3: -1, r4: -1, ` +
+ `re1: _|_((2.0 rem 1):invalid operation 2.0 rem 1 (mismatched types float and int)), ` +
+ `re2: _|_((2 rem 1.0):invalid operation 2 rem 1.0 (mismatched types int and float)), ` +
+ `d1: 2, d2: -2, d3: -3, d4: 3, ` +
+ `de1: _|_((2.0 div 1):invalid operation 2.0 div 1 (mismatched types float and int)), ` +
+ `de2: _|_((2 div 1.0):invalid operation 2 div 1.0 (mismatched types int and float)), ` +
+ `m1: 1, m2: 1, m3: 1, m4: 1, ` +
+ `me1: _|_((2.0 mod 1):invalid operation 2.0 mod 1 (mismatched types float and int)), ` +
+ `me2: _|_((2 mod 1.0):invalid operation 2 mod 1.0 (mismatched types int and float))}`,
+ }, {
+ desc: "booleans",
+ in: `
+ t: true
+ t: !false
+ f: false
+ f: !t
+ e: true
+ e: !true
+ `,
+ out: "<0>{t: true, f: false, e: _|_(true:conflicting values true and false)}",
+ }, {
+ desc: "boolean arithmetic",
+ in: `
+ a: true && true
+ b: true || false
+ c: false == true
+ d: false != true
+ e: true & true
+ f: true & false
+ `,
+ out: "<0>{a: true, b: true, c: false, d: true, e: true, f: _|_(true:conflicting values true and false)}",
+ }, {
+ desc: "basic type",
+ in: `
+ a: 1 & int
+ b: number & 1
+ c: 1.0
+ c: float
+ d: int & float // _|_
+ e: "4" & string
+ f: true
+ f: bool
+ `,
+ out: `<0>{a: 1, b: 1, c: 1.0, d: _|_((int & float):conflicting values int and float (mismatched types int and float)), e: "4", f: true}`, // TODO: eliminate redundancy
+ }, {
+ desc: "strings and bytes",
+ in: `
+ s0: "foo" + "bar"
+ s1: 3 * "abc"
+ s2: "abc" * 2
+
+ b0: 'foo' + 'bar'
+ b1: 3 * 'abc'
+ b2: 'abc' * 2
+
+ // TODO: consider the semantics of this and perhaps allow this.
+ e0: "a" + ''
+ e1: 'b' + "c"
+ `,
+ out: `<0>{` +
+ `s0: "foobar", ` +
+ `s1: "abcabcabc", ` +
+ `s2: "abcabc", ` +
+ `b0: 'foobar', ` +
+ `b1: 'abcabcabc', ` +
+ `b2: 'abcabc', ` +
+
+ `e0: _|_(("a" + ''):invalid operation "a" + '' (mismatched types string and bytes)), ` +
+ `e1: _|_(('b' + "c"):invalid operation 'b' + "c" (mismatched types bytes and string))` +
+ `}`,
+ }, {
+ desc: "escaping",
+
+ in: `
+ a: "foo\nbar",
+ b: a,
+
+ // TODO: mimic http://exploringjs.com/es6/ch_template-literals.html#sec_introduction-template-literals
+ `,
+ out: `<0>{a: "foo\nbar", b: "foo\nbar"}`,
+ // out: `<0>{a: "foo\nbar", b: <0>.a}`,
+ }, {
+ desc: "reference",
+ in: `
+ a: b
+ b: 2
+ d: {
+ d: 3
+ e: d
+ }
+ e: {
+ e: {
+ v: 1
+ }
+ f: {
+ v: e.v
+ }
+ }
+ `,
+ out: "<0>{a: 2, b: 2, d: <1>{d: 3, e: 3}, e: <2>{e: <3>{v: 1}, f: <4>{v: 1}}}",
+ }, {
+ desc: "lists",
+ in: `
+ list: [1,2,3]
+ index: [1,2,3][1]
+ unify: [1,2,3] & [_,2,3]
+ e: [] & 4
+ e2: [3]["d"]
+ e3: [3][-1]
+ e4: [1, 2, ...>=4 & <=5] & [1, 2, 4, 8]
+ e5: [1, 2, 4, 8] & [1, 2, ...>=4 & <=5]
+ `,
+ out: `<0>{list: [1,2,3], index: 2, unify: [1,2,3], e: _|_(([] & 4):conflicting values [] and 4 (mismatched types list and int)), e2: _|_("d":invalid list index "d" (type string)), e3: _|_(-1:invalid list index -1 (index must be non-negative)), e4: [1,2,4,_|_((<=5 & 8):invalid value 8 (out of bound <=5))], e5: [1,2,4,_|_((<=5 & 8):invalid value 8 (out of bound <=5))]}`,
+ }, {
+ desc: "list arithmetic",
+ in: `
+ list: [1,2,3]
+ mul0: list*0
+ mul1: list*1
+ mul2: 2*list
+ list1: [1]
+ mul1_0: list1*0
+ mul1_1: 1*list1
+ mul1_2: list1*2
+ e: list*-1
+ `,
+ out: `<0>{list: [1,2,3], ` +
+ `mul0: [], ` +
+ `mul1: [1,2,3], ` +
+ `mul2: [1,2,3,1,2,3], ` +
+ `list1: [1], ` +
+ `mul1_0: [], ` +
+ `mul1_1: [1], ` +
+ `mul1_2: [1,1], ` +
+ `e: _|_((<1>.list * -1):negative number -1 multiplies list)}`,
+ }, {
+ desc: "selecting",
+ in: `
+ obj: {a: 1, b: 2}
+ index: {a: 1, b: 2}["b"]
+ mulidx: {a: 1, b: {a:1, b: 3}}["b"]["b"]
+ e: {a: 1}[4]
+ f: {a: 1}.b
+ g: {a: 1}["b"]
+ h: [3].b
+ `,
+ out: `<0>{obj: <1>{a: 1, b: 2}, index: 2, mulidx: 3, e: _|_(4:invalid struct index 4 (type int)), f: <2>{a: 1}.b, g: <3>{a: 1}["b"], h: _|_([3]:invalid operation: [3].b (type list does not support selection))}`,
+ }, {
+ desc: "obj unify",
+ in: `
+ o1: {a: 1 } & { b: 2} // {a:1,b:2}
+ o2: {a: 1, b:2 } & { b: 2} // {a:1,b:2}
+ o3: {a: 1 } & { a:1, b: 2} // {a:1,b:2}
+ o4: {a: 1 } & { b: 2} // {a:1,b:2}
+ o4: {a: 1, b:2 } & { b: 2}
+ o4: {a: 1 } & { a:1, b: 2}
+ e: 1 // 1 & {a:3}
+ e: {a:3}
+ `,
+ out: "<0>{o1: <1>{a: 1, b: 2}, o2: <2>{a: 1, b: 2}, o3: <3>{a: 1, b: 2}, o4: <4>{a: 1, b: 2}, e: _|_((1 & <5>{a: 3}):conflicting values 1 and {a: 3} (mismatched types int and struct))}",
+ }, {
+ desc: "disjunctions",
+ in: `
+ o1: 1 | 2 | 3
+ o2: (1 | 2 | 3) & 1
+ o3: 2 & (1 | *2 | 3)
+ o4: (1 | *2 | 3) & (1 | 2 | *3)
+ o5: (1 | *2 | 3) & (3 | *2 | 1)
+ o6: (1 | 2 | 3) & (3 | 1 | 2)
+ o7: (1 | 2 | 3) & (2 | 3)
+ o8: (1 | 2 | 3) & (3 | 2)
+ o9: (2 | 3) & (1 | 2 | 3)
+ o10: (3 | 2) & (1 | *2 | 3)
+
+ m1: (*1 | (*2 | 3)) & (>=2 & <=3)
+ m2: (*1 | (*2 | 3)) & (2 | 3)
+ m3: (*1 | *(*2 | 3)) & (2 | 3)
+ m4: (2 | 3) & (*2 | 3)
+ m5: (*2 | 3) & (2 | 3)
+
+ // (*2 | 3) & (2 | 3)
+ // (2 | 3) & (*2 | 3)
+ // 2&(*2 | 3) | 3&(*2 | 3)
+ // (*1 | (*2 | 3)) & (2 | 3)
+ // *1& (2 | 3) | (*2 | 3)&(2 | 3)
+ // *2&(2 | 3) | 3&(2 | 3)
+
+ // (2 | 3)&(*1 | (*2 | 3))
+ // 2&(*1 | (*2 | 3)) | 3&(*1 | (*2 | 3))
+ // *1&2 | (*2 | 3)&2 | *1&3 | (*2 | 3)&3
+ // (*2 | 3)&2 | (*2 | 3)&3
+ // *2 | 3
+
+
+ // All errors are treated the same as per the unification model.
+ i1: [1, 2][3] | "c"
+ `,
+ out: `<0>{o1: (1 | 2 | 3), o2: 1, o3: 2, o4: (1 | 2 | 3 | *_|_), o5: (1 | *2 | 3), o6: (1 | 2 | 3), o7: (2 | 3), o8: (2 | 3), o9: (2 | 3), o10: (3 | *2), m1: (*2 | 3), m2: (*2 | 3), m3: (*2 | 3), m4: (*2 | 3), m5: (*2 | 3), i1: "c"}`,
+ }, {
+ desc: "types",
+ in: `
+ i: int
+ j: int & 3
+ s: string
+ t: "s" & string
+ e: int & string
+ e2: 1 & string
+ b: !int
+ p: +true
+ m: -false
+ `,
+ out: `<0>{i: int, j: 3, s: string, t: "s", e: _|_((int & string):conflicting values int and string (mismatched types int and string)), e2: _|_((1 & string):conflicting values 1 and string (mismatched types int and string)), b: _|_(!int:invalid operation !int (! int)), p: _|_(+true:invalid operation +true (+ bool)), m: _|_(-false:invalid operation -false (- bool))}`,
+ }, {
+ desc: "comparison",
+ in: `
+ lss: 1 < 2
+ leq: 1 <= 1.0
+ leq: 2.0 <= 3
+ eql: 1 == 1.0
+ neq: 1.0 == 1
+ gtr: !(2 > 3)
+ geq: 2.0 >= 2
+ seq: "a" + "b" == "ab"
+ err: 2 == "s"
+ `,
+ out: `<0>{lss: true, leq: true, eql: true, neq: true, gtr: true, geq: true, seq: true, err: _|_((2 == "s"):invalid operation 2 == "s" (mismatched types int and string))}`,
+ }, {
+ desc: "null",
+ in: `
+ eql: null == null
+ neq: null != null
+ unf: null & null
+
+ // errors
+ eq1: null == 1
+ eq2: 1 == null
+ ne1: "s" != null
+ call: null()
+ `,
+ out: `<0>{eql: true, neq: false, unf: null, eq1: false, eq2: false, ne1: true, call: _|_(null:cannot call non-function null (type null))}`,
+ }, {
+ desc: "self-reference cycles",
+ in: `
+ a: b - 100
+ b: a + 100
+
+ c: [c[1], c[0]]
+ `,
+ out: `<0>{a: (<1>.b - 100), ` +
+ `b: (<1>.a + 100), ` +
+ `c: [<1>.c[1],<1>.c[0]]}`,
+ }, {
+ desc: "resolved self-reference cycles",
+ in: `
+ a: b - 100
+ b: a + 100
+ b: 200
+
+ c: [c[1], a]
+
+ s1: s2 & {a: 1}
+ s2: s3 & {b: 2}
+ s3: s1 & {c: 3}
+ `,
+ out: `<0>{a: 100, b: 200, c: [100,100], s1: <1>{a: 1, b: 2, c: 3}, s2: <2>{a: 1, b: 2, c: 3}, s3: <3>{a: 1, b: 2, c: 3}}`,
+ }, {
+ desc: "resolved self-reference cycles: Issue 19",
+ in: `
+ // CUE knows how to resolve the following:
+ x: y + 100
+ y: x - 100
+ x: 200
+
+ z1: z2 + 1
+ z2: z3 + 2
+ z3: z1 - 3
+ z3: 8
+
+ // TODO: extensive tests with disjunctions.
+ `,
+ out: `<0>{x: 200, y: 100, z1: 11, z2: 10, z3: 8}`,
+ }, {
+ desc: "delayed constraint failure",
+ in: `
+ a: b - 100
+ b: a + 110
+ b: 200
+
+ x: 100
+ x: x + 1
+ `,
+ out: `<0>{` +
+ `x: _|_((100 & 101):conflicting values 100 and 101), ` +
+ `a: _|_((210 & 200):conflicting values 210 and 200), ` +
+ `b: _|_((210 & 200):conflicting values 210 and 200)}`,
+ // TODO: find a way to mark error in data.
+ }}
+ rewriteHelper(t, testCases, evalPartial)
+}
+
+func TestChooseDefault(t *testing.T) {
+ testCases := []testCase{{
+ desc: "pick first",
+ in: `
+ a: *5 | "a" | true
+ b: c: *{
+ a: 2
+ } | {
+ a : 3
+ }
+ `,
+ out: "<0>{a: 5, b: <1>{c: <2>{a: 2}}}",
+ }, {
+ // In this test, default results to bottom, meaning that the non-default
+ // value remains.
+ desc: "simple disambiguation conflict",
+ in: `
+ a: *"a" | "b"
+ b: *"b" | "a"
+ c: a & b
+ `,
+ out: `<0>{a: "a", b: "b", c: ("a" | "b")}`,
+ }, {
+ desc: "associativity of defaults",
+ in: `
+ a: *"a" | ("b" | "c")
+ b: (*"a" | "b") | "c"
+ c: *"a" | (*"b" | "c")
+ x: a & b
+ y: b & c
+ `,
+ out: `<0>{x: "a", y: (*"a" | *"b"), a: "a", b: "a", c: (*"a" | *"b")}`,
+ }}
+ rewriteHelper(t, testCases, evalFull)
+}
+
+func TestResolve(t *testing.T) {
+ testCases := []testCase{{
+ desc: "convert _ to top",
+ in: `a: { [_]: _ }`,
+ out: `<0>{a: <1>{...}}`,
+ }, {
+ in: `
+ a: b.c.d
+ b: c: { d: 3 }
+ c: { c: d.d, }
+ d: { d: 2 }
+ `,
+ out: "<0>{a: 3, b: <1>{c: <2>{d: 3}}, c: <3>{c: 2}, d: <4>{d: 2}}",
+ }, {
+ in: "`foo-bar`: 3\n x: `foo-bar`,",
+ out: `<0>{x: 3, "foo-bar": 3}`,
+ }, {
+ desc: "resolution of quoted identifiers",
+ in: `
+ package foo
+
+` + "`foo-bar`" + `: 2
+"baz": ` + "`foo-bar`" + `
+
+a: {
+ qux: 3
+ ` + "`qux-quux`" + `: qux
+ "qaz": ` + "`qux-quux`" + `
+}`,
+ out: `<0>{"foo-bar": 2, baz: 2, a: <1>{qux: 3, "qux-quux": 3, qaz: 3}}`,
+ }, {
+ in: `
+ a: _
+ b: a
+ a: { d: 1, d: _ }
+ b: _
+ `,
+ out: `<0>{a: <1>{d: 1}, b: <2>{d: 1}}`,
+ }, {
+ desc: "JSON",
+ in: `
+ a="a": 3
+ b: a
+ o: { "a\nb": 2 } // TODO: use $ for root?
+ c: o["a\nb"]
+ `,
+ out: `<0>{a: 3, b: 3, o: <1>{"a\nb": 2}, c: 2}`,
+ }, {
+ desc: "arithmetic",
+ in: `
+ v1: 1.0T/2.0
+ v2: 2.0 == 2
+ n1: 1
+ v5: 2.0 / n1
+ v6: 1.0 / 1.0
+ e2: int & 4.0/2.0
+ `,
+ out: `<0>{v1: 5.0000000000e+11, v2: true, n1: 1, v5: 2.0, v6: 1., e2: _|_((int & (4.0 / 2.0)):conflicting values int and (4.0 / 2.0) (mismatched types int and float))}`,
+ }, {
+ desc: "inequality",
+ in: `
+ a: 1 != 2
+ b: 1 != null
+ c: true == null
+ d: null != {}
+ e: null == []
+ f: 0 == 0.0 // types are unified first TODO: make this consistent
+ `,
+ out: `<0>{a: true, b: true, c: false, d: true, e: false, f: true}`,
+ }, {
+ desc: "attributes",
+ in: `
+ a: { foo: 1 @foo() @baz(1) }
+ b: { foo: 1 @bar() @foo() }
+ c: a & b
+
+ e: a & { foo: 1 @foo(other) }
+ `,
+ out: `<0>{a: <1>{foo: 1 @baz(1) @foo()}, ` +
+ `b: <2>{foo: 1 @bar() @foo()}, ` +
+ `c: <3>{foo: 1 @bar() @baz(1) @foo()}, ` +
+ `e: _|_((<4>.a & <5>{foo: 1 @foo(other)}):conflicting attributes for key "foo")}`,
+ }, {
+ desc: "optional field unification",
+ in: `
+ a: { foo?: string }
+ b: { foo: "foo" }
+ c: a & b
+ d: a & { "foo"?: "bar" }
+
+ g1: 1
+ "g\(1)"?: 1
+ "g\(2)"?: 2
+ `,
+ out: `<0>{a: <1>{foo?: string}, ` +
+ `b: <2>{foo: "foo"}, ` +
+ `c: <3>{foo: "foo"}, ` +
+ `d: <4>{foo?: "bar"}, ` +
+ `g1: 1, ` +
+ `g2?: 2}`,
+ }, {
+ desc: "optional field resolves to incomplete",
+ in: `
+ r: {
+ a?: 3
+ b: a
+ c: r["a"]
+ }
+ `,
+ out: `<0>{r: <1>{a?: 3, b: <2>.a, c: <3>.r["a"]}}`,
+ // TODO(#152): should be
+ // out: `<0>{r: <1>{a?: 3, b: <2>.a, c: <2>["a"]}}`,
+ }, {
+ desc: "bounds",
+ in: `
+ i1: >1 & 5
+ i2: (>=0 & <=10) & 5
+ i3: !=null & []
+ i4: !=2 & !=4
+
+
+ s1: >=0 & <=10 & !=1 // no simplification
+ s2: >=0 & <=10 & !=11 // >=0 & <=10
+ s3: >5 & !=5 // >5
+ s4: <10 & !=10 // <10
+ s5: !=2 & !=2
+
+ // TODO: could change inequality
+ s6: !=2 & >=2
+ s7: >=2 & !=2
+
+ s8: !=5 & >5
+
+ s10: >=0 & <=10 & <12 & >1 // >1 & <=10
+ s11: >0 & >=0 & <=12 & <12 // >0 & <12
+
+ s20: >=10 & <=10 // 10
+
+ s22: >5 & <=6 // no simplification
+ s22a: >5 & (<=6 & int) // 6
+ s22b: (int & >5) & <=6 // 6
+ s22c: >=5 & (<6 & int) // 5
+ s22d: (int & >=5) & <6 // 5
+ s22e: (>=5 & <6) & int // 5
+ s22f: int & (>=5 & <6) // 5
+
+ s23: >0 & <2 // no simplification
+ s23a: (>0 & <2) & int // int & 1
+ s23b: int & (>0 & <2) // int & 1
+ s23c: (int & >0) & <2 // int & 1
+ s23d: >0 & (int & <2) // int & 1
+ s23e: >0.0 & <2.0 // no simplification
+
+ s30: >0 & int
+
+ e1: null & !=null
+ e2: !=null & null
+ e3: >1 & 1
+ e4: <0 & 0
+ e5: >1 & <0
+ e6: >11 & <11
+ e7: >=11 & <11
+ e8: >11 & <=11
+ e9: >"a" & <1
+ `,
+ out: `<0>{i1: 5, i2: 5, i3: [], i4: (!=2 & !=4), ` +
+
+ `s1: (>=0 & <=10 & !=1), ` +
+ `s2: (>=0 & <=10), ` +
+ `s3: >5, ` +
+ `s4: <10, ` +
+ `s5: !=2, ` +
+
+ `s6: (!=2 & >=2), ` +
+ `s7: (>=2 & !=2), ` +
+
+ `s8: >5, ` +
+
+ `s10: (<=10 & >1), ` +
+ `s11: (>0 & <12), ` +
+
+ `s20: 10, ` +
+
+ `s22: (>5 & <=6), ` +
+ `s22a: 6, ` +
+ `s22b: 6, ` +
+ `s22c: 5, ` +
+ `s22d: 5, ` +
+ `s22e: 5, ` +
+ `s22f: 5, ` +
+
+ `s23: (>0 & <2), ` +
+ `s23a: 1, ` +
+ `s23b: 1, ` +
+ `s23c: 1, ` +
+ `s23d: 1, ` +
+ `s23e: (>0.0 & <2.0), ` +
+
+ `s30: int & >0, ` +
+
+ `e1: _|_((!=null & null):invalid value null (excluded by !=null)), ` +
+ `e2: _|_((!=null & null):invalid value null (excluded by !=null)), ` +
+ `e3: _|_((>1 & 1):invalid value 1 (out of bound >1)), ` +
+ `e4: _|_((<0 & 0):invalid value 0 (out of bound <0)), ` +
+ `e5: _|_(conflicting bounds >1 and <0), ` +
+ `e6: _|_(conflicting bounds >11 and <11), ` +
+ `e7: _|_(conflicting bounds >=11 and <11), ` +
+ `e8: _|_(conflicting bounds >11 and <=11), ` +
+ `e9: _|_((>"a" & <1):conflicting values >"a" and <1 (mismatched types string and number))}`,
+ }, {
+ desc: "bound conversions",
+ in: `
+ r0: int & >0.1 & <=1.9
+ r1: int & >0.1 & <1.9
+ r2: int & >=0.1 & <1.9
+ r3: int & >=-1.9 & <=-0.1
+ r4: int & >-1.9 & <=-0.1
+
+ r5: >=1.1 & <=1.1
+ r6: r5 & 1.1
+
+ c1: (1.2 & >1.3) & <2
+ c2: 1.2 & (>1.3 & <2)
+
+ c3: 1.2 & (>=1 & <2)
+ c4: 1.2 & (>=1 & <2 & int)
+ `,
+ out: `<0>{` +
+ `r0: 1, ` +
+ `r1: 1, ` +
+ `r2: 1, ` +
+ `r3: -1, ` +
+ `r4: -1, ` +
+ `r5: 1.1, ` +
+ `r6: 1.1, ` +
+ `c1: _|_((>1.3 & 1.2):invalid value 1.2 (out of bound >1.3)), ` +
+ `c2: _|_((>1.3 & 1.2):invalid value 1.2 (out of bound >1.3)), ` +
+ `c3: 1.2, ` +
+ `c4: _|_((1.2 & ((>=1 & <2) & int)):conflicting values 1.2 and ((>=1 & <2) & int) (mismatched types float and int))}`,
+ }, {
+ desc: "custom validators",
+ in: `
+ import "strings"
+
+ a: strings.ContainsAny("ab")
+ a: "after"
+
+ b: strings.ContainsAny("c")
+ b: "dog"
+
+ c: strings.ContainsAny("d") & strings.ContainsAny("g")
+ c: "dog"
+ `,
+ out: `<0>{` +
+ `a: "after", ` +
+ `b: _|_(strings.ContainsAny ("c"):invalid value "dog" (does not satisfy strings.ContainsAny("c"))), ` +
+ `c: "dog"` +
+ `}`,
+ }, {
+ desc: "null coalescing",
+ in: `
+ a: null
+ b: a.x | "b"
+ c: a["x"] | "c"
+ `,
+ out: `<0>{a: null, b: "b", c: "c"}`,
+ }, {
+ desc: "reference across tuples and back",
+ // Tests that it is okay to partially evaluate structs.
+ in: `
+ a: { c: b.e, d: b.f }
+ b: { e: 3, f: a.c }
+ `,
+ out: "<0>{a: <1>{c: 3, d: 3}, b: <2>{e: 3, f: 3}}",
+ }, {
+ desc: "index",
+ in: `
+ a: [2][0]
+ b: {foo:"bar"}["foo"]
+ c: (*l|{"3":3})["3"]
+ d: (*[]|[1])[0]
+ l: []
+ e1: [2][""]
+ e2: 2[2]
+ e3: [][true]
+ e4: [1,2,3][3]
+ e5: [1,2,3][-1]
+ e6: (*[]|{})[1]
+ def: {
+ a: 1
+ #b: 3
+ }
+ e7: def["b"]
+ `,
+ out: `<0>{a: 2, b: "bar", c: _|_("3":invalid list index "3" (type string)), l: [], d: _|_([]:index 0 out of bounds), e1: _|_("":invalid list index "" (type string)), e2: _|_(2:invalid operation: 2[2] (type int does not support indexing)), e3: _|_(true:invalid list index true (type bool)), e4: _|_([1,2,3]:index 3 out of bounds), e5: _|_(-1:invalid list index -1 (index must be non-negative)), e6: _|_([]:index 1 out of bounds), def: <1>{a: 1, #b: 3}, e7: <2>.def["b"]}`,
+ // }, {
+ // NOTE: string indexing no longer supported.
+ // Keeping it around until this is no longer an experiment.
+ // desc: "string index",
+ // in: `
+ // a0: "abc"[0]
+ // a1: "abc"[1]
+ // a2: "abc"[2]
+ // a3: "abc"[3]
+ // a4: "abc"[-1]
+
+ // b: "zoëven"[2]
+ // `,
+ // out: `<0>{a0: "a", a1: "b", a2: "c", a3: _|_("abc":index 3 out of bounds), a4: _|_(-1:invalid string index -1 (index must be non-negative)), b: "ë"}`,
+ }, {
+ desc: "disjunctions of lists",
+ in: `
+ l: [ int, int ] | [ string, string ]
+
+ l1: [ "a", "b" ]
+ l2: l & [ "c", "d" ]
+ `,
+ out: `<0>{l: ([int,int] | [string,string]), l1: ["a","b"], l2: ["c","d"]}`,
+ }, {
+ desc: "slice",
+ in: `
+ a: [2][0:0]
+ b: [0][1:1]
+ e1: [][1:1]
+ e2: [0][-1:0]
+ e3: [0][1:0]
+ e4: [0][1:2]
+ e5: 4[1:2]
+ e6: [2]["":]
+ e7: [2][:"9"]
+
+ `,
+ out: `<0>{a: [], b: [], e1: _|_(1:slice bounds out of range), e2: _|_([0]:negative slice index), e3: _|_([0]:invalid slice index: 1 > 0), e4: _|_(2:slice bounds out of range), e5: _|_(4:cannot slice 4 (type int)), e6: _|_("":invalid slice index "" (type string)), e7: _|_("9":invalid slice index "9" (type string))}`,
+ // }, {
+ // NOTE: string indexing no longer supported.
+ // Keeping it around until this is no longer an experiment.
+ // desc: "string slice",
+ // in: `
+ // a0: ""[0:0]
+ // a1: ""[:]
+ // a2: ""[0:]
+ // a3: ""[:0]
+ // b0: "abc"[0:0]
+ // b1: "abc"[0:1]
+ // b2: "abc"[0:2]
+ // b3: "abc"[0:3]
+ // b4: "abc"[3:3]
+ // b5: "abc"[1:]
+ // b6: "abc"[:2]
+
+ // // TODO: supported extended graphemes, instead of just runes.
+ // u: "Spaß"[3:4]
+ // `,
+ // out: `<0>{a0: "", a1: "", a2: "", a3: "", b0: "", b1: "a", b2: "ab", b3: "abc", b4: "", b5: "bc", b6: "ab", u: "ß"}`,
+ }, {
+ desc: "list types",
+ in: `
+ l0: 3*[int]
+ l0: [1, 2, 3]
+ l2: [...{ a: int }]
+ l2: [{a: 1}, {a: 2, b: 3}]
+
+ // TODO: work out a decent way to specify length ranges of lists.
+ // l3: <=10*[int]
+ // l3: [1, 2, 3, ...]
+
+ s1: (6*[int])[2:3]
+ s2: [0,2,3][1:2]
+
+ i1: (6*[int])[2]
+ i2: [0,2,3][2]
+
+ t0: [...{a: 8}]
+ t0: [{}]
+ t1: [...]
+ t1: [...int]
+
+ e0: 2*[{}]
+ e0: [{}]
+ e1: [...int]
+ e1: [...float]
+ `,
+ out: `<0>{` +
+ `l0: [1,2,3], ` +
+ `l2: [<1>{a: 1},<2>{a: 2, b: 3}], ` +
+ `s1: [int], ` +
+ `s2: [2], ` +
+ `i1: int, ` +
+ `i2: 3, ` +
+ `t0: [<3>{a: 8}], ` +
+ `t1: [, ...int], ` +
+ `e0: _|_(([<4>{},<4>{}] & [<5>{}]):conflicting list lengths: conflicting values 2 and 1), ` +
+ `e1: [, ..._|_((int & float):conflicting values int and float (mismatched types int and float))]` +
+ `}`,
+ }, {
+ // TODO: consider removing list arithmetic altogether. It is no longer
+ // needed to indicate the allowed capacity of a list and that didn't
+ // work anyway.
+ desc: "list arithmetic",
+ in: `
+ l0: 3*[1, 2, 3]
+ l1: 0*[1, 2, 3]
+ l2: 10*[]
+ l3: <=2*[]
+ l4: <=2*[int]
+ l5: <=2*(int*[int])
+ l6: 3*[...int]
+ l7: 3*[1, ...int]
+ l8: 3*[1, 2, ...int]
+
+ s0: [] + []
+ s1: [1] + []
+ s2: [] + [2]
+ s3: [1] + [2]
+ s4: [1,2] + []
+ s5: [] + [1,2]
+ s6: [1] + [1,2]
+ s7: [1,2] + [1]
+ s8: [1,2] + [1,2]
+ s9: [] + [...]
+ s10: [1] + [...]
+ s11: [] + [2, ...]
+ s12: [1] + [2, ...]
+ s13: [1,2] + [...]
+ s14: [] + [1,2, ...]
+ s15: [1] + [1,2, ...]
+ s16: [1,2] + [1, ...]
+ s17: [1,2] + [1,2, ...]
+
+ s18: [...] + []
+ s19: [1, ...] + []
+ s20: [...] + [2]
+ s21: [1, ...] + [2]
+ s22: [1,2, ...] + []
+ s23: [...] + [1,2]
+ s24: [1, ...] + [1,2]
+ s25: [1,2, ...] + [1]
+ s26: [1,2, ...] + [1,2]
+ s27: [...] + [...]
+ s28: [1, ...] + [...]
+ s29: [...] + [2, ...]
+ s30: [1, ...] + [2, ...]
+ s31: [1,2, ...] + [...]
+ s32: [...] + [1,2, ...]
+ s33: [1, ...] + [1,2, ...]
+ s34: [1,2, ...] + [1, ...]
+ s35: [1,2, ...] + [1,2, ...]
+ `,
+ out: `<0>{l0: [1,2,3,1,2,3,1,2,3], ` +
+ `l1: [], ` +
+ `l2: [], ` +
+ `l3: (<=2 * []), ` +
+ `l4: (<=2 * [int]), ` +
+ `l5: (<=2 * (int * [int])), ` +
+ `l6: [], ` +
+ `l7: [1,1,1], ` +
+ `l8: [1,2,1,2,1,2], ` +
+
+ `s0: [], ` +
+ `s1: [1], ` +
+ `s2: [2], ` +
+ `s3: [1,2], ` +
+ `s4: [1,2], ` +
+ `s5: [1,2], ` +
+ `s6: [1,1,2], ` +
+ `s7: [1,2,1], ` +
+ `s8: [1,2,1,2], ` +
+ `s9: [], ` +
+ `s10: [1], ` +
+ `s11: [2], ` +
+ `s12: [1,2], ` +
+ `s13: [1,2], ` +
+ `s14: [1,2], ` +
+ `s15: [1,1,2], ` +
+ `s16: [1,2,1], ` +
+ `s17: [1,2,1,2], ` +
+
+ `s18: [], ` +
+ `s19: [1], ` +
+ `s20: [2], ` +
+ `s21: [1,2], ` +
+ `s22: [1,2], ` +
+ `s23: [1,2], ` +
+ `s24: [1,1,2], ` +
+ `s25: [1,2,1], ` +
+ `s26: [1,2,1,2], ` +
+ `s27: [], ` +
+ `s28: [1], ` +
+ `s29: [2], ` +
+ `s30: [1,2], ` +
+ `s31: [1,2], ` +
+ `s32: [1,2], ` +
+ `s33: [1,1,2], ` +
+ `s34: [1,2,1], ` +
+ `s35: [1,2,1,2]` +
+
+ `}`,
+ }, {
+ desc: "list equality",
+ in: `
+ eq0: [] == []
+ eq1: [...] == []
+ eq2: [] == [...]
+ eq3: [...] == [...]
+
+ eq4: [1] == [1]
+ eq5: [1, ...] == [1]
+ eq6: [1] == [1, ...]
+ eq7: [1, ...] == [1, ...]
+
+ eq8: [1, 2] == [1, 2]
+ eq9: [1, 2, ...] == [1, 2]
+ eq10: [1, 2] == [1, 2, ...]
+ eq11: [1, 2, ...] == [1, 2, ...]
+
+ ne0: [] != []
+ ne1: [...] != []
+ ne2: [] != [...]
+ ne3: [...] != [...]
+
+ ne4: [1] != [1]
+ ne5: [1, ...] != [1]
+ ne6: [1] != [1, ...]
+ ne7: [1, ...] != [1, ...]
+
+ ne8: [1, 2] != [1, 2]
+ ne9: [1, 2, ...] != [1, 2]
+ ne10: [1, 2] != [1, 2, ...]
+ ne11: [1, 2, ...] != [1, 2, ...]
+
+ feq0: [] == [1]
+ feq1: [...] == [1]
+ feq2: [] == [1, ...]
+ feq3: [...] == [1, ...]
+
+ feq4: [1] == []
+ feq5: [1, ...] == []
+ feq6: [1] == [...]
+ feq7: [1, ...] == [...]
+
+ feq8: [1, 2] == [1]
+ feq9: [1, ...] == [1, 2]
+ feq10: [1, 2] == [1, ...]
+ feq11: [1, ...] == [1, 2, ...]
+
+ fne0: [] != [1]
+ fne1: [...] != [1]
+ fne2: [] != [1, ...]
+ fne3: [1, ...] != [1, ...]
+
+ fne4: [1] != []
+ fne5: [1, ...] != []
+ fne6: [1] != [...]
+ fne7: [1, ...] != [...]
+
+ fne8: [1, 2] != [1]
+ fne9: [1, ...] != [1, 2]
+ fne10: [1, 2] != [1, ...]
+ fne11: [1, ...] != [1, 2, ...]
+ `,
+ out: `<0>{` +
+ `eq0: true, eq1: true, eq2: true, eq3: true, eq4: true, eq5: true, eq6: true, eq7: true, eq8: true, eq9: true, eq10: true, eq11: true, ` +
+ `ne0: true, ne1: true, ne2: true, ne3: true, ne4: false, ne5: false, ne6: false, ne7: false, ne8: false, ne9: false, ne10: false, ne11: false, ` +
+ `feq0: false, feq1: false, feq2: false, feq3: false, feq4: false, feq5: false, feq6: false, feq7: false, feq8: false, feq9: false, feq10: false, feq11: false, ` +
+ `fne0: false, fne1: false, fne2: false, fne3: false, fne4: false, fne5: false, fne6: false, fne7: false, fne8: false, fne9: false, fne10: false, fne11: false}`,
+ }, {
+ desc: "list unification",
+ in: `
+ a: { l: ["foo", v], v: l[1] }
+ b: a & { l: [_, "bar"] }
+ `,
+ out: `<0>{` +
+ `a: <1>{l: ["foo",<2>.v], ` +
+ `v: <2>.l[1]}, ` +
+ `b: <3>{l: ["foo","bar"], v: "bar"}}`,
+ }, {
+ desc: "correct error messages",
+ // Tests that it is okay to partially evaluate structs.
+ in: `
+ a: "a" & 1
+ `,
+ out: `<0>{a: _|_(("a" & 1):conflicting values "a" and 1 (mismatched types string and int))}`,
+ }, {
+ desc: "structs",
+ in: `
+ a: t & { c: 5 } // {c:5,d:15}
+ b: ti & { c: 7 } // {c:7,d:21}
+ t: { c: number, d: c * 3 } // {c:number,d:number*3}
+ ti: t & { c: int }
+ `,
+ out: `<0>{a: <1>{c: 5, d: 15}, t: <2>{c: number, d: (<3>.c * 3)}, b: <4>{c: 7, d: 21}, ti: <5>{c: int, d: (<6>.c * 3)}}`,
+ }, {
+ desc: "definitions",
+ in: `
+ #Foo: {
+ field: int
+ recursive: {
+ field: string
+ }
+ }
+
+ // Allowed
+ #Foo1: { field: int }
+ #Foo1: { field2: string }
+
+ foo: #Foo
+ foo: { feild: 2 }
+
+ foo1: #Foo
+ foo1: {
+ field: 2
+ recursive: {
+ feild: 2 // Not caught as per spec. TODO: change?
+ }
+ }
+
+ #Bar: {
+ field: int
+ {[A=_]: int}
+ }
+ bar: #Bar
+ bar: { feild: 2 }
+
+ #Mixed: string
+ Mixed: string
+
+ mixedRec: { #Mixed: string }
+ mixedRec: { Mixed: string }
+ `,
+ out: `<0>{` +
+ `#Foo: <1>C{field: int, recursive: <2>C{field: string}}, ` +
+ `#Foo1: <3>C{field: int, field2: string}, ` +
+ `foo: _|_(2:field "feild" not allowed in closed struct), ` +
+ `foo1: <4>C{field: 2, recursive: _|_(2:field "feild" not allowed in closed struct)}, ` +
+ `#Bar: <5>{[]: <6>(A: string)->int, field: int}, ` +
+ `bar: <7>{[]: <8>(A: string)->int, field: int, feild: 2}, ` +
+ `#Mixed: string, ` +
+ `Mixed: string, ` +
+ `mixedRec: <9>{#Mixed: string, Mixed: string}}`,
+ }, {
+ desc: "combined definitions",
+ in: `
+ // Allow combining of structs within a definition
+ #D1: {
+ env: a: "A"
+ env: b: "B"
+ #def: {a: "A"}
+ #def: {b: "B"}
+ }
+
+ d1: #D1 & { env: c: "C" }
+
+ #D2: {
+ a: int
+ }
+ #D2: {
+ b: int
+ }
+
+ #D3: {
+ env: a: "A"
+ }
+ #D3: {
+ env: b: "B"
+ }
+
+ #D4: {
+ env: #DC
+ env: b: int
+ }
+
+ #DC: { a: int }
+ `,
+ out: `<0>{` +
+ `#D1: <1>C{env: <2>C{a: "A", b: "B"}, #def: <3>C{a: "A", b: "B"}}, ` +
+ `d1: <4>C{env: _|_("C":field "c" not allowed in closed struct), #def: <5>C{a: "A", b: "B"}}, ` +
+ `#D2: <6>C{a: int, b: int}, ` +
+ `#D3: <7>C{env: <8>C{a: "A", b: "B"}}, ` +
+ `#D4: <9>C{env: _|_(int:field "b" not allowed in closed struct)}, ` +
+ `#DC: <10>C{a: int}` +
+ `}`,
+ }, {
+ desc: "new-style definitions",
+ in: `
+ #Foo: {
+ a: 1
+ b: int
+ }
+ "#Foo": #Foo & {b: 1}
+
+ bulk: {[string]: string} & {
+ #def: 4 // Different namespace, so bulk option does not apply.
+ _hid: 3
+ a: "foo"
+ }
+ `,
+ out: `<0>{` +
+ `"#Foo": <1>C{a: 1, b: 1}, ` +
+ `#Foo: <2>C{a: 1, b: int}, ` +
+ `bulk: <3>{[]: <4>(_: string)->string, a: "foo", #def: 4, _hid: 3}` +
+ `}`,
+ }, {
+ desc: "recursive closing starting at non-definition",
+ in: `
+ z: a: {
+ #B: {
+ c: d: 1
+ c: f: 1
+ }
+ }
+ A: z & { a: { #B: { c: e: 2 } } }
+ `,
+ out: `<0>{z: <1>{a: <2>{#B: <3>C{c: <4>C{d: 1, f: 1}}}}, A: <5>{a: <6>{#B: <7>C{c: _|_(2:field "e" not allowed in closed struct)}}}}`,
+ }, {
+ desc: "non-closed definition carries over closedness to enclosed template",
+ in: `
+ #S: {
+ [string]: { a: int }
+ }
+ a: #S & {
+ v: { b: int }
+ }
+ #Q: {
+ [string]: { a: int } | { b: int }
+ }
+ b: #Q & {
+ w: { c: int }
+ }
+ #R: {
+ [string]: [{ a: int }, { b: int }]
+ }
+ c: #R & {
+ w: [{ d: int }, ...]
+ }
+ `,
+ out: `<0>{` +
+ `#S: <1>{[]: <2>(_: string)-><3>C{a: int}, }, ` +
+ `a: <4>{[]: <5>(_: string)-><6>C{a: int}, v: _|_(int:field "b" not allowed in closed struct)}, ` +
+ `b: <7>{[]: <8>(_: string)->(<9>C{a: int} | <10>C{b: int}), w: _|_(int:empty disjunction: field "c" not allowed in closed struct)}, ` +
+ `#Q: <11>{[]: <12>(_: string)->(<13>C{a: int} | <14>C{b: int}), }, ` +
+ `c: <15>{[]: <16>(_: string)->[<17>C{a: int},<18>C{b: int}], w: [_|_(int:field "d" not allowed in closed struct),<19>C{b: int}]}, ` +
+ `#R: <20>{[]: <21>(_: string)->[<22>C{a: int},<23>C{b: int}], }}`,
+ }, {
+ desc: "definitions with disjunctions",
+ in: `
+ #Foo: {
+ field: int
+
+ { a: 1 } |
+ { b: 2 }
+ }
+
+ foo: #Foo
+ foo: { a: 1 }
+
+ bar: #Foo
+ bar: { c: 2 }
+
+ baz: #Foo
+ baz: { b: 2 }
+ `,
+ out: `<0>{` +
+ `#Foo: (<1>C{field: int, a: 1} | <2>C{field: int, b: 2}), ` +
+ `foo: <3>C{field: int, a: 1}, ` +
+ `bar: _|_(2:empty disjunction: field "c" not allowed in closed struct), ` +
+ `baz: <4>C{field: int, b: 2}}`,
+ }, {
+ desc: "definitions with disjunctions recurisive",
+ in: `
+ #Foo: {
+ x: {
+ field: int
+
+ { a: 1 } |
+ { b: 2 }
+ }
+ x: c: 3
+ }
+ `,
+ out: `<0>{` +
+ `#Foo: <1>C{x: (<2>C{field: int, a: 1, c: 3} | <3>C{field: int, b: 2, c: 3})}` +
+ `}`,
+ }, {
+ desc: "definitions with embedding",
+ in: `
+ #E: {
+ a: { b: int }
+ }
+
+ #S: {
+ #E
+ a: { c: int }
+ b: 3
+ }
+
+ // adding a field to a nested struct that is closed.
+ #e1: #S & { a: d: 4 }
+ // literal struct not closed until after unification.
+ #v1: #S & { a: c: 4 }
+ `,
+ out: `<0>{` +
+ `#E: <1>C{a: <2>C{b: int}}, ` +
+ `#S: <3>C{a: <4>C{b: int, c: int}, b: 3}, ` +
+ `#e1: <5>C{a: _|_(4:field "d" not allowed in closed struct), b: 3}, ` +
+ `#v1: <6>C{a: <7>C{b: int, c: 4}, b: 3}}`,
+ }, {
+ desc: "top-level definition with struct and disjunction",
+ in: `
+ #def: {
+ Type: string
+ Text: string
+ Size: int
+ }
+
+ #def: {
+ Type: "B"
+ Size: 0
+ } | {
+ Type: "A"
+ Size: 1
+ }`,
+ out: `<0>{` +
+ `#def: (<1>C{Size: (0 & int), Type: ("B" & string), Text: string} | ` +
+ `<2>C{Size: (1 & int), Type: ("A" & string), Text: string})` +
+ `}`,
+ }, {
+ desc: "closing structs",
+ in: `
+ op: {x: int} // {x: int}
+ ot: {x: int, ...} // {x: int, ...}
+ cp: close({x: int}) // closed({x: int})
+ ct: close({x: int, ...}) // {x: int, ...}
+
+ opot: op & ot // {x: int, ...}
+ otop: ot & op // {x: int, ...}
+ opcp: op & cp // closed({x: int})
+ cpop: cp & op // closed({x: int})
+ opct: op & ct // {x: int, ...}
+ ctop: ct & op // {x: int, ...}
+ otcp: ot & cp // closed({x: int})
+ cpot: cp & ot // closed({x: int})
+ otct: ot & ct // {x: int, ...}
+ ctot: ct & ot // {x: int, ...}
+ cpct: cp & ct // closed({x: int})
+ ctcp: ct & cp // closed({x: int})
+ ctct: ct & ct // {x: int, ...}
+ `,
+ out: `<0>{` +
+ `op: <1>{x: int}, ` +
+ `ot: <2>{x: int, ...}, ` +
+ `cp: <3>C{x: int}, ` +
+ `ct: <4>{x: int, ...}, ` +
+ `opot: <5>{x: int, ...}, ` +
+ `otop: <6>{x: int, ...}, ` +
+ `opcp: <7>C{x: int}, ` +
+ `cpop: <8>C{x: int}, ` +
+ `opct: <9>{x: int, ...}, ` +
+ `ctop: <10>{x: int, ...}, ` +
+ `otcp: <11>C{x: int}, ` +
+ `cpot: <12>C{x: int}, ` +
+ `otct: <13>{x: int, ...}, ` +
+ `ctot: <14>{x: int, ...}, ` +
+ `cpct: <15>C{x: int}, ` +
+ `ctcp: <16>C{x: int}, ` +
+ `ctct: <17>{x: int, ...}}`,
+ }, {
+ desc: "excluded embedding from closing",
+ in: `
+ #S: {
+ a: { c: int }
+ {
+ c: { d: int }
+ }
+ B = { open: int }
+ b: B
+ }
+ V: #S & {
+ c: e: int
+ b: extra: int
+ }
+ `,
+ out: `<0>{` +
+ `#S: <1>C{` +
+ `a: <2>C{c: int}, ` +
+ `c: <3>{d: int}, ` +
+ `b: <4>{open: int}}, ` +
+ `V: <5>C{` +
+ `a: <6>C{c: int}, ` +
+ `c: <7>{d: int, e: int}, ` +
+ `b: <8>{open: int, extra: int}}}`,
+ }, {
+ desc: "closing with failed optional",
+ in: `
+ #k1: {a: int, b?: int} & #A // closed({a: int})
+ #k2: #A & {a: int, b?: int} // closed({a: int})
+
+ o1: {a?: 3} & {a?: 4} // {a?: _|_}
+
+ // Optional fields with error values can be elimintated when closing
+ #o2: {a?: 3} & {a?: 4} // close({})
+
+ #d1: {a?: 2, b: 4} | {a?: 3, c: 5}
+ v1: #d1 & {a?: 3, b: 4} // close({b: 4})
+
+ #A: {a: int}
+ `,
+ out: `<0>{` +
+ `#k1: <1>C{a: int}, ` +
+ `#A: <2>C{a: int}, ` +
+ `#k2: <3>C{a: int}, ` +
+ `o1: <4>{a?: _|_((3 & 4):conflicting values 3 and 4)}, ` +
+ `#o2: <5>C{a?: _|_((3 & 4):conflicting values 3 and 4)}, ` +
+ `#d1: (<6>C{a?: 2, b: 4} | <7>C{a?: 3, c: 5}), ` +
+ `v1: <8>C{a?: _|_((2 & 3):conflicting values 2 and 3), b: 4}` +
+ `}`,
+ }, {
+ desc: "closing with comprehensions",
+ in: `
+ #A: {f1: int, f2: int}
+
+ for k, v in {f3 : int} {
+ a: #A & { "\(k)": v }
+ }
+
+ #B: {
+ for k, v in {f1: int} {
+ "\(k)": v
+ }
+ }
+
+ #C: {
+ f1: _
+ for k, v in {f1: int} {
+ "\(k)": v
+ }
+ }
+
+ #D: {
+ for k, v in {f1: int} {
+ "\(k)": v
+ }
+ ...
+ }
+
+ #E: #A & {
+ for k, v in { f3: int } {
+ "\(k)": v
+ }
+ }
+ `,
+ out: `<0>{` +
+ `#A: <1>C{f1: int, f2: int}, ` +
+ `a: _|_(<2>.v:field "f3" not allowed in closed struct), ` +
+ `#B: <3>C{f1: int}, ` +
+ `#C: <4>C{f1: int}, ` +
+ `#D: <5>{f1: int, ...}, ` +
+ `#E: _|_(<6>.v:field "f3" not allowed in closed struct)` +
+ `}`,
+ }, {
+ desc: "incomplete comprehensions",
+ in: `
+ A: {
+ for v in src {
+ "\(v)": v
+ }
+ src: _
+ if true {
+ baz: "baz"
+ }
+ }
+ B: A & {
+ src: ["foo", "bar"]
+ }
+ `,
+ out: `<0>{` +
+ `A: <1>{src: _, baz: "baz" <2>for _, v in <3>.src yield <4>{""+<2>.v+"": <2>.v}}, ` +
+ `B: <5>{src: ["foo","bar"], baz: "baz", foo: "foo", bar: "bar"}}`,
+ }, {
+ desc: "reference to root",
+ in: `
+ a: { b: int }
+ c: a & {
+ b: 100
+ d: a.b + 3 // do not resolve as c != a.
+ }
+ x: {
+ b: int
+ c: b + 5
+ }
+ y: x & {
+ b: 100
+ // c should resolve to 105
+ }
+ v: {
+ b: int
+ c: v.b + 5 // reference starting from copied node.
+ }
+ w: v & { b: 100 }
+ wp: v & { b: 100 }
+ `,
+ out: `<0>{x: <1>{b: int, c: (<2>.b + 5)}, y: <3>{b: 100, c: 105}, a: <4>{b: int}, c: <5>{b: 100, d: (<6>.a.b + 3)}, v: <7>{b: int, c: (<6>.v.b + 5)}, w: <8>{b: 100, c: (<6>.v.b + 5)}, wp: <9>{b: 100, c: (<6>.v.b + 5)}}`,
+ // TODO(#152): should be
+ // out: `<0>{a: <1>{b: int}, c: <2>{b: 100, d: (<3>.a.b + 3)}, x: <4>{b: int, c: (<5>.b + 5)}, y: <6>{b: 100, c: 105}, v: <7>{b: int, c: (<8>.b + 5)}, w: <9>{b: 100, c: 105}, wp: <10>{b: 100, c: 105}}`,
+ }, {
+ desc: "references from template to concrete",
+ in: `
+ res: [t]
+ t: [X=string]: {
+ a: c + b.str
+ b: str: string
+ c: "X"
+ }
+ t: x: { b: str: "DDDD" }
+ `,
+ out: `<0>{res: [<1>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <5>{a: "XDDDD", c: "X", b: <6>{str: "DDDD"}}}], t: <7>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <8>{a: "XDDDD", c: "X", b: <9>{str: "DDDD"}}}}`,
+ }, {
+ desc: "interpolation",
+ in: `
+ a: "\(4)"
+ b: "one \(a) two \( a + c )"
+ c: "one"
+ d: "\(r)"
+ u: "\(_)"
+ r: _
+ e: "\([])"`,
+ out: `<0>{a: "4", b: "one 4 two 4one", c: "one", d: ""+<1>.r+"", r: _, u: ""+_+"", e: _|_([]:expression in interpolation must evaluate to a number kind or string (found list))}`,
+ }, {
+ desc: "multiline interpolation",
+ in: `
+ a1: """
+ before
+ \(4)
+ after
+ """
+ a2: """
+ before
+ \(4)
+
+ """
+ a3: """
+
+ \(4)
+ after
+ """
+ a4: """
+
+ \(4)
+
+ """
+ m1: """
+ before
+ \(
+ 4)
+ after
+ """
+ m2: """
+ before
+ \(
+ 4)
+
+ """
+ m3: """
+
+ \(
+
+ 4)
+ after
+ """
+ m4: """
+
+ \(
+ 4)
+
+ """
+ `,
+ out: `<0>{` +
+ `a1: "before\n4\nafter", a2: "before\n4\n", a3: "\n4\nafter", a4: "\n4\n", ` +
+ `m1: "before\n4\nafter", m2: "before\n4\n", m3: "\n4\nafter", m4: "\n4\n"` +
+ `}`,
+ }, {
+ desc: "diamond-shaped constraints",
+ in: `
+ S: {
+ A: {
+ a: 1,
+ },
+ B: A & {
+ b: 2,
+ }
+ },
+ T: S & { // S == { A: { a:1 }, B: { a:1, b:2 } }
+ A: {
+ c: 3,
+ },
+ B: { // S.B & A
+ d: 4, // Combines constraints S.A, S.B, T.A, and T.B
+ }
+ }`,
+ out: "<0>{T: <1>{A: <2>{a: 1, c: 3}, B: <3>{a: 1, b: 2, c: 3, d: 4}}, S: <4>{A: <5>{a: 1}, B: <6>{a: 1, b: 2}}}",
+ }, {
+ desc: "field templates",
+ in: `
+ a: {
+ {[name=_]: int}
+ k: 1
+ }
+ b: {
+ {[X=_]: { x: 0, y: *1 | int }}
+ v: {}
+ w: { x: 0 }
+ }
+ b: { [y=_]: {} }
+ c: {
+ {[Name=_]: { name: Name, y: 1 }}
+ foo: {}
+ bar: _
+ }
+ `,
+ out: `<0>{a: <1>{[]: <2>(name: string)->int, k: 1}, b: <3>{[]: <4>(X: string)->(<5>{x: 0, y: (*1 | int)} & <6>{}), v: <7>{x: 0, y: (*1 | int)}, w: <8>{x: 0, y: (*1 | int)}}, c: <9>{[]: <10>(Name: string)-><11>{y: 1, name: <10>.Name}, foo: <12>{y: 1, name: "foo"}, bar: <13>{y: 1, name: "bar"}}}`,
+ }, {
+ desc: "range unification",
+ in: `
+ // with concrete values
+ a1: >=1 & <=5 & 3
+ a2: >=1 & <=5 & 1
+ a3: >=1 & <=5 & 5
+ a4: >=1 & <=5 & 6
+ a5: >=1 & <=5 & 0
+
+ a6: 3 & >=1 & <=5
+ a7: 1 & >=1 & <=5
+ a8: 5 & >=1 & <=5
+ a9: 6 & >=1 & <=5
+ a10: 0 & >=1 & <=5
+
+ // with ranges
+ b1: >=1 & <=5 & >=1 & <=5
+ b2: >=1 & <=5 & >=1 & <=1
+ b3: >=1 & <=5 & >=5 & <=5
+ b4: >=1 & <=5 & >=2 & <=3
+ b5: >=1 & <=5 & >=3 & <=9
+ b6: >=1 & <=5 & >=5 & <=9
+ b7: >=1 & <=5 & >=6 & <=9
+
+ b8: >=1 & <=5 & >=1 & <=5
+ b9: >=1 & <=1 & >=1 & <=5
+ b10: >=5 & <=5 & >=1 & <=5
+ b11: >=2 & <=3 & >=1 & <=5
+ b12: >=3 & <=9 & >=1 & <=5
+ b13: >=5 & <=9 & >=1 & <=5
+ b14: >=6 & <=9 & >=1 & <=5
+
+ // ranges with more general types
+ c1: int & >=1 & <=5
+ c2: >=1 & <=5 & int
+ c3: string & >=1 & <=5
+ c4: >=1 & <=5 & string
+
+ // other types
+ s1: >="d" & <="z" & "e"
+ s2: >="d" & <="z" & "ee"
+
+ n1: number & >=1 & <=2
+ n2: int & >=1.1 & <=1.3
+ n3: >=1.0 & <=3.0 & 2
+ n4: >=0.0 & <=0.1 & 0.09999
+ n5: >=1 & <=5 & 2.5
+ `,
+ out: `<0>{` +
+ `a1: 3, ` +
+ `a2: 1, ` +
+ `a3: 5, ` +
+ `a4: _|_((<=5 & 6):invalid value 6 (out of bound <=5)), ` +
+ `a5: _|_((>=1 & 0):invalid value 0 (out of bound >=1)), ` +
+ `a6: 3, ` +
+ `a7: 1, ` +
+ `a8: 5, ` +
+
+ `a9: _|_((<=5 & 6):invalid value 6 (out of bound <=5)), ` +
+ `a10: _|_((>=1 & 0):invalid value 0 (out of bound >=1)), ` +
+
+ `b1: (>=1 & <=5), ` +
+ `b2: 1, ` +
+ `b3: 5, ` +
+ `b4: (>=2 & <=3), ` +
+ `b5: (>=3 & <=5), ` +
+ `b6: 5, ` +
+ `b7: _|_(conflicting bounds >=6 and <=5), ` +
+ `b8: (>=1 & <=5), ` +
+ `b9: 1, ` +
+ `b10: 5, ` +
+ `b11: (>=2 & <=3), ` +
+ `b12: (>=3 & <=5), ` +
+ `b13: 5, ` +
+ `b14: _|_(conflicting bounds >=6 and <=5), ` +
+ `c1: (int & >=1 & <=5), ` +
+ `c2: (<=5 & int & >=1), ` +
+ `c3: _|_((string & >=1):conflicting values string and >=1 (mismatched types string and number)), ` +
+ `c4: _|_(((>=1 & <=5) & string):conflicting values (>=1 & <=5) and string (mismatched types number and string)), ` +
+ `s1: "e", ` +
+ `s2: "ee", ` +
+ `n1: (>=1 & <=2), ` +
+ `n2: _|_(conflicting bounds int & >=1.1 and <=1.3), ` +
+ `n3: 2, ` +
+ `n4: 0.09999, ` +
+ `n5: 2.5}`,
+ }, {
+ desc: "predefined ranges",
+ in: `
+ k1: int8
+ k1: 44
+
+ k2: int64
+ k2: -8_000_000_000
+
+ e1: int16
+ e1: 100_000
+ `,
+ out: `<0>{k1: 44, k2: -8000000000, ` +
+ `e1: _|_((int & <=32767 & 100000):invalid value 100000 (out of bound int & <=32767))}`,
+ }, {
+ desc: "struct comprehensions",
+ in: `
+ obj: foo: a: "bar"
+ obj: [Name=string]: {
+ a: *"dummy" | string
+ if true {
+ sub: as: a
+ }
+ }
+
+ for k, v in { #def: 1, opt?: 2, _hid: 3, reg: 4 } {
+ "\(k)": v
+ }
+ `,
+ out: `<0>{obj: <1>{[]: <2>(Name: string)-><3>{a: (*"dummy" | string) if true yield <4>{sub: <5>{as: <3>.a}}}, foo: <6>{a: "bar", sub: <7>{as: "bar"}}}, reg: 4}`,
+ }, {
+ desc: "builtins",
+ in: `
+ a1: {
+ a: and([b, c])
+ b: =~"oo"
+ c: =~"fo"
+ }
+ a2: a1 & { a: "foo" }
+ a3: a1 & { a: "bar" }
+
+ o1: {
+ a: or([b, c])
+ b: string
+ c: "bar"
+ }
+ o2: o1 & { a: "foo" }
+ o3: o1 & { a: "foo", b: "baz" }
+ `,
+ out: `<0>{` +
+ `a1: <1>{a: (=~"oo" & =~"fo"), b: =~"oo", c: =~"fo"}, ` +
+ `a2: <2>{a: "foo", b: =~"oo", c: =~"fo"}, ` +
+ `a3: <3>{a: _|_((=~"oo" & "bar"):invalid value "bar" (does not match =~"oo")), b: =~"oo", c: =~"fo"}, ` +
+ `o1: <4>{a: string, b: string, c: "bar"}, ` +
+ `o2: <5>{a: "foo", b: string, c: "bar"}, ` +
+ `o3: <6>{a: _|_(("baz" & "foo"):empty disjunction: conflicting values "baz" and "foo";("bar" & "foo"):empty disjunction: conflicting values "bar" and "foo"), b: "baz", c: "bar"}}`,
+ }, {
+ desc: "self-reference cycles conflicts with strings",
+ in: `
+ a: {
+ x: y+"?"
+ y: x+"!"
+ }
+ a: x: "hey"
+ `,
+ out: `<0>{a: <1>{x: _|_(("hey!?" & "hey"):conflicting values "hey!?" and "hey"), y: "hey!"}}`,
+ }, {
+ desc: "resolved self-reference cycles with disjunctions",
+ in: `
+ a: b&{x:1} | {y:1} // {x:1,y:3,z:2} | {y:1}
+ b: {x:2} | c&{z:2} // {x:2} | {x:1,y:3,z:2}
+ c: a&{y:3} | {z:3} // {x:1,y:3,z:2} | {z:3}
+ `,
+ out: `<0>{a: (<1>{x: 1, y: 3, z: 2} | <2>{y: 1}), b: (<3>{x: 2} | <4>{x: 1, y: 3, z: 2}), c: (<5>{x: 1, y: 3, z: 2} | <6>{z: 3})}`,
+ }, {
+ // We take a very conservative stance on delaying arithmetic
+ // expressions within disjunctions. It should remain resolvable, though,
+ // once the user specifies one.
+ desc: "resolved self-reference cycles with disjunction",
+ in: `
+ // The second disjunct in xa1 is not resolvable and can be
+ // eliminated:
+ // xa4 & 9
+ // (xa2 + 2) & 9
+ // ((xa3 + 2) + 2) & 9
+ // (((6 & xa1-2) + 2) + 2) & 9
+ // ((6 + 2) + 2) & 9 // 6 == xa1-2
+ // 10 & 9 => _|_
+ // The remaining values resolve.
+ xa1: (xa2 & 8) | (xa4 & 9)
+ xa2: xa3 + 2
+ xa3: 6 & xa1-2
+ xa4: xa2 + 2
+
+ // The second disjunct in xb4 can be eliminated as both disjuncts
+ // of xb3 result in an incompatible sum when substituted.
+ xb1: (xb2 & 8) | (xb4 & 9)
+ xb2: xb3 + 2
+ xb3: (6 & (xb1-2)) | (xb4 & 9)
+ xb4: xb2 + 2
+
+ // Another variant with more disjunctions. xc1 remains with two
+ // possibilities. Technically, only the first value is valid.
+ // However, to fully determine that, all options of the remaining
+ // disjunction will have to be evaluated algebraically, which is
+ // not done.
+ xc1: xc2 & 8 | xc4 & 9 | xc5 & 9
+ xc2: xc3 + 2
+ xc3: 6 & xc1-2
+ xc4: xc2 + 1
+ xc5: xc2 + 2
+
+ // The above is resolved by setting xd1 explicitly.
+ xd1: xd2 & 8 | xd4 & 9 | xd5 & 9
+ xd2: xd3 + 2
+ xd3: 6 & xd1-2
+ xd4: xd2 + 1
+ xd5: xd2 + 2
+ xd1: 8
+
+ // The above is resolved by setting xd1 explicitly to the wrong
+ // value, resulting in an error.
+ xe1: xe2 & 8 | xe4 & 9 | xe5 & 9
+ xe2: xe3 + 2
+ xe3: 6 & xe1-2
+ xe4: xe2 + 1
+ xe5: xe2 + 2
+ xe1: 9
+
+ // Only one solution.
+ xf1: xf2 & 8 | xf4 & 9
+ xf2: xf3 + 2
+ xf3: 6 & xf1-2 | xf4 & 9
+ xf4: xf2 + 2
+
+ z1: z2 + 1 | z3 + 5
+ z2: z3 + 2
+ z3: z1 - 3
+ z3: 8
+ `,
+ out: `<0>{` +
+ `xa1: 8, ` +
+ `xa2: 8, ` +
+ `xa4: 10, ` +
+ `xa3: 6, ` +
+
+ `xb1: 8, ` +
+ `xb2: 8, ` +
+ `xb4: 10, ` +
+ `xb3: 6, ` +
+
+ `xc1: ((<1>.xc2 & 8) | (<1>.xc4 & 9) | (<1>.xc5 & 9)), ` +
+ `xc2: (<1>.xc3 + 2), ` +
+ `xc4: (<1>.xc2 + 1), ` +
+ `xc5: (<1>.xc2 + 2), ` +
+ `xc3: (6 & (<1>.xc1 - 2)), ` +
+
+ `xd1: 8, ` +
+ `xd2: 8, ` +
+ `xd4: 9, ` +
+ `xd5: 10, ` +
+ `xd3: 6, ` +
+
+ `xe1: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe2: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe4: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe5: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe3: _|_((6 & 7):conflicting values 6 and 7), ` +
+
+ `xf1: 8, ` +
+ `xf2: 8, ` +
+ `xf4: 10, ` +
+ `xf3: 6, ` +
+
+ `z1: ((<1>.z2 + 1) | (<1>.z3 + 5)), ` +
+ `z2: (<1>.z3 + 2), ` +
+ `z3: ((<1>.z1 - 3) & 8)}`,
+ }, {
+ // Defaults should not alter the result of the above disjunctions.
+ // The results may differ, but errors and resolution should be roughly
+ // the same.
+ desc: "resolved self-reference cycles with disjunction with defaults",
+ in: `
+ // The disjunction in xa could be resolved, but as disjunctions
+ // are not resolved for expression, it remains unresolved.
+ xa1: (xa2 & 8) | *(xa4 & 9)
+ xa2: xa3 + 2
+ xa3: 6 & xa1-2
+ xa4: xa2 + 2
+
+ // As xb3 is a disjunction, xb2 cannot be resolved and evaluating
+ // the cycle completely is broken. However, it is not an error
+ // as the user might still resolve the disjunction.
+ xb1: *(xb2 & 8) | (xb4 & 9)
+ xb2: xb3 + 2
+ xb3: *(6 & (xb1-2)) | (xb4 & 9)
+ xb4: xb2 + 2
+
+ // Another variant with more disjunctions. xc1 remains with two
+ // possibilities. Technically, only the first value is valid.
+ // However, to fully determine that, all options of the remaining
+ // disjunction will have to be evaluated algebraically, which is
+ // not done.
+ xc1: *(xc2 & 8) | (xc4 & 9) | (xc5 & 9)
+ xc2: xc3 + 2
+ xc3: 6 & xc1-2
+ xc4: xc2 + 1
+ xc5: xc2 + 2
+
+ // The above is resolved by setting xd1 explicitly.
+ xd1: *(xd2 & 8) | xd4 & 9 | xd5 & 9
+ xd2: xd3 + 2
+ xd3: 6 & xd1-2
+ xd4: xd2 + 1
+ xd5: xd2 + 2
+
+ // The above is resolved by setting xd1 explicitly to the wrong
+ // value, resulting in an error.
+ xe1: *(xe2 & 8) | xe4 & 9 | xe5 & 9
+ xe2: xe3 + 2
+ xe3: 6 & xe1-2
+ xe4: xe2 + 1
+ xe5: xe2 + 2
+ xe1: 9
+
+ z1: *(z2 + 1) | z3 + 5
+ z2: z3 + 2
+ z3: z1 - 3
+ z3: 8
+ `,
+ out: `<0>{` +
+ `xa1: 8, ` +
+ `xa2: 8, ` +
+ `xa4: 10, ` +
+ `xa3: 6, ` +
+
+ `xb1: 8, ` +
+ `xb2: 8, ` +
+ `xb4: 10, ` +
+ `xb3: 6, ` +
+
+ `xc1: (*8 | 9), ` + // not resolved because we use evalPartial
+ `xc2: 8, ` +
+ `xc4: 9, ` +
+ `xc5: 10, ` +
+ `xc3: 6, ` +
+
+ `xd1: (*8 | 9), ` + // TODO: eliminate 9?
+ `xd2: 8, ` +
+ `xd4: 9, ` +
+ `xd5: 10, ` +
+ `xd3: 6, ` +
+
+ `xe1: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe2: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe4: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe5: _|_((6 & 7):conflicting values 6 and 7), ` +
+ `xe3: _|_((6 & 7):conflicting values 6 and 7), ` +
+
+ `z1: (*11 | 13), ` + // 13 is eliminated with evalFull
+ `z2: 10, ` +
+ `z3: 8}`,
+ }}
+ rewriteHelper(t, testCases, evalPartial)
+}
+
+func TestFullEval(t *testing.T) {
+ testCases := []testCase{{
+ desc: "detect conflicting value",
+ in: `
+ a: 8000.9
+ a: 7080 | int`,
+ out: `<0>{a: _|_((8000.9 & (int | int)):conflicting values 8000.9 and int (mismatched types float and int))}`, // TODO: fix repetition
+ }, {
+ desc: "conflicts in optional fields are okay ",
+ in: `
+ d: {a: 1, b?: 3} | {a: 2}
+
+ // the following conjunction should not eliminate any disjuncts
+ c: d & {b?:4}
+ `,
+ out: `<0>{d: (<1>{a: 1, b?: 3} | <2>{a: 2}), c: (<3>{a: 1, b?: (3 & 4)} | <4>{a: 2, b?: 4})}`,
+ }, {
+ desc: "resolve all disjunctions",
+ in: `
+ service: [Name=string]: {
+ name: string | *Name
+ port: int | *7080
+ }
+ service: foo: _
+ service: bar: { port: 8000 }
+ service: baz: { name: "foobar" }
+ `,
+ out: `<0>{service: <1>{[]: <2>(Name: string)-><3>{name: (string | *<2>.Name), port: (int | *7080)}, foo: <4>{name: "foo", port: 7080}, bar: <5>{name: "bar", port: 8000}, baz: <6>{name: "foobar", port: 7080}}}`,
+ }, {
+ desc: "field templates",
+ in: `
+ a: {
+ [name=_]: int
+ k: 1
+ }
+ b: {
+ [X=_]: { x: 0, y: *1 | int }
+ v: {}
+ w: { y: 0 }
+ }
+ b: { [y=_]: {} } // TODO: allow different name
+ c: {
+ [Name=_]: { name: Name, y: 1 }
+ foo: {}
+ bar: _
+ }
+ `,
+ out: `<0>{a: <1>{[]: <2>(name: string)->int, k: 1}, b: <3>{[]: <4>(X: string)->(<5>{x: 0, y: (*1 | int)} & <6>{}), v: <7>{x: 0, y: 1}, w: <8>{x: 0, y: 0}}, c: <9>{[]: <10>(Name: string)-><11>{y: 1, name: <10>.Name}, foo: <12>{y: 1, name: "foo"}, bar: <13>{y: 1, name: "bar"}}}`,
+ }, {
+ desc: "field comprehension",
+ in: `
+ a: {
+ for k, v in b
+ if k < "d"
+ if v > b.a {
+ "\(k)": v
+ }
+ }
+ b: {
+ a: 1
+ b: 2
+ c: 3
+ d: 4
+ }
+ c: {
+ for k, v in b
+ if k < "d"
+ if v > b.a {
+ "\(k)": v
+ }
+ }
+ `,
+ out: `<0>{a: <1>{b: 2, c: 3}, b: <2>{a: 1, b: 2, c: 3, d: 4}, c: <3>{b: 2, c: 3}}`,
+ }, {
+ desc: "conditional field",
+ in: `
+ if b {
+ a: "foo"
+ }
+ b: true
+ c: {
+ a: 3
+ if a > 1 {
+ a: 3
+ }
+ }
+ d: {
+ a: int
+ if a > 1 {
+ a: 3
+ }
+ }
+ `,
+ // NOTE: the node numbers are not correct here, but this is an artifact
+ // of the testing code.
+ out: `<0>{b: true, a: "foo", c: <1>{a: 3}, d: <2>{a: int if (<3>.a > 1) yield <4>{a: 3}}}`,
+ }, {
+ desc: "referencing field in field comprehension",
+ in: `
+ a: { b: c: 4 }
+ a: {
+ b: d: 5
+ for k, v in b {
+ "\(k)": v
+ }
+ }
+ `,
+ out: `<0>{a: <1>{b: <2>{c: 4, d: 5}, c: 4, d: 5}}`,
+ }, {
+ desc: "different labels for templates",
+ in: `
+ a: [X=string]: { name: X }
+ a: [Name=string]: { name: Name }
+ a: foo: {}
+ `,
+ out: `<0>{a: <1>{[]: <2>(X: string)->(<3>{name: <2>.X} & <4>{name: <2>.X}), foo: <5>{name: "foo"}}}`,
+ }, {
+ // TODO: rename EE and FF to E and F to check correct ordering.
+
+ desc: "nested templates in one field",
+ in: `
+ a: [A=string]: b: [B=string]: {
+ name: A
+ kind: B
+ }
+ a: "A": b: "B": _
+ a: "C": b: "D": _
+ a: "EE": b: "FF": { c: "bar" }
+ `,
+ out: `<0>{a: <1>{[]: <2>(A: string)-><3>{b: <4>{[]: <5>(B: string)-><6>{name: <2>.A, kind: <5>.B}, }}, ` +
+ `A: <7>{b: <8>{[]: <9>(B: string)-><10>{name: <11>.A, kind: <9>.B}, ` +
+ `B: <12>{name: "A", kind: "B"}}}, ` +
+ `C: <13>{b: <14>{[]: <15>(B: string)-><16>{name: <17>.A, kind: <15>.B}, ` +
+ `D: <18>{name: "C", kind: "D"}}}, ` +
+ `EE: <19>{b: <20>{[]: <21>(B: string)-><22>{name: <23>.A, kind: <21>.B}, ` +
+ `FF: <24>{name: "EE", kind: "FF", c: "bar"}}}}}`,
+ }, {
+ desc: "template unification within one struct",
+ in: `
+ a: {
+ [A=string]: { name: A }
+ // TODO: allow duplicate alias here
+ [X=string]: { kind: X }
+ }
+ a: "A": _
+ a: "C": _
+ a: "E": { c: "bar" }
+ `,
+ out: `<0>{a: <1>{[]: <2>(A: string)->(<3>{name: <2>.A} & <4>{kind: <2>.A}), ` +
+ `E: <5>{name: "E", kind: "E", c: "bar"}, ` +
+ `A: <6>{name: "A", kind: "A"}, ` +
+ `C: <7>{name: "C", kind: "C"}}}`,
+ }, {
+ desc: "field comprehensions with multiple keys",
+ in: `
+ for x in [
+ {a: "A", b: "B" },
+ {a: "C", b: "D" },
+ {a: "E", b: "F" },
+ ] {
+ a: "\(x.a)": b: "\(x.b)": x
+ }
+
+ for x in [
+ {a: "A", b: "B" },
+ {a: "C", b: "D" },
+ {a: "E", b: "F" },
+ ] {
+ "\(x.a)": "\(x.b)": x
+ }
+ `,
+ out: `<0>{E: <1>{F: <2>{a: "E", b: "F"}}, ` +
+ `a: <3>{` +
+ `E: <4>{b: <5>{F: <6>{a: "E", b: "F"}}}, ` +
+ `A: <7>{b: <8>{B: <9>{a: "A", b: "B"}}}, ` +
+ `C: <10>{b: <11>{D: <12>{a: "C", b: "D"}}}}, ` +
+ `A: <13>{B: <14>{a: "A", b: "B"}}, ` +
+ `C: <15>{D: <16>{a: "C", b: "D"}}}`,
+ // TODO: this order would be desirable.
+ // out: `<0>{a: <1>{` +
+ // `A: <2>{b: <3>{B: <4>{a: "A", b: "B"}}}, ` +
+ // `C: <5>{b: <6>{D: <7>{a: "C", b: "D"}}}, ` +
+ // `E: <8>{b: <9>{F: <10>{a: "E", b: "F"}}}}, ` +
+ // `A: <11>{B: <12>{a: "A", b: "B"}}, ` +
+ // `C: <13>{D: <14>{a: "C", b: "D"}}, ` +
+ // `E: <15>{F: <16>{a: "E", b: "F"}}}`,
+ }, {
+ desc: "field comprehensions with templates",
+ in: `
+ num: 1
+ a: {
+ if num < 5 {
+ [A=string]: [B=string]: {
+ name: A
+ kind: B
+ }
+ }
+ }
+ a: b: c: d: "bar"
+ `,
+ out: `<0>{num: 1, a: <1>{[]: <2>(A: string)-><3>{[]: <4>(B: string)-><5>{name: <2>.A, kind: <4>.B}, }, ` +
+ `b: <6>{[]: <7>(B: string)-><8>{name: <9>.A, kind: <7>.B}, ` +
+ `c: <10>{name: "b", kind: "c", ` +
+ `d: "bar"}}}}`,
+ }, {
+ desc: "disjunctions of lists",
+ in: `
+ l: *[ int, int ] | [ string, string ]
+
+ l1: [ "a", "b" ]
+ l2: l & [ "c", "d" ]
+ `,
+ out: `<0>{l: [int,int], l1: ["a","b"], l2: ["c","d"]}`,
+ }, {
+ desc: "normalization",
+ in: `
+ a: string | string
+ b: *1 | *int
+ c: *1.0 | *float
+ `,
+ out: `<0>{a: string, b: int, c: float}`,
+ }, {
+ desc: "default disambiguation and elimination",
+ in: `
+ a: *1 | int
+ b: *3 | int
+ c: a & b
+ d: b & a
+
+ e: *1 | *1
+ `,
+ out: `<0>{a: 1, b: 3, c: int, d: int, e: 1}`,
+ }, {
+ desc: "list comprehension",
+ in: `
+ a: [ for k, v in b if k < "d" if v > b.a { k }]
+ b: {
+ a: 1
+ b: 2
+ c: 3
+ d: 4
+ }
+ c: [ for _, x in b for _, y in b if x < y { x } ]
+ d: [ for x, _ in a { x } ]
+ `,
+ out: `<0>{a: ["b","c"], b: <1>{a: 1, b: 2, c: 3, d: 4}, c: [1,1,1,2,2,3], d: [0,1]}`,
+ }, {
+ desc: "struct comprehension with template",
+ in: `
+ result: [ for _, v in service { v } ]
+
+ service: [Name=string]: {
+ name: *Name | string
+ type: "service"
+ port: *7080 | int
+ }
+ service: foo: {}
+ service: bar: { port: 8000 }
+ service: baz: { name: "foobar" }
+ `,
+ out: `<0>{result: [` +
+ `<1>{name: "foo", type: "service", port: 7080},` +
+ `<2>{name: "bar", type: "service", port: 8000},` +
+ `<3>{name: "foobar", type: "service", port: 7080}], ` +
+
+ `service: <4>{` +
+ `[]: <5>(Name: string)-><6>{name: (*<5>.Name | string), type: "service", port: (*7080 | int)}, ` +
+ `foo: <7>{name: "foo", type: "service", port: 7080}, ` +
+ `bar: <8>{name: "bar", type: "service", port: 8000}, ` +
+ `baz: <9>{name: "foobar", type: "service", port: 7080}}}`,
+ }, {
+ desc: "resolutions in struct comprehension keys",
+ in: `
+ a: { for _, b in ["c"] { "\(b + ".")": "a" } }
+ `,
+ out: `<0>{a: <1>{"c.": "a"}}`,
+ }, {
+ desc: "recursive evaluation within list",
+ in: `
+ l: [a]
+ a: b & { c: "t" }
+ b: {
+ d: c
+ c: string
+ }
+ l1: [a1]
+ a1: b1 & { c: "t" }
+ b1: {
+ d: "s" + c
+ c: string
+ }
+ `,
+ out: `<0>{` +
+ `l: [<1>{c: "t", d: "t"}], ` +
+ `a: <2>{c: "t", d: "t"}, ` +
+ `b: <3>{c: string, d: string}, ` +
+ `l1: [<4>{c: "t", d: "st"}], ` +
+ `a1: <5>{c: "t", d: "st"}, ` +
+ `b1: <6>{c: string, d: ("s" + <7>.c)}}`,
+ }, {
+ desc: "ips",
+ in: `
+ IP: 4*[ uint8 ]
+
+ Private:
+ *[ 192, 168, uint8, uint8 ] |
+ [ 10, uint8, uint8, uint8] |
+ [ 172, >=16 & <=32, uint8, uint8 ]
+
+ Inst: Private & [ _, 10, ... ]
+
+ MyIP: Inst & [_, _, 10, 10 ]
+ `,
+ out: `<0>{` +
+ `IP: [(int & >=0 & int & <=255),(int & >=0 & int & <=255),(int & >=0 & int & <=255),(int & >=0 & int & <=255)], ` +
+ `Private: [192,168,(int & >=0 & int & <=255),(int & >=0 & int & <=255)], ` +
+ `Inst: [10,10,(int & >=0 & int & <=255),(int & >=0 & int & <=255)], ` +
+ `MyIP: [10,10,10,10]` +
+ `}`,
+ }, {
+ desc: "complex interaction of groundness",
+ in: `
+ res: [ for x in a for y in x { y & { d: "b" } }]
+ res: [ a.b.c & { d: "b" } ]
+
+ a: b: [C=string]: { d: string, s: "a" + d }
+ a: b: c: d: string
+ `,
+ // TODO(perf): unification should catch shared node.
+ out: `<0>{res: [<1>{d: "b", s: "ab"}], ` +
+ `a: <2>{b: <3>{[]: <4>(C: string)-><5>{d: string, s: ("a" + <5>.d)}, c: <6>{d: string, s: ("a" + <7>.d)}}}}`,
+ }, {
+ desc: "complex groundness 2",
+ in: `
+ r1: f1 & { y: "c" }
+
+ f1: { y: string, res: a.b.c & { d: y } }
+
+ a: b: c: { d: string, s: "a" + d }
+ a: b: [C=string]: { d: string, s: "a" + d }
+ a: b: c: d: string
+ `,
+ out: `<0>{r1: <1>{y: "c", res: <2>{d: "c", s: "ac"}}, f1: <3>{y: string, res: <4>{d: string, s: (("a" + <5>.d) & ("a" + <5>.d))}}, a: <6>{b: <7>{[]: <8>(C: string)-><9>{d: string, s: ("a" + <9>.d)}, c: <10>{d: string, s: (("a" + <11>.d) & ("a" + <11>.d))}}}}`,
+ }, {
+ desc: "references from template to concrete",
+ in: `
+ res: [t]
+ t: [X=string]: {
+ a: c + b.str
+ b: str: string
+ c: "X"
+ }
+ t: x: { b: str: "DDDD" }
+ `,
+ out: `<0>{res: [<1>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <5>{a: "XDDDD", c: "X", b: <6>{str: "DDDD"}}}], ` +
+ `t: <7>{[]: <2>(X: string)-><3>{a: (<3>.c + <3>.b.str), c: "X", b: <4>{str: string}}, x: <8>{a: "XDDDD", c: "X", b: <9>{str: "DDDD"}}}}`,
+ }, {
+ // TODO: A nice property for CUE to have would be that evaluation time
+ // is proportional to the number of output nodes (note that this is
+ // not the same as saying that the running time is O(n)).
+ // We should probably disallow shenanigans like the one below. But until
+ // this is allowed, it should at least be correct. At least we are not
+ // making reentrant coding easy.
+ desc: "reentrance",
+ in: `
+ // This indirection is needed to avoid binding references to fib
+ // within fib to the instantiated version.
+ fibRec: {nn: int, out: (fib & {n: nn}).out}
+ fib: {
+ n: int
+
+ if n >= 2 {
+ out: (fibRec & {nn: n - 2}).out + (fibRec & {nn: n - 1}).out
+ }
+ if n < 2 {
+ out: n
+ }
+ }
+ fib2: (fib & {n: 2}).out
+ fib7: (fib & {n: 7}).out
+ fib12: (fib & {n: 12}).out
+ `,
+ out: `<0>{` +
+ `fibRec: <1>{` +
+ `nn: int, ` +
+ `out: (<2>.fib & <3>{n: <4>.nn}).out}, ` +
+ // NOTE: the node numbers are not correct here, but this is an artifact
+ // of the testing code.
+ `fib: <5>{n: int if (<6>.n >= 2) yield <7>{out: ((<2>.fibRec & <8>{nn: (<6>.n - 2)}).out + (<2>.fibRec & <9>{nn: (<6>.n - 1)}).out)}, if (<6>.n < 2) yield <10>{out: <6>.n}}, ` +
+ `fib2: 1, ` +
+ `fib7: 13, ` +
+ `fib12: 144}`,
+ }, {
+ desc: "Issue #23",
+ in: `
+ x: {a:1}|{a:2}
+ y: x & {a:3}
+ `,
+ out: `<0>{x: (<1>{a: 1} | <2>{a: 2}), y: _|_((1 & 3):empty disjunction: conflicting values 1 and 3;(2 & 3):empty disjunction: conflicting values 2 and 3)}`,
+ }, {
+ desc: "cannot resolve references that would be ambiguous",
+ in: `
+ a1: *0 | 1
+ a1: a3 - a2
+ a2: *0 | 1
+ a2: a3 - a1
+ a3: 1
+
+ b1: (*0 | 1) & b2
+ b2: (0 | *1) & b1
+
+ c1: (*{a:1} | {b:1}) & c2
+ c2: (*{a:2} | {b:2}) & c1
+ `,
+ out: `<0>{` +
+ `a1: ((*0 | 1) & (<1>.a3 - <1>.a2)), ` +
+ `a3: 1, ` +
+ `a2: ((*0 | 1) & (<1>.a3 - <1>.a1)), ` +
+ `b1: (0 | 1), ` +
+ `b2: (0 | 1), ` +
+ `c1: (<2>{a: 1, b: 2} | <3>{a: 2, b: 1}), ` +
+ `c2: (<4>{a: 2, b: 1} | <5>{a: 1, b: 2})}`,
+ }, {
+ desc: "dont convert incomplete errors to non-incomplete",
+ in: `
+ import "strings"
+
+ n1: {min: <max, max: >min}
+ n2: -num
+ n3: +num
+ n4: num + num
+ n5: num - num
+ n6: num * num
+ n7: num / num
+
+ b1: !is
+
+ s1: "\(str)"
+ s2: strings.ContainsAny("dd")
+ s3: strings.ContainsAny(str, "dd")
+
+ str: string
+ num: <4
+ is: bool
+ `,
+ out: `<0>{` +
+ `n1: <1>{min: <<2>.max, max: ><2>.min}, ` +
+ `n2: -<3>.num, num: <4, ` +
+ `n3: +<3>.num, ` +
+ `n4: (<3>.num + <3>.num), ` +
+ `n5: (<3>.num - <3>.num), ` +
+ `n6: (<3>.num * <3>.num), ` +
+ `n7: (<3>.num / <3>.num), ` +
+ `b1: !<3>.is, ` +
+ `is: bool, ` +
+ `s1: ""+<3>.str+"", ` +
+ `str: string, ` +
+ `s2: strings.ContainsAny ("dd"), ` +
+ `s3: <4>.ContainsAny (<3>.str,"dd")}`,
+ }, {
+ desc: "len of incomplete types",
+ in: `
+ args: *[] | [...string]
+ v1: len(args)
+ v2: len([])
+ v3: len({})
+ v4: len({a: 3})
+ v5: len({a: 3} | {a: 4})
+ v6: len('sf' | 'dd')
+ v7: len([2] | *[1, 2])
+ v8: len([2] | [1, 2])
+ v9: len("😂")
+ v10: len("")
+ `,
+ out: `<0>{` +
+ `args: [], ` +
+ `v1: 0, ` +
+ `v2: 0, ` +
+ `v3: 0, ` +
+ `v4: 1, ` +
+ `v5: len ((<1>{a: 3} | <2>{a: 4})), ` +
+ `v6: len (('sf' | 'dd')), ` +
+ `v7: 2, ` +
+ `v8: len (([2] | [1,2])), ` +
+ `v9: 4, ` +
+ `v10: 0}`,
+ }, {
+ desc: "slice rewrite bug",
+ in: `
+ fn: {
+ arg: [...int] & [1]
+ out: arg[1:]
+ }
+ fn1: fn & {arg: [1]}
+ `,
+ out: `<0>{fn: <1>{arg: [1], out: []}, fn1: <2>{arg: [1], out: []}}`,
+ }, {
+ desc: "Issue #94",
+ in: `
+ foo: {
+ opt?: 1
+ "txt": 2
+ #def: 3
+ regular: 4
+ _hidden: 5
+ }
+ comp: { for k, v in foo { "\(k)": v } }
+ select: {
+ opt: foo.opt
+ "txt": foo.txt
+ #def: foo.#def
+ regular: foo.regular
+ _hidden: foo._hidden
+ }
+ index: {
+ opt: foo["opt"]
+ "txt": foo["txt"]
+ #def: foo["#def"]
+ regular: foo["regular"]
+ _hidden: foo["_hidden"]
+ }
+ `,
+ out: `<0>{` +
+ `foo: <1>{opt?: 1, txt: 2, #def: 3, regular: 4, _hidden: 5}, ` +
+ `comp: <2>{txt: 2, regular: 4}, ` +
+ `select: <3>{opt: <4>.foo.opt, txt: 2, #def: 3, regular: 4, _hidden: 5}, ` +
+ `index: <5>{opt: <4>.foo["opt"], txt: 2, #def: <4>.foo["#def"], regular: 4, _hidden: <4>.foo["_hidden"]}}`,
+ }, {
+ desc: "retain references with interleaved embedding",
+ in: `
+ a: d: {
+ #base
+ #info: {...}
+ Y: #info.X
+ }
+
+ #base: {
+ #info: {...}
+ }
+
+ a: [Name=string]: { #info: {
+ X: "foo"
+ }}
+ `,
+ out: `<0>{a: <1>{[]: <2>(Name: string)-><3>{#info: <4>C{X: "foo"}}, d: <5>C{#info: <6>C{X: "foo"}, Y: "foo"}}, #base: <7>C{#info: <8>{...}}}`,
+ }, {
+ desc: "comparison against bottom",
+ in: `
+ a: _|_ == _|_
+ b: err == 1&2 // not a literal error, so not allowed
+ c: err == _|_ // allowed
+ d: err != _|_ // allowed
+ e: err != 1&3
+ // z: err == err // TODO: should infer to be true?
+ f: ({a: 1} & {a: 2}) == _|_
+ g: ({a: 1} & {b: 2}) == _|_
+ h: _|_ == ({a: 1} & {a: 2})
+ i: _|_ == ({a: 1} & {b: 2})
+
+ err: 1 & 2
+ `,
+ out: `<0>{a: true, b: _|_((1 & 2):conflicting values 1 and 2), err: _|_((1 & 2):conflicting values 1 and 2), c: true, d: false, e: _|_((1 & 2):conflicting values 1 and 2), f: true, g: false, h: true, i: false}`,
+ }, {
+ desc: "or builtin should not fail on non-concrete empty list",
+ in: `
+ #Workflow: {
+ jobs: {
+ [jobID=string]: {
+ }
+ }
+ #JobID: or([ for k, _ in jobs { k } ])
+ }
+
+ foo: #Workflow & {
+ jobs: foo: {
+ }
+ }
+ `,
+ out: `<0>{#Workflow: <1>C{jobs: <2>{[]: <3>(jobID: string)-><4>C{}, }, #JobID: or ([ <5>for k, _ in <6>.jobs yield <5>.k ])}, foo: <7>C{jobs: <8>{[]: <9>(jobID: string)-><10>C{}, foo: <11>C{}}, #JobID: "foo"}}`,
+ }, {
+ desc: "Issue #153",
+ in: `
+ Foo: {
+ listOfCloseds: [...#Closed]
+ }
+
+ #Closed: {
+ a: int | *0
+ }
+
+ Junk: {
+ b: 2
+ }
+
+ Foo & {
+ listOfCloseds: [{
+ for k, v in Junk {
+ "\(k)": v
+ }
+ }]
+ }
+ `,
+ out: `<0>{<1>{listOfCloseds: [_|_(<2>.v:field "b" not allowed in closed struct)]}, Foo: <3>{listOfCloseds: []}, #Closed: <4>C{a: 0}, Junk: <5>{b: 2}}`,
+ }, {
+ desc: "label and field aliases",
+ in: `
+ p: [ID=string]: { name: ID }
+ A="foo=bar": "str"
+ a: A
+ B=bb: 4
+ b1: B
+ b1: bb
+ C="\(a)": 5
+ c: C
+ `,
+ out: `<0>{` +
+ `p: <1>{[]: <2>(ID: string)-><3>{name: <2>.ID}, }, ` +
+ `"foo=bar": "str", ` +
+ `a: "str", ` +
+ `bb: 4, ` +
+ `b1: 4, ` +
+ `c: 5, ` +
+ `str: 5}`,
+ }, {
+ desc: "optionals with label filters",
+ in: `
+ #JobID: =~"^[a-zA-Z]*$"
+ #Job: {
+ name: string
+ cmd: string
+ }
+ #Jobs: {
+ [#JobID]: #Job
+ [=~"Test$"]: name: =~"^test" // Must work without ...
+ }
+
+ jobs: foo: name: "allGood"
+ jobs: foo: name: "allGood"
+
+ jobs1: #Jobs
+ jobs1: foo1: {} // faulty
+
+ jobs2: #Jobs
+ jobs2: fooTest: name: "badName" // faulty
+
+ jobs3: #Jobs
+ jobs3: [string]: #Job
+ jobs3: fooTest1: name: "badName" // faulty
+ `,
+ out: `<0>{` +
+ `#JobID: =~"^[a-zA-Z]*$", ` +
+ `#Job: <1>C{name: string, cmd: string}, ` +
+ `#Jobs: <2>C{[=~"^[a-zA-Z]*$"]: <3>(_: string)-><4>.#Job, [=~"Test$"]: <5>(_: string)-><6>C{name: =~"^test"}, }, ` +
+ `jobs: <7>{foo: <8>{name: "allGood"}}, ` +
+ `jobs1: _|_(<9>{}:field "foo1" not allowed in closed struct), ` +
+ `jobs2: <10>C{[=~"^[a-zA-Z]*$"]: <11>(_: string)-><4>.#Job, [=~"Test$"]: <12>(_: string)-><13>C{name: =~"^test"}, fooTest: _|_(string:field "cmd" not allowed in closed struct)}, ` +
+ `jobs3: _|_(<14>{name: "badName"}:field "fooTest1" not allowed in closed struct)}`,
+ }, {
+ desc: "optionals in open structs",
+ in: `
+ A: {
+ [=~"^[a-s]*$"]: int
+ }
+ B: {
+ [=~"^[m-z]*$"]: int
+ }
+ #C: {A & B}
+ c: #C & { aaa: 3 }
+ `,
+ out: `<0>{A: <1>{[=~"^[a-s]*$"]: <2>(_: string)->int, }, B: <3>{[=~"^[m-z]*$"]: <4>(_: string)->int, }, #C: <5>C{[=~"^[a-s]*$"]: <6>(_: string)->int, [=~"^[m-z]*$"]: <7>(_: string)->int, }, c: <8>C{[=~"^[a-s]*$"]: <9>(_: string)->int, [=~"^[m-z]*$"]: <10>(_: string)->int, aaa: 3}}`,
+ }, {
+ desc: "conjunction of optional sets",
+ in: `
+ #A: {
+ [=~"^[a-s]*$"]: int
+ }
+ #B: {
+ [=~"^[m-z]*$"]: int
+ }
+
+ #C: #A & #B
+ c: #C & { aaa: 3 }
+
+ #D: {#A & #B}
+ d: #D & { aaa: 3 }
+ `,
+ out: `<0>{` +
+ `#A: <1>C{[=~"^[a-s]*$"]: <2>(_: string)->int, }, ` +
+ `#B: <3>C{[=~"^[m-z]*$"]: <4>(_: string)->int, }, ` +
+ `#C: <5>C{(C{[=~"^[a-s]*$"]: <6>(_: string)->int} & C{[=~"^[m-z]*$"]: <7>(_: string)->int}), }, ` +
+ `c: _|_(3:field "aaa" not allowed in closed struct), ` +
+ `#D: <8>C{(C{[=~"^[a-s]*$"]: <9>(_: string)->int} & C{[=~"^[m-z]*$"]: <10>(_: string)->int}), }, ` +
+ `d: _|_(3:field "aaa" not allowed in closed struct)` +
+ `}`,
+ }, {
+ desc: "continue recursive closing for optionals",
+ in: `
+ #S: {
+ [string]: { a: int }
+ }
+ a: #S & {
+ v: { b: int }
+ }
+ `,
+ out: `<0>{#S: <1>{[]: <2>(_: string)-><3>C{a: int}, }, a: <4>{[]: <5>(_: string)-><6>C{a: int}, v: _|_(int:field "b" not allowed in closed struct)}}`,
+ }, {
+ desc: "augment closed optionals",
+ in: `
+ #A: {
+ [=~"^[a-s]*$"]: int
+ }
+ #B: {
+ [=~"^[m-z]*?"]: int
+ }
+ #C: {
+ #A & #B
+ [=~"^Q*$"]: int
+ }
+ c: #C & { QQ: 3 }
+ #D: {
+ #A
+ #B
+ }
+ d: #D & { aaa: 4 }
+ `,
+ out: `<0>{` +
+ `#A: <1>C{[=~"^[a-s]*$"]: <2>(_: string)->int, }, ` +
+ `#B: <3>C{[=~"^[m-z]*?"]: <4>(_: string)->int, }, ` +
+ `#C: <5>C{C{[=~"^Q*$"]: <6>(_: string)->int}, C{(C{[=~"^[a-s]*$"]: <7>(_: string)->int} & C{[=~"^[m-z]*?"]: <8>(_: string)->int})}, }, ` +
+ `c: <9>C{C{[=~"^Q*$"]: <10>(_: string)->int}, C{(C{[=~"^[a-s]*$"]: <11>(_: string)->int} & C{[=~"^[m-z]*?"]: <12>(_: string)->int})}, QQ: 3}, ` +
+ `#D: <13>C{[=~"^[a-s]*$"]: <14>(_: string)->int, [=~"^[m-z]*?"]: <15>(_: string)->int, }, ` +
+ `d: <16>C{[=~"^[a-s]*$"]: <17>(_: string)->int, [=~"^[m-z]*?"]: <18>(_: string)->int, aaa: 4}}`,
+ }, {
+ in: `
+ #Task: {
+ {
+ op: "pull"
+ tag: *"latest" | string
+ refToTag: tag
+ tagExpr: tag + "dd"
+ tagInString: "\(tag)"
+ } | {
+ op: "scratch"
+ }
+ }
+
+ foo: #Task & {"op": "pull"}
+ `,
+ out: `<0>{#Task: (<1>C{op: "pull", tag: (*"latest" | string), refToTag: <1>.tag, tagExpr: (<1>.tag + "dd"), tagInString: ""+<1>.tag+""} | <2>C{op: "scratch"}), foo: <3>C{op: "pull", tag: "latest", refToTag: "latest", tagExpr: "latestdd", tagInString: "latest"}}`,
+ }, {
+ in: `
+ t: {
+ #ok: *true | bool
+ if #ok {
+ x: int
+ }
+ }
+ s: t & {
+ #ok: false
+ }`,
+ out: `<0>{t: <1>{x: int, #ok: true}, s: <2>{#ok: false}}`,
+ }, {
+ desc: "cross-dependent comprehension",
+ // TODO(eval): fix: c should ultimately be allowed the struct. Current
+ // semantics require, however, that generated fields are not available
+ // for evaluation. This, however, does not have to hold, for closedness
+ // checks and allowing this would be more intuitive.
+ // Until that time, ensure that the behavior is at commutative.
+ in: `
+ #a: {
+ if b {
+ c: 4
+ }
+ b: bool
+ }
+ x: (#a & { b: true}) & {c: 4 }
+ y: x
+ `,
+ // c should not be allowed, as it would break commutativiy.
+ // See comments above.
+ out: `<0>{x: _|_(4:field "c" not allowed in closed struct), y: _|_(4:field "c" not allowed in closed struct), #a: <1>C{b: bool if <2>.b yield <3>C{c: 4}}}`,
+ }, {
+ desc: "optional expanded before lookup",
+ in: `
+ test: [ID=_]: {
+ name: ID
+ }
+
+ test: A: {
+ field1: "1"
+ field2: "2"
+ }
+
+ B: test.A & {}
+ `,
+ out: `<0>{test: <1>{[]: <2>(ID: string)-><3>{name: <2>.ID}, A: <4>{name: "A", field1: "1", field2: "2"}}, B: <5>{name: "A", field1: "1", field2: "2"}}`,
+ }, {
+ desc: "Issue #178",
+ in: `
+ import "encoding/csv"
+ import "encoding/hex"
+
+ foo: csv.Decode(data)
+ data: bytes
+
+ len: int
+ bar: hex.EncodedLen(len)
+ `,
+ out: `<0>{foo: <1>.Decode (<2>.data), data: bytes, len: int, bar: <3>.EncodedLen (<2>.len)}`,
+ }, {
+ // This resulted in an issue in an older version. Prevent regression.
+ desc: "comprehension and skipped field",
+ in: `
+ for key, value in {x: v: 1} {
+ "\(key)": {
+ v: *{for pod, _ in value.v {}} | {"\(value.v)": 2}
+ _p: 3
+ }
+ }
+ `,
+ out: `<0>{x: <1>{v: <2>{"1": 2}, _p: 3}}`,
+ }, {
+ desc: "non-structural direct cycles",
+ in: `
+ c1: {bar: baz: 2} & c1.bar
+ c2: {bar: 1} & c2.bar
+ `,
+ out: `<0>{` +
+ `c1: <1>{bar: <2>{baz: 2}, baz: 2}, ` +
+ `c2: _|_(conflicting values {bar: 1} and 1 (mismatched types struct and int))}`,
+ }, {
+ desc: "dont bind to string labels",
+ in: `
+ x: 1
+ y: {
+ "x": 2
+ z: x
+ }
+ `,
+ out: `<0>{x: 1, y: <1>{x: 2, z: 1}}`,
+ }, {
+ desc: "dont pass incomplete values to builtins",
+ in: `
+ import "encoding/json"
+
+ input: string
+ foo: json.Marshal(input)
+ `,
+ out: `<0>{input: string, foo: <1>.Marshal (<2>.input)}`,
+ }, {
+ desc: "alias reuse in nested scope",
+ in: `
+ #Foo: {
+ let X = or([ for k, _ in {} { k } ])
+ connection: [X]: X
+ }
+ #A: {
+ foo: "key"
+ let X = foo
+ a: foo: [X]: X
+ }
+ #B: {
+ foo: string
+ let X = foo
+ a: foo: [X]: X
+ }
+ b: #B & { foo: "key" }
+ `,
+ out: `<0>{` +
+ `#Foo: <1>C{connection: <2>C{[or ([ <3>for k, _ in <4>{} yield <3>.k ])]: <5>(_: string)->or ([ <3>for k, _ in <4>{} yield <3>.k ]), }}, ` +
+ `#A: <6>C{foo: "key", a: <7>C{foo: <8>C{["key"]: <9>(_: string)-><10>.foo, }}}, ` +
+ `#B: <11>C{foo: string, a: <12>C{foo: <13>C{[string]: <14>(_: string)-><15>.foo, }}}, ` +
+ `b: <16>C{foo: "key", a: <17>C{foo: <18>C{["key"]: <19>(_: string)-><20>.foo, }}}` +
+ `}`,
+ }, {
+ desc: "json Marshaling detects incomplete",
+ in: `
+ import "encoding/json"
+ a: json.Marshal({ a: string} )
+
+ foo: { a: 3, b: foo.c }
+ b: json.Marshal(foo)
+ `,
+ out: `<0>{` +
+ `a: <1>.Marshal (<2>{a: string}), ` +
+ `foo: <3>{a: 3, b: <4>.foo.c}, ` +
+ `b: <1>.Marshal (<4>.foo)}`,
+ }, {
+ desc: "detectIncompleteYAML",
+ in: `
+ package foobar
+
+ import yaml "encoding/yaml"
+
+ #Spec: {
+ _vars: {something: string}
+ data: {
+ #foo: {
+ use: _vars.something
+ }
+ baz: yaml.Marshal(_vars.something)
+ foobar: yaml.Marshal(#foo)
+ }
+ }
+ Val: #Spec & {
+ _vars: something: "var-string"
+ }
+ `,
+ out: `<0>{#Spec: <1>C{_vars: <2>C{something: string}, data: <3>C{#foo: <4>C{use: string}, baz: <5>.Marshal (<6>._vars.something), foobar: <5>.Marshal (<7>.#foo)}}, Val: <8>C{_vars: <9>C{something: "var-string"}, data: <10>C{#foo: <11>C{use: "var-string"}, baz: "var-string\n", foobar: "use: var-string\n"}}}`,
+ }, {
+ desc: "detectIncompleteJSON",
+ in: `
+ package foobar
+
+ import "encoding/json"
+
+ #Spec: {
+ _vars: {something: string}
+ data: {
+ #foo: {
+ use: _vars.something
+ }
+ baz: json.Marshal(_vars.something)
+ foobar: json.Marshal(#foo)
+ }
+ }
+ Val: #Spec & {
+ _vars: something: "var-string"
+ }
+ `,
+ out: `<0>{#Spec: <1>C{_vars: <2>C{something: string}, data: <3>C{#foo: <4>C{use: string}, baz: <5>.Marshal (<6>._vars.something), foobar: <5>.Marshal (<7>.#foo)}}, Val: <8>C{_vars: <9>C{something: "var-string"}, data: <10>C{#foo: <11>C{use: "var-string"}, baz: "\"var-string\"", foobar: "{\"use\":\"var-string\"}"}}}`,
+ }, {
+ desc: "issue312",
+ in: `
+ for x in [1] {
+ *close({}) | { [_]: null }
+ }
+ `,
+ out: `<0>{ <1>for _, x in [1] yield <2>{}, (*close (<3>{}) | <4>{[]: <5>(_: string)->null, })}`,
+ }, {
+ // TODO(eval): note that this behavior is incompatible with allowing
+ // non-struct as emit values. If we ever want to do this, we need to
+ // do it soon.
+ desc: "issue312",
+ in: `
+ y: *1 | {a: 2}
+ for x in [1] { y }
+ `,
+ out: `<0>{y: 1, a: 2}`,
+ }, {
+ desc: "issue318",
+ in: `
+ #T: {
+ arg: x: string
+ out1: "\(arg.x) \(arg.y)"
+ out2: "\(arg.y)"
+ vx: arg.x
+ vy: arg.y
+ }
+ `,
+ out: `<0>{` +
+ `#T: <1>C{` +
+ `arg: <2>C{x: string}, ` +
+ `out1: _|_(<3>.arg.y:undefined field "y"), ` +
+ `out2: _|_(<3>.arg.y:undefined field "y"), ` +
+ `vx: string, ` +
+ `vy: _|_(<3>.arg.y:undefined field "y")}}`,
+ }, {
+ desc: "issue314",
+ in: `
+ import (
+ "text/template"
+ "encoding/yaml"
+ "encoding/json"
+ )
+
+ x: {
+ s: "myname"
+ #T
+ }
+
+ #T: {
+ s: string
+ out: template.Execute("{{.s}}", {
+ "s": s
+ })
+ }
+
+ #V: {
+ s: string
+ out: json.Marshal({"s": s})
+ }
+
+ #U: {
+ s: string
+ out: yaml.Marshal({"s": s})
+ }`,
+ out: `<0>{` +
+ `x: <1>C{s: "myname", out: "myname"}, ` +
+ `#T: <2>C{s: string, out: <3>.Execute ("{{.s}}",<4>C{s: <5>.s})}, ` +
+ `#V: <6>C{s: string, out: <7>.Marshal (<8>C{s: <9>.s})}, ` +
+ `#U: <10>C{s: string, out: <11>.Marshal (<12>C{s: <13>.s})}}`,
+ }}
+ rewriteHelper(t, testCases, evalFull)
+}
+
+func TestX(t *testing.T) {
+ // Don't remove. For debugging.
+ in := `
+ `
+
+ if strings.TrimSpace(in) == "" {
+ t.Skip()
+ }
+ rewriteHelper(t, []testCase{{in: in}}, evalFull)
+}
diff --git a/internal/legacy/cue/types.go b/internal/legacy/cue/types.go
new file mode 100644
index 0000000..a5deb07
--- /dev/null
+++ b/internal/legacy/cue/types.go
@@ -0,0 +1,2247 @@
+// 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 cue
+
+import (
+ "bytes"
+ "encoding/json"
+ "fmt"
+ "io"
+ "math"
+ "math/big"
+ "strconv"
+ "strings"
+
+ "github.com/cockroachdb/apd/v2"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/token"
+ "cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/adt"
+)
+
+// Kind determines the underlying type of a Value.
+type Kind = adt.Kind
+
+const BottomKind Kind = 0
+
+const (
+ // NullKind indicates a null value.
+ NullKind Kind = adt.NullKind
+
+ // BoolKind indicates a boolean value.
+ BoolKind = adt.BoolKind
+
+ // IntKind represents an integral number.
+ IntKind = adt.IntKind
+
+ // FloatKind represents a decimal float point number that cannot be
+ // converted to an integer. The underlying number may still be integral,
+ // but resulting from an operation that enforces the float type.
+ FloatKind = adt.FloatKind
+
+ // StringKind indicates any kind of string.
+ StringKind = adt.StringKind
+
+ // BytesKind is a blob of data.
+ BytesKind = adt.BytesKind
+
+ // StructKind is a kev-value map.
+ StructKind = adt.StructKind
+
+ // ListKind indicates a list of values.
+ ListKind = adt.ListKind
+
+ // _numberKind is used as a implementation detail inside
+ // Kind.String to indicate NumberKind.
+
+ // NumberKind represents any kind of number.
+ NumberKind = IntKind | FloatKind
+
+ TopKind = Kind(adt.TopKind)
+)
+
+// An structValue represents a JSON object.
+//
+// TODO: remove
+type structValue struct {
+ ctx *context
+ path *valueData
+ obj *structLit
+ Arcs arcs
+}
+
+// Len reports the number of fields in this struct.
+func (o *structValue) Len() int {
+ if o.obj == nil {
+ return 0
+ }
+ return len(o.Arcs)
+}
+
+// At reports the key and value of the ith field, i < o.Len().
+func (o *structValue) At(i int) (key string, v Value) {
+ a := o.Arcs[i]
+ v = newChildValue(o, i)
+ return o.ctx.LabelStr(a.Label), v
+}
+
+// Lookup reports the field for the given key. The returned Value is invalid
+// if it does not exist.
+func (o *structValue) Lookup(key string) Value {
+ f := o.ctx.StrLabel(key)
+ i := 0
+ len := o.Len()
+ for ; i < len; i++ {
+ if o.Arcs[i].Label == f {
+ break
+ }
+ }
+ if i == len {
+ // TODO: better message.
+ ctx := o.ctx
+ x := ctx.mkErr(o.obj, codeNotExist, "value %q not found", key)
+ v := x.evalPartial(ctx)
+ return Value{ctx.index, &valueData{o.path.parent, 0, arc{Label: o.path.Label, Value: v, v: x}}}
+ }
+ return newChildValue(o, i)
+}
+
+// MarshalJSON returns a valid JSON encoding or reports an error if any of the
+// fields is invalid.
+func (o *structValue) marshalJSON() (b []byte, err errors.Error) {
+ b = append(b, '{')
+ n := o.Len()
+ for i := 0; i < n; i++ {
+ k, v := o.At(i)
+ s, err := json.Marshal(k)
+ if err != nil {
+ return nil, unwrapJSONError(err)
+ }
+ b = append(b, s...)
+ b = append(b, ':')
+ bb, err := json.Marshal(v)
+ if err != nil {
+ return nil, unwrapJSONError(err)
+ }
+ b = append(b, bb...)
+ if i < n-1 {
+ b = append(b, ',')
+ }
+ }
+ b = append(b, '}')
+ return b, nil
+}
+
+var _ errors.Error = &marshalError{}
+
+type marshalError struct {
+ err errors.Error
+ b *bottom
+}
+
+func toMarshalErr(v Value, b *bottom) error {
+ return &marshalError{v.toErr(b), b}
+}
+
+func marshalErrf(v Value, src source, code errCode, msg string, args ...interface{}) error {
+ arguments := append([]interface{}{code, msg}, args...)
+ b := v.idx.mkErr(src, arguments...)
+ return toMarshalErr(v, b)
+}
+
+func (e *marshalError) Error() string {
+ return fmt.Sprintf("cue: marshal error: %v", e.err)
+}
+
+func (e *marshalError) Path() []string { return e.err.Path() }
+func (e *marshalError) Msg() (string, []interface{}) { return e.err.Msg() }
+func (e *marshalError) Position() token.Pos { return e.err.Position() }
+func (e *marshalError) InputPositions() []token.Pos {
+ return e.err.InputPositions()
+}
+
+func unwrapJSONError(err error) errors.Error {
+ switch x := err.(type) {
+ case *json.MarshalerError:
+ return unwrapJSONError(x.Err)
+ case *marshalError:
+ return x
+ case errors.Error:
+ return &marshalError{x, nil}
+ default:
+ return &marshalError{errors.Wrapf(err, token.NoPos, "json error"), nil}
+ }
+}
+
+// An Iterator iterates over values.
+//
+type Iterator struct {
+ val Value
+ ctx *context
+ iter iterAtter
+ len int
+ p int
+ cur Value
+ f label
+}
+
+// Next advances the iterator to the next value and reports whether there was
+// any. It must be called before the first call to Value or Key.
+func (i *Iterator) Next() bool {
+ if i.p >= i.len {
+ i.cur = Value{}
+ return false
+ }
+ arc := i.iter.iterAt(i.ctx, i.p)
+ i.cur = i.val.makeChild(i.ctx, uint32(i.p), arc)
+ i.f = arc.Label
+ i.p++
+ return true
+}
+
+// Value returns the current value in the list. It will panic if Next advanced
+// past the last entry.
+func (i *Iterator) Value() Value {
+ return i.cur
+}
+
+// Label reports the label of the value if i iterates over struct fields and
+// "" otherwise.
+func (i *Iterator) Label() string {
+ if i.f == 0 {
+ return ""
+ }
+ return i.ctx.LabelStr(i.f)
+}
+
+// IsHidden reports if a field is hidden from the data model.
+func (i *Iterator) IsHidden() bool {
+ return i.f.IsHidden()
+}
+
+// IsOptional reports if a field is optional.
+func (i *Iterator) IsOptional() bool {
+ return i.cur.v.arc.optional
+}
+
+// IsDefinition reports if a field is a definition.
+func (i *Iterator) IsDefinition() bool {
+ return i.cur.v.arc.definition
+}
+
+// marshalJSON iterates over the list and generates JSON output. HasNext
+// will return false after this operation.
+func marshalList(l *Iterator) (b []byte, err errors.Error) {
+ b = append(b, '[')
+ if l.Next() {
+ for i := 0; ; i++ {
+ x, err := json.Marshal(l.Value())
+ if err != nil {
+ return nil, unwrapJSONError(err)
+ }
+ b = append(b, x...)
+ if !l.Next() {
+ break
+ }
+ b = append(b, ',')
+ }
+ }
+ b = append(b, ']')
+ return b, nil
+}
+
+func (v Value) getNum(k kind) (*numLit, errors.Error) {
+ v, _ = v.Default()
+ if err := v.checkKind(v.ctx(), k); err != nil {
+ return nil, v.toErr(err)
+ }
+ n, _ := v.v.Value.(*numLit)
+ return n, nil
+}
+
+// MantExp breaks x into its mantissa and exponent components and returns the
+// exponent. If a non-nil mant argument is provided its value is set to the
+// mantissa of x. The components satisfy x == mant × 10**exp. It returns an
+// error if v is not a number.
+//
+// The components are not normalized. For instance, 2.00 is represented mant ==
+// 200 and exp == -2. Calling MantExp with a nil argument is an efficient way to
+// get the exponent of the receiver.
+func (v Value) MantExp(mant *big.Int) (exp int, err error) {
+ n, err := v.getNum(numKind)
+ if err != nil {
+ return 0, err
+ }
+ if n.X.Form != 0 {
+ return 0, ErrInfinite
+ }
+ if mant != nil {
+ mant.Set(&n.X.Coeff)
+ if n.X.Negative {
+ mant.Neg(mant)
+ }
+ }
+ return int(n.X.Exponent), nil
+}
+
+// AppendInt appends the string representation of x in the given base to buf and
+// returns the extended buffer, or an error if the underlying number was not
+// an integer.
+func (v Value) AppendInt(buf []byte, base int) ([]byte, error) {
+ i, err := v.Int(nil)
+ if err != nil {
+ return nil, err
+ }
+ return i.Append(buf, base), nil
+}
+
+// AppendFloat appends to buf the string form of the floating-point number x.
+// It returns an error if v is not a number.
+func (v Value) AppendFloat(buf []byte, fmt byte, prec int) ([]byte, error) {
+ n, err := v.getNum(numKind)
+ if err != nil {
+ return nil, err
+ }
+ ctx := apd.BaseContext
+ nd := int(apd.NumDigits(&n.X.Coeff)) + int(n.X.Exponent)
+ if n.X.Form == apd.Infinite {
+ if n.X.Negative {
+ buf = append(buf, '-')
+ }
+ return append(buf, string('∞')...), nil
+ }
+ if fmt == 'f' && nd > 0 {
+ ctx.Precision = uint32(nd + prec)
+ } else {
+ ctx.Precision = uint32(prec)
+ }
+ var d apd.Decimal
+ ctx.Round(&d, &n.X)
+ return d.Append(buf, fmt), nil
+}
+
+var (
+ // ErrBelow indicates that a value was rounded down in a conversion.
+ ErrBelow = errors.New("value was rounded down")
+
+ // ErrAbove indicates that a value was rounded up in a conversion.
+ ErrAbove = errors.New("value was rounded up")
+
+ // ErrInfinite indicates that a value is infinite.
+ ErrInfinite = errors.New("infinite")
+)
+
+// Int converts the underlying integral number to an big.Int. It reports an
+// error if the underlying value is not an integer type. If a non-nil *Int
+// argument z is provided, Int stores the result in z instead of allocating a
+// new Int.
+func (v Value) Int(z *big.Int) (*big.Int, error) {
+ n, err := v.getNum(intKind)
+ if err != nil {
+ return nil, err
+ }
+ if z == nil {
+ z = &big.Int{}
+ }
+ if n.X.Exponent != 0 {
+ panic("cue: exponent should always be nil for integer types")
+ }
+ z.Set(&n.X.Coeff)
+ if n.X.Negative {
+ z.Neg(z)
+ }
+ return z, nil
+}
+
+// Int64 converts the underlying integral number to int64. It reports an
+// error if the underlying value is not an integer type or cannot be represented
+// as an int64. The result is (math.MinInt64, ErrAbove) for x < math.MinInt64,
+// and (math.MaxInt64, ErrBelow) for x > math.MaxInt64.
+func (v Value) Int64() (int64, error) {
+ n, err := v.getNum(intKind)
+ if err != nil {
+ return 0, err
+ }
+ if !n.X.Coeff.IsInt64() {
+ if n.X.Negative {
+ return math.MinInt64, ErrAbove
+ }
+ return math.MaxInt64, ErrBelow
+ }
+ i := n.X.Coeff.Int64()
+ if n.X.Negative {
+ i = -i
+ }
+ return i, nil
+}
+
+// Uint64 converts the underlying integral number to uint64. It reports an
+// error if the underlying value is not an integer type or cannot be represented
+// as a uint64. The result is (0, ErrAbove) for x < 0, and
+// (math.MaxUint64, ErrBelow) for x > math.MaxUint64.
+func (v Value) Uint64() (uint64, error) {
+ n, err := v.getNum(intKind)
+ if err != nil {
+ return 0, err
+ }
+ if n.X.Negative {
+ return 0, ErrAbove
+ }
+ if !n.X.Coeff.IsUint64() {
+ return math.MaxUint64, ErrBelow
+ }
+ i := n.X.Coeff.Uint64()
+ return i, nil
+}
+
+// trimZeros trims 0's for better JSON respresentations.
+func trimZeros(s string) string {
+ n1 := len(s)
+ s2 := strings.TrimRight(s, "0")
+ n2 := len(s2)
+ if p := strings.IndexByte(s2, '.'); p != -1 {
+ if p == n2-1 {
+ return s[:len(s2)+1]
+ }
+ return s2
+ }
+ if n1-n2 <= 4 {
+ return s
+ }
+ return fmt.Sprint(s2, "e+", n1-n2)
+}
+
+var (
+ smallestPosFloat64 *apd.Decimal
+ smallestNegFloat64 *apd.Decimal
+ maxPosFloat64 *apd.Decimal
+ maxNegFloat64 *apd.Decimal
+)
+
+func init() {
+ const (
+ // math.SmallestNonzeroFloat64: 1 / 2**(1023 - 1 + 52)
+ smallest = "4.940656458412465441765687928682213723651e-324"
+ // math.MaxFloat64: 2**1023 * (2**53 - 1) / 2**52
+ max = "1.797693134862315708145274237317043567981e+308"
+ )
+ ctx := apd.BaseContext
+ ctx.Precision = 40
+
+ var err error
+ smallestPosFloat64, _, err = ctx.NewFromString(smallest)
+ if err != nil {
+ panic(err)
+ }
+ smallestNegFloat64, _, err = ctx.NewFromString("-" + smallest)
+ if err != nil {
+ panic(err)
+ }
+ maxPosFloat64, _, err = ctx.NewFromString(max)
+ if err != nil {
+ panic(err)
+ }
+ maxNegFloat64, _, err = ctx.NewFromString("-" + max)
+ if err != nil {
+ panic(err)
+ }
+}
+
+// Float64 returns the float64 value nearest to x. It reports an error if v is
+// not a number. If x is too small to be represented by a float64 (|x| <
+// math.SmallestNonzeroFloat64), the result is (0, ErrBelow) or (-0, ErrAbove),
+// respectively, depending on the sign of x. If x is too large to be represented
+// by a float64 (|x| > math.MaxFloat64), the result is (+Inf, ErrAbove) or
+// (-Inf, ErrBelow), depending on the sign of x.
+func (v Value) Float64() (float64, error) {
+ n, err := v.getNum(numKind)
+ if err != nil {
+ return 0, err
+ }
+ if n.X.Negative {
+ if n.X.Cmp(smallestNegFloat64) == 1 {
+ return -0, ErrAbove
+ }
+ if n.X.Cmp(maxNegFloat64) == -1 {
+ return math.Inf(-1), ErrBelow
+ }
+ } else {
+ if n.X.Cmp(smallestPosFloat64) == -1 {
+ return 0, ErrBelow
+ }
+ if n.X.Cmp(maxPosFloat64) == 1 {
+ return math.Inf(1), ErrAbove
+ }
+ }
+ f, _ := n.X.Float64()
+ return f, nil
+}
+
+type valueData struct {
+ parent *valueData
+ index uint32
+ arc
+}
+
+// path returns the path of the value.
+func (v *valueData) appendPath(a []string, idx *index) ([]string, kind) {
+ var k kind
+ if v.parent != nil {
+ a, k = v.parent.appendPath(a, idx)
+ }
+ switch k {
+ case listKind:
+ a = append(a, strconv.FormatInt(int64(v.index), 10))
+ case structKind:
+ label := idx.LabelStr(v.arc.Label)
+ if f := v.arc.Label; !f.IsDef() && !f.IsHidden() {
+ if !ast.IsValidIdent(label) {
+ label = strconv.Quote(label)
+ }
+ }
+ a = append(a, label)
+ }
+ return a, v.arc.Value.Kind()
+}
+
+// Value holds any value, which may be a Boolean, Error, List, Null, Number,
+// Struct, or String.
+type Value struct {
+ idx *index
+ v *valueData
+}
+
+func newErrValue(v Value, b *bottom) Value {
+ ctx := v.ctx()
+ p := v.v
+ if p == nil {
+ return newValueRoot(ctx, b)
+ }
+ return Value{
+ ctx.index,
+ &valueData{p.parent, p.index, arc{
+ Label: p.arc.Label,
+ Value: b,
+ v: b,
+ }},
+ }
+}
+
+func newValueRoot(ctx *context, x value) Value {
+ v := x.evalPartial(ctx)
+ return Value{ctx.index, &valueData{nil, 0, arc{Value: v, v: x}}}
+}
+
+func newChildValue(obj *structValue, i int) Value {
+ a := obj.Arcs[i]
+ for j, b := range obj.obj.Arcs {
+ if b.Label == a.Label {
+ a = obj.obj.iterAt(obj.ctx, j)
+ // TODO: adding more technical debt here. The evaluator should be
+ // rewritten.
+ x := obj.obj
+ ctx := obj.ctx
+ if x.optionals != nil {
+ name := ctx.LabelStr(x.Arcs[i].Label)
+ arg := &stringLit{x.baseValue, name, nil}
+
+ val, _ := x.optionals.constraint(ctx, arg)
+ if val != nil {
+ a.v = mkBin(ctx, x.Pos(), opUnify, a.v, val)
+ }
+ }
+ break
+ }
+ }
+
+ return Value{obj.ctx.index, &valueData{obj.path, uint32(i), a}}
+}
+
+// Dereference reports the value v refers to if v is a reference or v itself
+// otherwise.
+func Dereference(v Value) Value {
+ if v.v == nil {
+ return v
+ }
+
+ ctx := v.ctx()
+ a, n := appendPath(ctx, make([]label, 0, 3), v.v.v)
+
+ if n == nil {
+ return v
+
+ }
+
+ p := locateNode(v.v, n)
+
+ if p == nil {
+
+ imp := ctx.getImportFromNode(n.node)
+ if imp == nil {
+ // TODO(eval): embedded structs are currently represented at the
+ // same level as the enclosing struct. This means that the parent
+ // of an embedded struct skips the struct in which it is embedded.
+ // Treat embedded structs as "anonymous" fields.
+ // See TestPathCorrection.
+ return v
+ }
+ p = &valueData{arc: arc{v: imp.rootValue, Value: imp.rootStruct}}
+ }
+
+ cached := p.Value
+ if cached == nil {
+ cached = p.v.evalPartial(ctx)
+ }
+ s := cached.(*structLit)
+ for _, f := range a {
+ a := s.Lookup(ctx, f)
+ if a.v == nil {
+ return Value{}
+ }
+ p = &valueData{parent: p, arc: a} // index
+ s, _ = a.Value.(*structLit)
+ }
+
+ v = Value{v.idx, p}
+ return v
+}
+
+func appendPath(ctx *context, a []label, v value) (path []label, n *nodeRef) {
+ switch x := v.(type) {
+ case *selectorExpr:
+ a, n = appendPath(ctx, a, x.X)
+ if n == nil {
+ return nil, nil
+ }
+
+ a = append(a, x.Sel)
+
+ case *indexExpr:
+ e := x.Index.evalPartial(ctx)
+ s, ok := e.(*stringLit)
+ if !ok {
+ return nil, nil
+ }
+
+ a, n = appendPath(ctx, a, x.X)
+ if n == nil {
+ return nil, nil
+ }
+
+ a = append(a, ctx.Label(s.Str, false))
+
+ case *nodeRef:
+ n = x
+ }
+ return a, n
+}
+
+func remakeValue(base Value, v value) Value {
+ p := base.v
+ if n, ok := v.(*nodeRef); ok {
+ if q := locateNode(p, n); q != nil {
+ p = q
+ }
+ }
+ path := *p
+ path.v = v
+ path.Value = v.evalPartial(base.ctx())
+ return Value{base.idx, &path}
+}
+
+func locateNode(p *valueData, n *nodeRef) *valueData {
+ // the parent must exist.
+ for ; p != nil && p.Value != n.node.(value); p = p.parent {
+ }
+ return p
+}
+
+func (v Value) ctx() *context {
+ return v.idx.newContext()
+}
+
+func (v Value) makeChild(ctx *context, i uint32, a arc) Value {
+ return Value{v.idx, &valueData{v.v, i, a}}
+}
+
+func (v Value) makeElem(x value) Value {
+ v, e := v.evalFull(x)
+ return Value{v.idx, &valueData{v.v, 0, arc{
+ optional: true,
+ v: x,
+ Value: e,
+ }}}
+}
+
+func (v Value) eval(ctx *context) evaluated {
+ if v.v == nil || v.v.Value == nil {
+ panic("undefined value")
+ }
+ return ctx.manifest(v.v.Value)
+}
+
+func (v Value) evalFull(u value) (Value, evaluated) {
+ ctx := v.ctx()
+ x := u.evalPartial(ctx)
+ if st, ok := x.(*structLit); ok {
+ var err *bottom
+ x, err = st.expandFields(ctx)
+ if err != nil {
+ x = err
+ }
+ if x != st {
+ p := *v.v
+ p.Value = x
+ v.v = &p
+ }
+ }
+ return v, x
+}
+
+// Eval resolves the references of a value and returns the result.
+// This method is not necessary to obtain concrete values.
+func (v Value) Eval() Value {
+ if v.v == nil {
+ return v
+ }
+ return remakeValue(v.evalFull(v.v.v))
+}
+
+// Default reports the default value and whether it existed. It returns the
+// normal value if there is no default.
+func (v Value) Default() (Value, bool) {
+ if v.v == nil {
+ return v, false
+ }
+ v, u := v.evalFull(v.v.v)
+ x := v.ctx().manifest(u)
+ if x != u {
+ return remakeValue(v, x), true
+ }
+ return v, false
+}
+
+// Label reports he label used to obtain this value from the enclosing struct.
+//
+// TODO: get rid of this somehow. Probably by including a FieldInfo struct
+// or the like.
+func (v Value) Label() (string, bool) {
+ if v.v.Label == 0 {
+ return "", false
+ }
+ return v.idx.LabelStr(v.v.Label), true
+}
+
+// Kind returns the kind of value. It returns BottomKind for atomic values that
+// are not concrete. For instance, it will return BottomKind for the bounds
+// >=0.
+func (v Value) Kind() Kind {
+ if v.v == nil {
+ return BottomKind
+ }
+ c := v.v.Value
+ if c == nil {
+ c = v.v.v.evalPartial(v.ctx())
+ }
+ k := c.Kind()
+ if k.isGround() {
+ switch {
+ case k.isAnyOf(nullKind):
+ return NullKind
+ case k.isAnyOf(boolKind):
+ return BoolKind
+ case k&numKind == (intKind):
+ return IntKind
+ case k&numKind == (floatKind):
+ return FloatKind
+ case k.isAnyOf(numKind):
+ return NumberKind
+ case k.isAnyOf(bytesKind):
+ return BytesKind
+ case k.isAnyOf(stringKind):
+ return StringKind
+ case k.isAnyOf(structKind):
+ return StructKind
+ case k.isAnyOf(listKind):
+ return ListKind
+ }
+ }
+ return BottomKind
+}
+
+// IncompleteKind returns a mask of all kinds that this value may be.
+func (v Value) IncompleteKind() Kind {
+ if v.v == nil {
+ return BottomKind
+ }
+ var k kind
+ x := v.v.v.evalPartial(v.ctx())
+ switch x := convertBuiltin(x).(type) {
+ case *builtin:
+ k = x.representedKind()
+ case *customValidator:
+ k = x.Builtin.Params[0]
+ default:
+ k = x.Kind()
+ }
+ vk := BottomKind // Everything is a bottom kind.
+ for i := kind(1); i < nonGround; i <<= 1 {
+ if k&i != 0 {
+ switch i {
+ case nullKind:
+ vk |= NullKind
+ case boolKind:
+ vk |= BoolKind
+ case intKind:
+ vk |= IntKind
+ case floatKind:
+ vk |= FloatKind
+ case stringKind:
+ vk |= StringKind
+ case bytesKind:
+ vk |= BytesKind
+ case structKind:
+ vk |= StructKind
+ case listKind:
+ vk |= ListKind
+ }
+ }
+ }
+ return vk
+}
+
+// MarshalJSON marshalls this value into valid JSON.
+func (v Value) MarshalJSON() (b []byte, err error) {
+ b, err = v.marshalJSON()
+ if err != nil {
+ return nil, unwrapJSONError(err)
+ }
+ return b, nil
+}
+
+func (v Value) marshalJSON() (b []byte, err error) {
+ v, _ = v.Default()
+ if v.v == nil {
+ return json.Marshal(nil)
+ }
+ ctx := v.idx.newContext()
+ x := v.eval(ctx)
+ // TODO: implement marshalles in value.
+ switch k := x.Kind(); k {
+ case nullKind:
+ return json.Marshal(nil)
+ case boolKind:
+ return json.Marshal(x.(*boolLit).B)
+ case intKind, floatKind, numKind:
+ return x.(*numLit).X.MarshalText()
+ case stringKind:
+ return json.Marshal(x.(*stringLit).Str)
+ case bytesKind:
+ return json.Marshal(x.(*bytesLit).B)
+ case listKind:
+ i, _ := v.List()
+ return marshalList(&i)
+ case structKind:
+ obj, err := v.structValData(ctx)
+ st := obj.obj
+ if len(st.comprehensions) > 0 {
+ // This should always evaluate to incomplete. However, fall back
+ // to a bad error message, rather than crashing, in case it doesn't.
+ if err, ok := st.comprehensions[0].comp.evalPartial(ctx).(*bottom); ok {
+ return nil, toMarshalErr(v, err)
+ }
+ }
+
+ if err != nil {
+ return nil, toMarshalErr(v, err)
+ }
+ return obj.marshalJSON()
+ case bottomKind:
+ return nil, toMarshalErr(v, x.(*bottom))
+ default:
+ if k.hasReferences() {
+ return nil, marshalErrf(v, x, codeIncomplete, "value %q contains unresolved references", ctx.str(x))
+ }
+ if !k.isGround() {
+ return nil, marshalErrf(v, x, codeIncomplete, "cannot convert incomplete value %q to JSON", ctx.str(x))
+ }
+ return nil, marshalErrf(v, x, 0, "cannot convert value %q of type %T to JSON", ctx.str(x), x)
+ }
+}
+
+// Syntax converts the possibly partially evaluated value into syntax. This
+// can use used to print the value with package format.
+func (v Value) Syntax(opts ...Option) ast.Node {
+ // TODO: the default should ideally be simplified representation that
+ // exactly represents the value. The latter can currently only be
+ // ensured with Raw().
+ if v.v == nil || v.v.Value == nil {
+ return nil
+ }
+ ctx := v.ctx()
+ o := getOptions(opts)
+ var inst *Instance
+ if !o.final && !o.concrete {
+ inst = v.instance()
+ }
+ if o.raw {
+ n, _ := export(ctx, inst, v.v.v, o)
+ return n
+ }
+ n, _ := export(ctx, inst, v.v.Value, o)
+ return n
+}
+
+// Decode initializes x with Value v. If x is a struct, it will validate the
+// constraints specified in the field tags.
+func (v Value) Decode(x interface{}) error {
+ // TODO: optimize
+ b, err := v.MarshalJSON()
+ if err != nil {
+ return err
+ }
+ return json.Unmarshal(b, x)
+}
+
+// // EncodeJSON generates JSON for the given value.
+// func (v Value) EncodeJSON(w io.Writer, v Value) error {
+// return nil
+// }
+
+// Doc returns all documentation comments associated with the field from which
+// the current value originates.
+func (v Value) Doc() []*ast.CommentGroup {
+ if v.v == nil {
+ return nil
+ }
+ return v.v.docs.appendDocs(nil)
+}
+
+// Split returns a list of values from which v originated such that
+// the unification of all these values equals v and for all returned values.
+// It will also split unchecked unifications (embeddings), so unifying the
+// split values may fail if actually unified.
+// Source returns a non-nil value.
+//
+// Deprecated: use Expr.
+func (v Value) Split() []Value {
+ if v.v == nil {
+ return nil
+ }
+ ctx := v.ctx()
+ a := []Value{}
+ for _, x := range separate(v.v.v) {
+ path := *v.v
+ path.Value = x.evalPartial(ctx)
+ path.v = x
+ a = append(a, Value{v.idx, &path})
+ }
+ return a
+}
+
+func separate(v value) (a []value) {
+ c := v.computed()
+ if c == nil || (c.op != opUnify && c.op != opUnifyUnchecked) {
+ return []value{v}
+ }
+ if c.x != nil {
+ a = append(a, separate(c.x)...)
+ }
+ if c.y != nil {
+ a = append(a, separate(c.y)...)
+ }
+ return a
+}
+
+// Source returns the original node for this value. The return value may not
+// be a syntax.Expr. For instance, a struct kind may be represented by a
+// struct literal, a field comprehension, or a file. It returns nil for
+// computed nodes. Use Split to get all source values that apply to a field.
+func (v Value) Source() ast.Node {
+ if v.v == nil {
+ return nil
+ }
+ return v.v.v.Source()
+}
+
+// Err returns the error represented by v or nil v is not an error.
+func (v Value) Err() error {
+ if err := v.checkKind(v.ctx(), bottomKind); err != nil {
+ return v.toErr(err)
+ }
+ return nil
+}
+
+// Pos returns position information.
+func (v Value) Pos() token.Pos {
+ if v.v == nil || v.Source() == nil {
+ return token.NoPos
+ }
+ pos := v.Source().Pos()
+ return pos
+}
+
+// TODO: IsFinal: this value can never be changed.
+
+// IsClosed reports whether a list of struct is closed. It reports false when
+// when the value is not a list or struct.
+func (v Value) IsClosed() bool {
+ switch v.Kind() {
+ case StructKind:
+ if st, ok := v.v.val().(*structLit); ok {
+ return st.closeStatus.shouldClose()
+ }
+ case ListKind:
+ if l, ok := v.v.val().(*list); ok {
+ if n, ok := l.len.(*numLit); ok {
+ return n.intValue(v.ctx()) == len(l.elem.Arcs)
+ }
+ }
+ }
+ return false
+}
+
+// IsConcrete reports whether the current value is a concrete scalar value
+// (not relying on default values), a terminal error, a list, or a struct.
+// It does not verify that values of lists or structs are concrete themselves.
+// To check whether there is a concrete default, use v.Default().IsConcrete().
+func (v Value) IsConcrete() bool {
+ if v.v == nil {
+ return false // any is neither concrete, not a list or struct.
+ }
+ x := v.v.v.evalPartial(v.ctx())
+
+ // Errors marked as incomplete are treated as not complete.
+ if isIncomplete(x) {
+ return false
+ }
+ // Other errors are considered ground.
+ return x.Kind().isConcrete()
+}
+
+// Deprecated: IsIncomplete
+//
+// It indicates that the value cannot be fully evaluated due to
+// insufficient information.
+func (v Value) IsIncomplete() bool {
+ // TODO: remove
+ x := v.eval(v.ctx())
+ if !x.Kind().isConcrete() {
+ return true
+ }
+ return isIncomplete(x)
+}
+
+// Exists reports whether this value existed in the configuration.
+func (v Value) Exists() bool {
+ if v.v == nil {
+ return false
+ }
+ return exists(v.eval(v.ctx()))
+}
+
+func (v Value) checkKind(ctx *context, want kind) *bottom {
+ if v.v == nil {
+ return errNotExists
+ }
+ // TODO: use checkKind
+ x := v.eval(ctx)
+ if b, ok := x.(*bottom); ok {
+ return b
+ }
+ got := x.Kind()
+ if want != bottomKind {
+ if got&want&concreteKind == bottomKind {
+ return ctx.mkErr(x, "cannot use value %v (type %s) as %s",
+ v.ctx().str(x), got, want)
+ }
+ if !got.isGround() {
+ return ctx.mkErr(x, codeIncomplete,
+ "non-concrete value %v", got)
+ }
+ }
+ return nil
+}
+
+func makeInt(v Value, x int64) Value {
+ return remakeValue(v, newInt(v.v.v.base(), base10).setInt64(x))
+}
+
+// Len returns the number of items of the underlying value.
+// For lists it reports the capacity of the list. For structs it indicates the
+// number of fields, for bytes the number of bytes.
+func (v Value) Len() Value {
+ if v.v != nil {
+ switch x := v.v.v.evalPartial(v.ctx()).(type) {
+ case *list:
+ return remakeValue(v, x.len.evalPartial(v.ctx()))
+ case *bytesLit:
+ return makeInt(v, int64(x.len()))
+ case *stringLit:
+ return makeInt(v, int64(x.len()))
+ }
+ }
+ const msg = "len not supported for type %v"
+ return remakeValue(v, v.ctx().mkErr(v.v.v, msg, v.Kind()))
+}
+
+// Elem returns the value of undefined element types of lists and structs.
+func (v Value) Elem() (Value, bool) {
+ if v.v == nil {
+ return Value{}, false
+ }
+ ctx := v.ctx()
+ switch x := v.v.Value.(type) {
+ case *structLit:
+ t, _ := x.optionals.constraint(ctx, nil)
+ if t == nil {
+ break
+ }
+ return v.makeElem(t), true
+ case *list:
+ return v.makeElem(x.typ), true
+ }
+ return Value{}, false
+}
+
+// BulkOptionals returns all bulk optional fields as key-value pairs.
+// See also Elem and Template.
+func (v Value) BulkOptionals() [][2]Value {
+ x, ok := v.v.Value.(*structLit)
+ if !ok {
+ return nil
+ }
+ return v.appendBulk(nil, x.optionals)
+}
+
+func (v Value) appendBulk(a [][2]Value, x *optionals) [][2]Value {
+ if x == nil {
+ return a
+ }
+ a = v.appendBulk(a, x.left)
+ a = v.appendBulk(a, x.right)
+ for _, set := range x.fields {
+ if set.key != nil {
+ ctx := v.ctx()
+ fn, ok := ctx.manifest(set.value).(*lambdaExpr)
+ if !ok {
+ // create error
+ continue
+ }
+ x := fn.call(ctx, set.value, &basicType{K: stringKind})
+
+ a = append(a, [2]Value{v.makeElem(set.key), v.makeElem(x)})
+ }
+ }
+ return a
+}
+
+// List creates an iterator over the values of a list or reports an error if
+// v is not a list.
+func (v Value) List() (Iterator, error) {
+ v, _ = v.Default()
+ ctx := v.ctx()
+ if err := v.checkKind(ctx, listKind); err != nil {
+ return Iterator{ctx: ctx}, v.toErr(err)
+ }
+ l := v.eval(ctx).(*list)
+ return Iterator{ctx: ctx, val: v, iter: l, len: len(l.elem.Arcs)}, nil
+}
+
+// Null reports an error if v is not null.
+func (v Value) Null() error {
+ v, _ = v.Default()
+ if err := v.checkKind(v.ctx(), nullKind); err != nil {
+ return v.toErr(err)
+ }
+ return nil
+}
+
+// // IsNull reports whether v is null.
+// func (v Value) IsNull() bool {
+// return v.Null() == nil
+// }
+
+// Bool returns the bool value of v or false and an error if v is not a boolean.
+func (v Value) Bool() (bool, error) {
+ v, _ = v.Default()
+ ctx := v.ctx()
+ if err := v.checkKind(ctx, boolKind); err != nil {
+ return false, v.toErr(err)
+ }
+ return v.eval(ctx).(*boolLit).B, nil
+}
+
+// String returns the string value if v is a string or an error otherwise.
+func (v Value) String() (string, error) {
+ v, _ = v.Default()
+ ctx := v.ctx()
+ if err := v.checkKind(ctx, stringKind); err != nil {
+ return "", v.toErr(err)
+ }
+ return v.eval(ctx).(*stringLit).Str, nil
+}
+
+// Bytes returns a byte slice if v represents a list of bytes or an error
+// otherwise.
+func (v Value) Bytes() ([]byte, error) {
+ v, _ = v.Default()
+ ctx := v.ctx()
+ switch x := v.eval(ctx).(type) {
+ case *bytesLit:
+ return append([]byte(nil), x.B...), nil
+ case *stringLit:
+ return []byte(x.Str), nil
+ }
+ return nil, v.toErr(v.checkKind(ctx, bytesKind|stringKind))
+}
+
+// Reader returns a new Reader if v is a string or bytes type and an error
+// otherwise.
+func (v Value) Reader() (io.Reader, error) {
+ v, _ = v.Default()
+ ctx := v.ctx()
+ switch x := v.eval(ctx).(type) {
+ case *bytesLit:
+ return bytes.NewReader(x.B), nil
+ case *stringLit:
+ return strings.NewReader(x.Str), nil
+ }
+ return nil, v.toErr(v.checkKind(ctx, stringKind|bytesKind))
+}
+
+// TODO: distinguish between optional, hidden, etc. Probably the best approach
+// is to mark options in context and have a single function for creating
+// a structVal.
+
+// structVal returns an structVal or an error if v is not a struct.
+func (v Value) structValData(ctx *context) (structValue, *bottom) {
+ return v.structValOpts(ctx, options{
+ omitHidden: true,
+ omitDefinitions: true,
+ omitOptional: true,
+ })
+}
+
+func (v Value) structValFull(ctx *context) (structValue, *bottom) {
+ return v.structValOpts(ctx, options{})
+}
+
+// structVal returns an structVal or an error if v is not a struct.
+func (v Value) structValOpts(ctx *context, o options) (structValue, *bottom) {
+ v, _ = v.Default() // TODO: remove?
+
+ obj, path, err := v.getStruct()
+ if err != nil {
+ return structValue{}, err
+ }
+
+ // check if any fields can be omitted
+ needFilter := false
+ if o.omitHidden || o.omitOptional || o.omitDefinitions {
+ f := label(0)
+ for _, a := range obj.Arcs {
+ f |= a.Label
+ if a.optional && o.omitOptional {
+ needFilter = true
+ break
+ }
+ if a.definition && (o.omitDefinitions || o.concrete) {
+ needFilter = true
+ break
+ }
+ }
+ needFilter = needFilter || f.IsHidden()
+ }
+
+ if needFilter {
+ arcs := make([]arc, len(obj.Arcs))
+ k := 0
+ for _, a := range obj.Arcs {
+ if a.definition && (o.omitDefinitions || o.concrete) {
+ continue
+ }
+ if a.Label.IsHidden() && o.omitHidden {
+ continue
+ }
+ if o.omitOptional && a.optional {
+ continue
+ }
+ arcs[k] = a
+ k++
+ }
+ arcs = arcs[:k]
+ return structValue{ctx, path, obj, arcs}, nil
+ }
+ return structValue{ctx, path, obj, obj.Arcs}, nil
+}
+
+// Struct returns the underlying struct of a value or an error if the value
+// is not a struct.
+func (v Value) Struct() (*Struct, error) {
+ obj, path, err := v.getStruct()
+ if err != nil {
+ return nil, v.toErr(err)
+ }
+ return &Struct{Value{v.idx, path}, obj}, nil
+}
+
+func (v Value) getStruct() (*structLit, *valueData, *bottom) {
+ ctx := v.ctx()
+ if err := v.checkKind(ctx, structKind); err != nil {
+ return nil, nil, err
+ }
+ orig := v.eval(ctx).(*structLit)
+
+ // TODO: This is expansion appropriate?
+ obj, err := orig.expandFields(ctx)
+ if err != nil {
+ return nil, nil, err
+ }
+
+ path := v.v
+ if obj != orig {
+ p := *path
+ p.arc.Value = obj
+ path = &p
+ }
+
+ return obj, path, nil
+}
+
+// Struct represents a CUE struct value.
+type Struct struct {
+ v Value
+ s *structLit
+}
+
+// FieldInfo contains information about a struct field.
+type FieldInfo struct {
+ Name string
+ Pos int
+ Value Value
+
+ IsDefinition bool
+ IsOptional bool
+ IsHidden bool
+}
+
+func (s *Struct) Len() int {
+ return len(s.s.Arcs)
+}
+
+// field reports information about the ith field, i < o.Len().
+func (s *Struct) Field(i int) FieldInfo {
+ ctx := s.v.ctx()
+ a := s.s.Arcs[i]
+ a.Value = s.s.at(ctx, i)
+
+ // TODO: adding more technical debt here. The evaluator should be
+ // rewritten.
+ x := s.s
+ if x.optionals != nil {
+ name := ctx.LabelStr(x.Arcs[i].Label)
+ arg := &stringLit{x.baseValue, name, nil}
+
+ val, _ := x.optionals.constraint(ctx, arg)
+ if val != nil {
+ a.v = mkBin(ctx, x.Pos(), opUnify, a.v, val)
+ }
+ }
+
+ v := Value{ctx.index, &valueData{s.v.v, uint32(i), a}}
+ str := ctx.LabelStr(a.Label)
+ return FieldInfo{str, i, v, a.definition, a.optional, a.Label.IsHidden()}
+}
+
+// FieldByName looks up a field for the given name. If isIdent is true, it will
+// look up a definition or hidden field (starting with `_` or `_#`). Otherwise
+// it interprets name as an arbitrary string for a regular field.
+func (s *Struct) FieldByName(name string, isIdent bool) (FieldInfo, error) {
+ f := s.v.ctx().Label(name, isIdent)
+ for i, a := range s.s.Arcs {
+ if a.Label == f {
+ return s.Field(i), nil
+ }
+ }
+ return FieldInfo{}, errNotFound
+}
+
+// Fields creates an iterator over the Struct's fields.
+func (s *Struct) Fields(opts ...Option) *Iterator {
+ iter, _ := s.v.Fields(opts...)
+ return iter
+}
+
+// Fields creates an iterator over v's fields if v is a struct or an error
+// otherwise.
+func (v Value) Fields(opts ...Option) (*Iterator, error) {
+ o := options{omitDefinitions: true, omitHidden: true, omitOptional: true}
+ o.updateOptions(opts)
+ ctx := v.ctx()
+ obj, err := v.structValOpts(ctx, o)
+ if err != nil {
+ return &Iterator{ctx: ctx}, v.toErr(err)
+ }
+ n := &structLit{
+ obj.obj.baseValue, // baseValue
+ obj.obj.emit, // emit
+ obj.obj.optionals, // template
+ obj.obj.closeStatus, // closeStatus
+ nil, // comprehensions
+ obj.Arcs, // arcs
+ nil, // attributes
+ }
+ return &Iterator{ctx: ctx, val: v, iter: n, len: len(n.Arcs)}, nil
+}
+
+// Lookup reports the value at a path starting from v. The empty path returns v
+// itself. Use LookupDef for definitions or LookupField for any kind of field.
+//
+// The Exists() method can be used to verify if the returned value existed.
+// Lookup cannot be used to look up hidden or optional fields or definitions.
+func (v Value) Lookup(path ...string) Value {
+ ctx := v.ctx()
+ for _, k := range path {
+ // TODO(eval) TODO(error): always search in full data and change error
+ // message if a field is found but is of the incorrect type.
+ obj, err := v.structValData(ctx)
+ if err != nil {
+ // TODO: return a Value at the same location and a new error?
+ return newErrValue(v, err)
+ }
+ v = obj.Lookup(k)
+ }
+ return v
+}
+
+// LookupDef reports the definition with the given name within struct v. The
+// Exists method of the returned value will report false if the definition did
+// not exist. The Err method reports if any error occurred during evaluation.
+func (v Value) LookupDef(name string) Value {
+ ctx := v.ctx()
+ o, err := v.structValFull(ctx)
+ if err != nil {
+ return newErrValue(v, err)
+ }
+
+ f := v.ctx().Label(name, true)
+ for i, a := range o.Arcs {
+ if a.Label == f {
+ if f.IsHidden() || !a.definition || a.optional {
+ break
+ }
+ return newChildValue(&o, i)
+ }
+ }
+ if !strings.HasPrefix(name, "#") {
+ alt := v.LookupDef("#" + name)
+ // Use the original error message if this resulted in an error as well.
+ if alt.Err() == nil {
+ return alt
+ }
+ }
+ return newErrValue(v, ctx.mkErr(v.v.v,
+ "definition %q not found", name))
+}
+
+var errNotFound = errors.Newf(token.NoPos, "field not found")
+
+// FieldByName looks up a field for the given name. If isIdent is true, it will
+// look up a definition or hidden field (starting with `_` or `_#`). Otherwise
+// it interprets name as an arbitrary string for a regular field.
+func (v Value) FieldByName(name string, isIdent bool) (f FieldInfo, err error) {
+ s, err := v.Struct()
+ if err != nil {
+ return f, err
+ }
+ return s.FieldByName(name, isIdent)
+}
+
+// LookupField reports information about a field of v.
+//
+// Deprecated: this API does not work with new-style definitions. Use FieldByName.
+func (v Value) LookupField(name string) (FieldInfo, error) {
+ s, err := v.Struct()
+ if err != nil {
+ // TODO: return a Value at the same location and a new error?
+ return FieldInfo{}, err
+ }
+ f, err := s.FieldByName(name, true)
+ if err != nil {
+ return f, err
+ }
+ if f.IsHidden {
+ return f, errNotFound
+ }
+ return f, err
+}
+
+// TODO: expose this API?
+//
+// // EvalExpr evaluates an expression within the scope of v, which must be
+// // a struct.
+// //
+// // Expressions may refer to builtin packages if they can be uniquely identified.
+// func (v Value) EvalExpr(expr ast.Expr) Value {
+// ctx := v.ctx()
+// result := evalExpr(ctx, v.eval(ctx), expr)
+// return newValueRoot(ctx, result)
+// }
+
+// Fill creates a new value by unifying v with the value of x at the given path.
+//
+// Values may be any Go value that can be converted to CUE, an ast.Expr or
+// a Value. In the latter case, it will panic if the Value is not from the same
+// Runtime.
+//
+// Any reference in v referring to the value at the given path will resolve
+// to x in the newly created value. The resulting value is not validated.
+func (v Value) Fill(x interface{}, path ...string) Value {
+ if v.v == nil {
+ return v
+ }
+ ctx := v.ctx()
+ root := v.v.val()
+ for i := len(path) - 1; i >= 0; i-- {
+ x = map[string]interface{}{path[i]: x}
+ }
+ value := convertVal(ctx, root, true, x)
+ a := v.v.arc
+ a.v = mkBin(ctx, v.Pos(), opUnify, root, value)
+ a.Value = a.v.evalPartial(ctx)
+ // TODO: validate recursively?
+ return Value{v.idx, &valueData{v.v.parent, v.v.index, a}}
+}
+
+// Template returns a function that represents the template definition for a
+// struct in a configuration file. It returns nil if v is not a struct kind or
+// if there is no template associated with the struct.
+//
+// The returned function returns the value that would be unified with field
+// given its name.
+func (v Value) Template() func(label string) Value {
+ // TODO: rename to optional.
+ if v.v == nil {
+ return nil
+ }
+
+ ctx := v.ctx()
+ x, ok := v.v.Value.(*structLit)
+ if !ok || x.optionals.isEmpty() {
+ return nil
+ }
+
+ return func(label string) Value {
+ arg := &stringLit{x.baseValue, label, nil}
+
+ if val, _ := x.optionals.constraint(ctx, arg); val != nil {
+ return remakeValue(v, val)
+ }
+ return Value{}
+ }
+}
+
+// Subsume reports nil when w is an instance of v or an error otherwise.
+//
+// Without options, the entire value is considered for assumption, which means
+// Subsume tests whether v is a backwards compatible (newer) API version of w.
+// Use the Final() to indicate that the subsumed value is data, and that
+//
+// Use the Final option to check subsumption if a w is known to be final,
+// and should assumed to be closed.
+//
+// Options are currently ignored and the function will panic if any are passed.
+//
+// Value v and w must be obtained from the same build.
+// TODO: remove this requirement.
+func (v Value) Subsume(w Value, opts ...Option) error {
+ var mode subsumeMode
+ o := getOptions(opts)
+ if o.final {
+ mode |= subFinal | subChoose
+ }
+ if o.ignoreClosedness {
+ mode |= subSchema
+ }
+ return subsumes(v, w, mode)
+}
+
+// Deprecated: use Subsume.
+//
+// Subsumes reports whether w is an instance of v.
+//
+// Without options, Subsumes checks whether v is a backwards compatbile schema
+// of w.
+//
+// By default, Subsumes tests whether two values are compatib
+// Value v and w must be obtained from the same build.
+// TODO: remove this requirement.
+func (v Value) Subsumes(w Value) bool {
+ return subsumes(v, w, subChoose) == nil
+}
+
+// Unify reports the greatest lower bound of v and w.
+//
+// Value v and w must be obtained from the same build.
+// TODO: remove this requirement.
+func (v Value) Unify(w Value) Value {
+ ctx := v.ctx()
+ if v.v == nil {
+ return w
+ }
+ if w.v == nil {
+ return v
+ }
+ if v.Err() != nil {
+ // TODO: perhaps keep both errors.
+ return v
+ }
+ if w.Err() != nil {
+ return w
+ }
+ a := v.v.v
+ b := w.v.v
+ src := binSrc(token.NoPos, opUnify, a, b)
+ val := mkBin(ctx, src.Pos(), opUnify, a, b)
+ u := remakeValue(v, val)
+ if err := u.Validate(); err != nil {
+ u = newValueRoot(ctx, ctx.mkErr(src, err))
+ }
+ return u
+}
+
+// Equals reports whether two values are equal, ignoring optional fields.
+// The result is undefined for incomplete values.
+func (v Value) Equals(other Value) bool {
+ if v.v == nil || other.v == nil {
+ return false
+ }
+ x := v.v.val()
+ y := other.v.val()
+ return equals(v.ctx(), x, y)
+}
+
+// Format prints a debug version of a value.
+func (v Value) Format(state fmt.State, verb rune) {
+ ctx := v.ctx()
+ if v.v == nil {
+ fmt.Fprint(state, "<nil>")
+ return
+ }
+ switch {
+ case state.Flag('#'):
+ _, _ = io.WriteString(state, ctx.str(v.v.v))
+ case state.Flag('+'):
+ _, _ = io.WriteString(state, debugStr(ctx, v.v.v))
+ default:
+ _, _ = io.WriteString(state, ctx.str(v.v.Value))
+ }
+}
+
+func (v Value) instance() *Instance {
+ if v.v == nil {
+ return nil
+ }
+ return v.ctx().getImportFromNode(v.v.v)
+}
+
+// Reference returns the instance and path referred to by this value such that
+// inst.Lookup(path) resolves to the same value, or no path if this value is not
+// a reference. If a reference contains index selection (foo[bar]), it will
+// only return a reference if the index resolves to a concrete value.
+func (v Value) Reference() (inst *Instance, path []string) {
+ // TODO: don't include references to hidden fields.
+ if v.v == nil {
+ return nil, nil
+ }
+ ctx := v.ctx()
+ var x value
+ var feature string
+ switch sel := v.v.v.(type) {
+ case *selectorExpr:
+ x = sel.X
+ feature = ctx.LabelStr(sel.Sel)
+
+ case *indexExpr:
+ e := sel.Index.evalPartial(ctx)
+ s, ok := e.(*stringLit)
+ if !ok {
+ return nil, nil
+ }
+ x = sel.X
+ feature = s.Str
+
+ default:
+ return nil, nil
+ }
+ imp, a := mkPath(ctx, v.v, x, feature, 0)
+ return imp, a
+}
+
+func mkPath(c *context, up *valueData, x value, feature string, d int) (imp *Instance, a []string) {
+ switch x := x.(type) {
+ case *selectorExpr:
+ imp, a = mkPath(c, up, x.X, c.LabelStr(x.Sel), d+1)
+ if imp == nil {
+ return nil, nil
+ }
+
+ case *indexExpr:
+ e := x.Index.evalPartial(c)
+ s, ok := e.(*stringLit)
+ if !ok {
+ return nil, nil
+ }
+ imp, a = mkPath(c, up, x.X, s.Str, d+1)
+ if imp == nil {
+ return nil, nil
+ }
+
+ case *nodeRef:
+ // the parent must exist.
+ var v value
+ if p := locateNode(up, x); p != nil {
+ v, a = mkFromRoot(c, p, d+2)
+ } else {
+ // Either this references another parent, or it is an embedding.
+ imp = c.getImportFromNode(x.node)
+ if imp != nil {
+ break
+ }
+ // This must be an embedding, go one up.
+ v, a = mkFromRoot(c, up.parent, d+2)
+ }
+ if v == nil {
+ v = x.node
+ }
+ imp = c.getImportFromNode(v)
+ default:
+ return nil, nil
+ }
+ return imp, append(a, feature)
+}
+
+func mkFromRoot(c *context, up *valueData, d int) (root value, a []string) {
+ if up == nil {
+ return nil, make([]string, 0, d)
+ }
+ root, a = mkFromRoot(c, up.parent, d+1)
+ if up.parent != nil {
+ a = append(a, c.LabelStr(up.Label))
+ } else {
+ root = up.v
+ }
+ return root, a
+}
+
+// References reports all references used to evaluate this value. It does not
+// report references for sub fields if v is a struct.
+//
+// Deprecated: can be implemented in terms of Reference and Expr.
+func (v Value) References() [][]string {
+ // TODO: the pathFinder algorithm is quite broken. Using Reference and Expr
+ // will cast a much more accurate net on referenced values.
+ ctx := v.ctx()
+ pf := pathFinder{up: v.v}
+ raw := v.v.v
+ if raw == nil {
+ return nil
+ }
+ rewrite(ctx, raw, pf.find)
+ return pf.paths
+}
+
+type pathFinder struct {
+ paths [][]string
+ stack []label
+ up *valueData
+}
+
+func (p *pathFinder) find(ctx *context, v value) (value, bool) {
+ switch x := v.(type) {
+ case *selectorExpr:
+ i := len(p.stack)
+ p.stack = append(p.stack, x.Sel)
+ rewrite(ctx, x.X, p.find)
+ p.stack = p.stack[:i]
+ return v, false
+
+ case *nodeRef:
+ i := len(p.stack)
+ up := p.up
+ for ; up != nil && up.Value != x.node.(value); up = up.parent {
+ }
+ for ; up != nil && up.Label > 0; up = up.parent {
+ p.stack = append(p.stack, up.Label)
+ }
+ path := make([]string, len(p.stack))
+ for i, v := range p.stack {
+ path[len(path)-1-i] = ctx.LabelStr(v)
+ }
+ p.paths = append(p.paths, path)
+ p.stack = p.stack[:i]
+ return v, false
+
+ case *structLit:
+ // If the stack is empty, we do not descend, as we are not evaluating
+ // sub fields.
+ if len(p.stack) == 0 {
+ return v, false
+ }
+
+ stack := p.stack
+ p.stack = nil
+ for _, a := range x.Arcs {
+ rewrite(ctx, a.v, p.find)
+ }
+ p.stack = stack
+ return v, false
+ }
+ return v, true
+}
+
+type options struct {
+ concrete bool // enforce that values are concrete
+ raw bool // show original values
+ hasHidden bool
+ omitHidden bool
+ omitDefinitions bool
+ omitOptional bool
+ omitAttrs bool
+ resolveReferences bool
+ final bool
+ ignoreClosedness bool // used for comparing APIs
+ docs bool
+ disallowCycles bool // implied by concrete
+}
+
+// An Option defines modes of evaluation.
+type Option option
+
+type option func(p *options)
+
+// Final indicates a value is final. It implicitly closes all structs and lists
+// in a value and selects defaults.
+func Final() Option {
+ return func(o *options) {
+ o.final = true
+ o.omitDefinitions = true
+ o.omitOptional = true
+ o.omitHidden = true
+ }
+}
+
+// Schema specifies the input is a Schema. Used by Subsume.
+func Schema() Option {
+ return func(o *options) {
+ o.ignoreClosedness = true
+ }
+}
+
+// Concrete ensures that all values are concrete.
+//
+// For Validate this means it returns an error if this is not the case.
+// In other cases a non-concrete value will be replaced with an error.
+func Concrete(concrete bool) Option {
+ return func(p *options) {
+ if concrete {
+ p.concrete = true
+ p.final = true
+ if !p.hasHidden {
+ p.omitHidden = true
+ p.omitDefinitions = true
+ }
+ }
+ }
+}
+
+// DisallowCycles forces validation in the precense of cycles, even if
+// non-concrete values are allowed. This is implied by Concrete(true).
+func DisallowCycles(disallow bool) Option {
+ return func(p *options) { p.disallowCycles = disallow }
+}
+
+// ResolveReferences forces the evaluation of references when outputting.
+// This implies the input cannot have cycles.
+func ResolveReferences(resolve bool) Option {
+ return func(p *options) { p.resolveReferences = resolve }
+}
+
+// Raw tells Syntax to generate the value as is without any simplifications.
+func Raw() Option {
+ return func(p *options) { p.raw = true }
+}
+
+// All indicates that all fields and values should be included in processing
+// even if they can be elided or omitted.
+func All() Option {
+ return func(p *options) {
+ p.omitAttrs = false
+ p.omitHidden = false
+ p.omitDefinitions = false
+ p.omitOptional = false
+ }
+}
+
+// Docs indicates whether docs should be included.
+func Docs(include bool) Option {
+ return func(p *options) { p.docs = true }
+}
+
+// Definitions indicates whether definitions should be included.
+//
+// Definitions may still be included for certain functions if they are referred
+// to by other other values.
+func Definitions(include bool) Option {
+ return func(p *options) {
+ p.hasHidden = true
+ p.omitDefinitions = !include
+ }
+}
+
+// Hidden indicates that definitions and hidden fields should be included.
+//
+// Deprecated: Hidden fields are deprecated.
+func Hidden(include bool) Option {
+ return func(p *options) {
+ p.hasHidden = true
+ p.omitHidden = !include
+ p.omitDefinitions = !include
+ }
+}
+
+// Optional indicates that optional fields should be included.
+func Optional(include bool) Option {
+ return func(p *options) { p.omitOptional = !include }
+}
+
+// Attributes indicates that attributes should be included.
+func Attributes(include bool) Option {
+ return func(p *options) { p.omitAttrs = !include }
+}
+
+func getOptions(opts []Option) (o options) {
+ o.updateOptions(opts)
+ return
+}
+
+func (o *options) updateOptions(opts []Option) {
+ for _, fn := range opts {
+ fn(o)
+ }
+}
+
+// Validate reports any errors, recursively. The returned error may represent
+// more than one error, retrievable with errors.Errors, if more than one
+// exists.
+func (v Value) Validate(opts ...Option) error {
+ x := validator{}
+ o := options{}
+ o.updateOptions(opts)
+ // Logically, errors are always permitted in logical fields, so we
+ // force-disable them.
+ // TODO: consider whether we should honor the option to allow checking
+ // optional fields.
+ o.omitOptional = true
+ x.walk(v, o)
+ return errors.Sanitize(x.errs)
+}
+
+type validator struct {
+ errs errors.Error
+ depth int
+}
+
+func (x *validator) before(v Value, o options) bool {
+ if err := v.checkKind(v.ctx(), bottomKind); err != nil {
+ if !o.concrete && isIncomplete(err) {
+ if o.disallowCycles && err.Code == codeCycle {
+ x.errs = errors.Append(x.errs, v.toErr(err))
+ }
+ return false
+ }
+ x.errs = errors.Append(x.errs, v.toErr(err))
+ if len(errors.Errors(x.errs)) > 50 {
+ return false // mostly to avoid some hypothetical cycle issue
+ }
+ }
+ if o.concrete {
+ ctx := v.ctx()
+ if err := isGroundRecursive(ctx, v.eval(ctx)); err != nil {
+ x.errs = errors.Append(x.errs, v.toErr(err))
+ }
+ }
+ return true
+}
+
+func (x *validator) walk(v Value, opts options) {
+ // TODO(#42): we can get rid of the arbitrary evaluation depth once CUE has
+ // proper structural cycle detection. See Issue #42. Currently errors
+ // occurring at a depth > internal.MaxDepth will not be detected.
+ if x.depth > internal.MaxDepth {
+ return
+ }
+ ctx := v.ctx()
+ switch v.Kind() {
+ case StructKind:
+ if !x.before(v, opts) {
+ return
+ }
+ x.depth++
+ obj, err := v.structValOpts(ctx, opts)
+ if err != nil {
+ if !isIncomplete(err) && opts.concrete {
+ x.errs = errors.Append(x.errs, v.toErr(err))
+ }
+ }
+ for i := 0; i < obj.Len(); i++ {
+ _, v := obj.At(i)
+ opts := opts
+ if obj.Arcs[i].definition {
+ opts.concrete = false
+ }
+ x.walk(v, opts)
+ }
+ x.depth--
+
+ case ListKind:
+ if !x.before(v, opts) {
+ return
+ }
+ x.depth++
+ list, _ := v.List()
+ for list.Next() {
+ x.walk(list.Value(), opts)
+ }
+ x.depth--
+
+ default:
+ x.before(v, opts)
+ }
+}
+
+func isGroundRecursive(ctx *context, v value) *bottom {
+ switch x := v.(type) {
+ case *bottom:
+ if isIncomplete(x) {
+ return x
+ }
+ case *list:
+ for i := 0; i < len(x.elem.Arcs); i++ {
+ v := ctx.manifest(x.at(ctx, i))
+ if err := isGroundRecursive(ctx, v); err != nil {
+ return err
+ }
+ }
+ default:
+ if !x.Kind().isGround() {
+ return ctx.mkErr(v, "incomplete value (%v)", ctx.str(v))
+ }
+ }
+ return nil
+}
+
+// Walk descends into all values of v, calling f. If f returns false, Walk
+// will not descent further. It only visits values that are part of the data
+// model, so this excludes optional fields, hidden fields, and definitions.
+func (v Value) Walk(before func(Value) bool, after func(Value)) {
+ ctx := v.ctx()
+ switch v.Kind() {
+ case StructKind:
+ if before != nil && !before(v) {
+ return
+ }
+ obj, _ := v.structValData(ctx)
+ for i := 0; i < obj.Len(); i++ {
+ _, v := obj.At(i)
+ v.Walk(before, after)
+ }
+ case ListKind:
+ if before != nil && !before(v) {
+ return
+ }
+ list, _ := v.List()
+ for list.Next() {
+ list.Value().Walk(before, after)
+ }
+ default:
+ if before != nil {
+ before(v)
+ }
+ }
+ if after != nil {
+ after(v)
+ }
+}
+
+// Attribute returns the attribute data for the given key.
+// The returned attribute will return an error for any of its methods if there
+// is no attribute for the requested key.
+func (v Value) Attribute(key string) Attribute {
+ // look up the attributes
+ if v.v == nil || v.v.attrs == nil {
+ return Attribute{internal.NewNonExisting(key)}
+ }
+ for _, a := range v.v.attrs.attr {
+ if a.key() != key {
+ continue
+ }
+ return Attribute{internal.ParseAttrBody(token.NoPos, a.body())}
+ }
+ return Attribute{internal.NewNonExisting(key)}
+}
+
+// An Attribute contains meta data about a field.
+type Attribute struct {
+ attr internal.Attr
+}
+
+// Err returns the error associated with this Attribute or nil if this
+// attribute is valid.
+func (a *Attribute) Err() error {
+ return a.attr.Err
+}
+
+// String reports the possibly empty string value at the given position or
+// an error the attribute is invalid or if the position does not exist.
+func (a *Attribute) String(pos int) (string, error) {
+ return a.attr.String(pos)
+}
+
+// Int reports the integer at the given position or an error if the attribute is
+// invalid, the position does not exist, or the value at the given position is
+// not an integer.
+func (a *Attribute) Int(pos int) (int64, error) {
+ return a.attr.Int(pos)
+}
+
+// Flag reports whether an entry with the given name exists at position pos or
+// onwards or an error if the attribute is invalid or if the first pos-1 entries
+// are not defined.
+func (a *Attribute) Flag(pos int, key string) (bool, error) {
+ return a.attr.Flag(pos, key)
+}
+
+// Lookup searches for an entry of the form key=value from position pos onwards
+// and reports the value if found. It reports an error if the attribute is
+// invalid or if the first pos-1 entries are not defined.
+func (a *Attribute) Lookup(pos int, key string) (val string, found bool, err error) {
+ return a.attr.Lookup(pos, key)
+}
+
+// Expr reports the operation of the underlying expression and the values it
+// operates on.
+//
+// For unary expressions, it returns the single value of the expression.
+//
+// For binary expressions it returns first the left and right value, in that
+// order. For associative operations however, (for instance '&' and '|'), it may
+// return more than two values, where the operation is to be applied in
+// sequence.
+//
+// For selector and index expressions it returns the subject and then the index.
+// For selectors, the index is the string value of the identifier.
+//
+// For interpolations it returns a sequence of values to be concatenated, some
+// of which will be literal strings and some unevaluated expressions.
+//
+// A builtin call expression returns the value of the builtin followed by the
+// args of the call.
+func (v Value) Expr() (Op, []Value) {
+ // TODO: return v if this is complete? Yes for now
+ if v.v == nil {
+ return NoOp, nil
+ }
+ // TODO: replace appends with []Value{}. For not leave.
+ a := []Value{}
+ op := NoOp
+ switch x := v.v.v.(type) {
+ case *binaryExpr:
+ a = append(a, remakeValue(v, x.X))
+ a = append(a, remakeValue(v, x.Y))
+ op = opToOp[x.Op]
+ case *unaryExpr:
+ a = append(a, remakeValue(v, x.X))
+ op = opToOp[x.Op]
+ case *bound:
+ a = append(a, remakeValue(v, x.Expr))
+ op = opToOp[x.Op]
+ case *unification:
+ // pre-expanded unification
+ for _, conjunct := range x.Values {
+ a = append(a, remakeValue(v, conjunct))
+ }
+ op = AndOp
+ case *disjunction:
+ // Filter defaults that are subsumed by another value.
+ count := 0
+ outer:
+ for _, disjunct := range x.Values {
+ if disjunct.Default {
+ for _, n := range x.Values {
+ s := subsumer{ctx: v.ctx()}
+ if !n.Default && s.subsumes(n.Val, disjunct.Val) {
+ continue outer
+ }
+ }
+ }
+ count++
+ a = append(a, remakeValue(v, disjunct.Val))
+ }
+ if count > 1 {
+ op = OrOp
+ }
+ case *interpolation:
+ for _, p := range x.Parts {
+ a = append(a, remakeValue(v, p))
+ }
+ op = InterpolationOp
+ case *selectorExpr:
+ a = append(a, remakeValue(v, x.X))
+ a = append(a, remakeValue(v, &stringLit{
+ x.baseValue,
+ v.ctx().LabelStr(x.Sel),
+ nil,
+ }))
+ op = SelectorOp
+ case *indexExpr:
+ a = append(a, remakeValue(v, x.X))
+ a = append(a, remakeValue(v, x.Index))
+ op = IndexOp
+ case *sliceExpr:
+ a = append(a, remakeValue(v, x.X))
+ a = append(a, remakeValue(v, x.Lo))
+ a = append(a, remakeValue(v, x.Hi))
+ op = SliceOp
+ case *callExpr:
+ a = append(a, remakeValue(v, x.Fun))
+ for _, arg := range x.Args {
+ a = append(a, remakeValue(v, arg))
+ }
+ op = CallOp
+ case *customValidator:
+ a = append(a, remakeValue(v, x.Builtin))
+ for _, arg := range x.Args {
+ a = append(a, remakeValue(v, arg))
+ }
+ op = CallOp
+ default:
+ a = append(a, v)
+ }
+ return op, a
+}
diff --git a/internal/legacy/cue/types_test.go b/internal/legacy/cue/types_test.go
new file mode 100644
index 0000000..cea8a14
--- /dev/null
+++ b/internal/legacy/cue/types_test.go
@@ -0,0 +1,2783 @@
+// 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 cue
+
+import (
+ "bytes"
+ "fmt"
+ "io/ioutil"
+ "math"
+ "math/big"
+ "reflect"
+ "strconv"
+ "strings"
+ "testing"
+
+ "github.com/google/go-cmp/cmp"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/internal"
+)
+
+func getInstance(t *testing.T, body ...string) *Instance {
+ t.Helper()
+
+ insts := Build(makeInstances([]*bimport{{files: body}}))
+ if insts[0].Err != nil {
+ t.Fatalf("unexpected parse error: %v", insts[0].Err)
+ }
+ return insts[0]
+}
+
+func TestValueType(t *testing.T) {
+ testCases := []struct {
+ value string
+ kind Kind
+ incompleteKind Kind
+ json string
+ valid bool
+ concrete bool
+ closed bool
+ // pos token.Pos
+ }{{ // Not a concrete value.
+ value: `v: _`,
+ kind: BottomKind,
+ incompleteKind: TopKind,
+ }, {
+ value: `v: _|_`,
+ kind: BottomKind,
+ incompleteKind: BottomKind,
+ concrete: true,
+ }, {
+ value: `v: 1&2`,
+ kind: BottomKind,
+ incompleteKind: BottomKind,
+ concrete: true,
+ }, {
+ value: `v: b, b: 1&2`,
+ kind: BottomKind,
+ incompleteKind: BottomKind,
+ concrete: true,
+ }, {
+ value: `v: (b[a]), b: 1, a: 1`,
+ kind: BottomKind,
+ incompleteKind: BottomKind,
+ concrete: true,
+ }, { // TODO: should be error{
+ value: `v: (b)
+ b: bool`,
+ kind: BottomKind,
+ incompleteKind: BoolKind,
+ }, {
+ value: `v: ([][b]), b: "d"`,
+ kind: BottomKind,
+ incompleteKind: BottomKind,
+ concrete: true,
+ }, {
+ value: `v: null`,
+ kind: NullKind,
+ incompleteKind: NullKind,
+ concrete: true,
+ }, {
+ value: `v: true`,
+ kind: BoolKind,
+ incompleteKind: BoolKind,
+ concrete: true,
+ }, {
+ value: `v: false`,
+ kind: BoolKind,
+ incompleteKind: BoolKind,
+ concrete: true,
+ }, {
+ value: `v: bool`,
+ kind: BottomKind,
+ incompleteKind: BoolKind,
+ }, {
+ value: `v: 2`,
+ kind: IntKind,
+ incompleteKind: IntKind,
+ concrete: true,
+ }, {
+ value: `v: 2.0`,
+ kind: FloatKind,
+ incompleteKind: FloatKind,
+ concrete: true,
+ }, {
+ value: `v: 2.0Mi`,
+ kind: IntKind,
+ incompleteKind: IntKind,
+ concrete: true,
+ }, {
+ value: `v: 14_000`,
+ kind: IntKind,
+ incompleteKind: IntKind,
+ concrete: true,
+ }, {
+ value: `v: >=0 & <5`,
+ kind: BottomKind,
+ incompleteKind: NumberKind,
+ }, {
+ value: `v: float`,
+ kind: BottomKind,
+ incompleteKind: FloatKind,
+ }, {
+ value: `v: "str"`,
+ kind: StringKind,
+ incompleteKind: StringKind,
+ concrete: true,
+ }, {
+ value: "v: '''\n'''",
+ kind: BytesKind,
+ incompleteKind: BytesKind,
+ concrete: true,
+ }, {
+ value: "v: string",
+ kind: BottomKind,
+ incompleteKind: StringKind,
+ }, {
+ value: `v: {}`,
+ kind: StructKind,
+ incompleteKind: StructKind,
+ concrete: true,
+ }, {
+ value: `v: close({})`,
+ kind: StructKind,
+ incompleteKind: StructKind,
+ concrete: true,
+ closed: true,
+ }, {
+ value: `v: []`,
+ kind: ListKind,
+ incompleteKind: ListKind,
+ concrete: true,
+ closed: true,
+ }, {
+ value: `v: [...int]`,
+ kind: BottomKind,
+ incompleteKind: ListKind,
+ concrete: false,
+ }, {
+ value: `v: {a: int, b: [1][a]}.b`,
+ kind: BottomKind,
+ concrete: false,
+ }, {
+ value: `import "time"
+ v: {a: time.Time}.a`,
+ kind: BottomKind,
+ incompleteKind: StringKind,
+ concrete: false,
+ }, {
+ value: `import "time"
+ v: {a: time.Time & string}.a`,
+ kind: BottomKind,
+ incompleteKind: StringKind,
+ concrete: false,
+ }, {
+ value: `import "strings"
+ v: {a: strings.ContainsAny("D")}.a`,
+ kind: BottomKind,
+ incompleteKind: StringKind,
+ concrete: false,
+ }, {
+ value: `import "struct"
+ v: {a: struct.MaxFields(2) & {}}.a`,
+ kind: StructKind, // Can determine a valid struct already.
+ incompleteKind: StructKind,
+ concrete: true,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ inst := getInstance(t, tc.value)
+ v := inst.Lookup("v")
+ if got := v.Kind(); got != tc.kind {
+ t.Errorf("Kind: got %x; want %x", int(got), int(tc.kind))
+ }
+ want := tc.incompleteKind | BottomKind
+ if got := v.IncompleteKind(); got != want {
+ t.Errorf("IncompleteKind: got %x; want %x", int(got), int(want))
+ }
+ if got := v.IsConcrete(); got != tc.concrete {
+ t.Errorf("IsConcrete: got %v; want %v", got, tc.concrete)
+ }
+ if got := v.IsClosed(); got != tc.closed {
+ t.Errorf("IsClosed: got %v; want %v", got, tc.closed)
+ }
+ })
+ }
+}
+
+func TestInt(t *testing.T) {
+ testCases := []struct {
+ value string
+ int int64
+ uint uint64
+ base int
+ err string
+ errU string
+ notInt bool
+ }{{
+ value: "1",
+ int: 1,
+ uint: 1,
+ }, {
+ value: "-1",
+ int: -1,
+ uint: 0,
+ errU: ErrAbove.Error(),
+ }, {
+ value: "-111222333444555666777888999000",
+ int: math.MinInt64,
+ uint: 0,
+ err: ErrAbove.Error(),
+ errU: ErrAbove.Error(),
+ }, {
+ value: "111222333444555666777888999000",
+ int: math.MaxInt64,
+ uint: math.MaxUint64,
+ err: ErrBelow.Error(),
+ errU: ErrBelow.Error(),
+ }, {
+ value: "1.0",
+ err: "cannot use value 1.0 (type float) as int",
+ errU: "cannot use value 1.0 (type float) as int",
+ notInt: true,
+ }, {
+ value: "int",
+ err: "non-concrete value int",
+ errU: "non-concrete value int",
+ notInt: true,
+ }, {
+ value: "_|_",
+ err: "from source",
+ errU: "from source",
+ notInt: true,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ n := getInstance(t, tc.value).Value()
+ base := 10
+ if tc.base > 0 {
+ base = tc.base
+ }
+ b, err := n.AppendInt(nil, base)
+ if checkFailed(t, err, tc.err, "append") {
+ want := tc.value
+ if got := string(b); got != want {
+ t.Errorf("append: got %v; want %v", got, want)
+ }
+ }
+
+ vi, err := n.Int64()
+ checkErr(t, err, tc.err, "Int64")
+ if vi != tc.int {
+ t.Errorf("Int64: got %v; want %v", vi, tc.int)
+ }
+
+ vu, err := n.Uint64()
+ checkErr(t, err, tc.errU, "Uint64")
+ if vu != uint64(tc.uint) {
+ t.Errorf("Uint64: got %v; want %v", vu, tc.uint)
+ }
+ })
+ }
+}
+
+func TestFloat(t *testing.T) {
+ testCases := []struct {
+ value string
+ float string
+ float64 float64
+ mant string
+ exp int
+ fmt byte
+ prec int
+ kind Kind
+ err string
+ }{{
+ value: "1",
+ float: "1",
+ mant: "1",
+ exp: 0,
+ float64: 1,
+ fmt: 'g',
+ kind: IntKind,
+ }, {
+ value: "-1",
+ float: "-1",
+ mant: "-1",
+ exp: 0,
+ float64: -1,
+ fmt: 'g',
+ kind: IntKind,
+ }, {
+ value: "1.0",
+ float: "1.0",
+ mant: "10",
+ exp: -1,
+ float64: 1.0,
+ fmt: 'g',
+ kind: FloatKind,
+ }, {
+ value: "2.6",
+ float: "2.6",
+ mant: "26",
+ exp: -1,
+ float64: 2.6,
+ fmt: 'g',
+ kind: FloatKind,
+ }, {
+ value: "20.600",
+ float: "20.60",
+ mant: "20600",
+ exp: -3,
+ float64: 20.60,
+ prec: 2,
+ fmt: 'f',
+ kind: FloatKind,
+ }, {
+ value: "1/0",
+ float: "",
+ float64: 0,
+ prec: 2,
+ fmt: 'f',
+ err: "division by zero",
+ kind: BottomKind,
+ }, {
+ value: "1.797693134862315708145274237317043567982e+308",
+ float: "1.8e+308",
+ mant: "1797693134862315708145274237317043567982",
+ exp: 269,
+ float64: math.Inf(1),
+ prec: 2,
+ fmt: 'g',
+ err: ErrAbove.Error(),
+ kind: FloatKind,
+ }, {
+ value: "-1.797693134862315708145274237317043567982e+308",
+ float: "-1.8e+308",
+ mant: "-1797693134862315708145274237317043567982",
+ exp: 269,
+ float64: math.Inf(-1),
+ prec: 2,
+ fmt: 'g',
+ kind: FloatKind,
+ err: ErrBelow.Error(),
+ }, {
+ value: "4.940656458412465441765687928682213723650e-324",
+ float: "4.941e-324",
+ mant: "4940656458412465441765687928682213723650",
+ exp: -363,
+ float64: 0,
+ prec: 4,
+ fmt: 'g',
+ kind: FloatKind,
+ err: ErrBelow.Error(),
+ }, {
+ value: "-4.940656458412465441765687928682213723650e-324",
+ float: "-4.940656458412465441765687928682213723650e-324",
+ mant: "-4940656458412465441765687928682213723650",
+ exp: -363,
+ float64: 0,
+ prec: -1,
+ fmt: 'g',
+ kind: FloatKind,
+ err: ErrAbove.Error(),
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ n := getInstance(t, tc.value).Value()
+ if n.Kind() != tc.kind {
+ t.Fatal("Not a number")
+ }
+
+ var mant big.Int
+ exp, err := n.MantExp(&mant)
+ mstr := ""
+ if err == nil {
+ mstr = mant.String()
+ }
+ if exp != tc.exp || mstr != tc.mant {
+ t.Errorf("mantExp: got %s %d; want %s %d", mstr, exp, tc.mant, tc.exp)
+ }
+
+ b, _ := n.AppendFloat(nil, tc.fmt, tc.prec)
+ want := tc.float
+ if got := string(b); got != want {
+ t.Errorf("append: got %v; want %v", got, want)
+ }
+
+ f, err := n.Float64()
+ checkErr(t, err, tc.err, "Float64")
+ if f != tc.float64 {
+ t.Errorf("Float64: got %v; want %v", f, tc.float64)
+ }
+ })
+ }
+}
+
+func TestString(t *testing.T) {
+ testCases := []struct {
+ value string
+ str string
+ err string
+ }{{
+ value: `""`,
+ str: ``,
+ }, {
+ value: `"Hello world!"`,
+ str: `Hello world!`,
+ }, {
+ value: `"Hello \(#world)!"
+ #world: "world"`,
+ str: `Hello world!`,
+ }, {
+ value: `string`,
+ err: "non-concrete value string",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ str, err := getInstance(t, tc.value).Value().String()
+ checkFatal(t, err, tc.err, "init")
+ if str != tc.str {
+ t.Errorf("String: got %q; want %q", str, tc.str)
+ }
+
+ b, err := getInstance(t, tc.value).Value().Bytes()
+ checkFatal(t, err, tc.err, "init")
+ if got := string(b); got != tc.str {
+ t.Errorf("Bytes: got %q; want %q", got, tc.str)
+ }
+
+ r, err := getInstance(t, tc.value).Value().Reader()
+ checkFatal(t, err, tc.err, "init")
+ b, _ = ioutil.ReadAll(r)
+ if got := string(b); got != tc.str {
+ t.Errorf("Reader: got %q; want %q", got, tc.str)
+ }
+ })
+ }
+}
+
+func TestError(t *testing.T) {
+ testCases := []struct {
+ value string
+ err string
+ }{{
+ value: `_|_`,
+ err: "from source",
+ }, {
+ value: `"Hello world!"`,
+ }, {
+ value: `string`,
+ err: "",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ err := getInstance(t, tc.value).Value().Err()
+ checkErr(t, err, tc.err, "init")
+ })
+ }
+}
+
+func TestNull(t *testing.T) {
+ testCases := []struct {
+ value string
+ err string
+ }{{
+ value: `v: _|_`,
+ err: "from source",
+ }, {
+ value: `v: "str"`,
+ err: "cannot use value \"str\" (type string) as null",
+ }, {
+ value: `v: null`,
+ }, {
+ value: `v: _`,
+ err: "non-concrete value _",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ err := getInstance(t, tc.value).Lookup("v").Null()
+ checkErr(t, err, tc.err, "init")
+ })
+ }
+}
+
+func TestBool(t *testing.T) {
+ testCases := []struct {
+ value string
+ bool bool
+ err string
+ }{{
+ value: `_|_`,
+ err: "from source",
+ }, {
+ value: `"str"`,
+ err: "cannot use value \"str\" (type string) as bool",
+ }, {
+ value: `true`,
+ bool: true,
+ }, {
+ value: `false`,
+ }, {
+ value: `bool`,
+ err: "non-concrete value bool",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ got, err := getInstance(t, tc.value).Value().Bool()
+ if checkErr(t, err, tc.err, "init") {
+ if got != tc.bool {
+ t.Errorf("got %v; want %v", got, tc.bool)
+ }
+ }
+ })
+ }
+}
+
+func TestList(t *testing.T) {
+ testCases := []struct {
+ value string
+ res string
+ err string
+ }{{
+ value: `_|_`,
+ err: "from source",
+ }, {
+ value: `"str"`,
+ err: "cannot use value \"str\" (type string) as list",
+ }, {
+ value: `[]`,
+ res: "[]",
+ }, {
+ value: `[1,2,3]`,
+ res: "[1,2,3,]",
+ }, {
+ value: `>=5*[1,2,3, ...int]`,
+ err: "incomplete",
+ }, {
+ value: `[for x in #y if x > 1 { x }]
+ #y: [1,2,3]`,
+ res: "[2,3,]",
+ }, {
+ value: `[int]`,
+ err: "cannot convert incomplete value",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ l, err := getInstance(t, tc.value).Value().List()
+ checkFatal(t, err, tc.err, "init")
+
+ buf := []byte{'['}
+ for l.Next() {
+ b, err := l.Value().MarshalJSON()
+ checkFatal(t, err, tc.err, "list.Value")
+ buf = append(buf, b...)
+ buf = append(buf, ',')
+ }
+ buf = append(buf, ']')
+ if got := string(buf); got != tc.res {
+ t.Errorf("got %v; want %v", got, tc.res)
+ }
+ })
+ }
+}
+
+func TestFields(t *testing.T) {
+ testCases := []struct {
+ value string
+ res string
+ err string
+ }{{
+ value: `_|_`,
+ err: "from source",
+ }, {
+ value: `"str"`,
+ err: "cannot use value \"str\" (type string) as struct",
+ }, {
+ value: `{}`,
+ res: "{}",
+ }, {
+ value: `{a:1,b:2,c:3}`,
+ res: "{a:1,b:2,c:3,}",
+ }, {
+ value: `{a:1,"_b":2,c:3,_d:4}`,
+ res: "{a:1,_b:2,c:3,}",
+ }, {
+ value: `{_a:"a"}`,
+ res: "{}",
+ }, {
+ value: `{ for k, v in #y if v > 1 {"\(k)": v} }
+ #y: {a:1,b:2,c:3}`,
+ res: "{b:2,c:3,}",
+ }, {
+ value: `{ #def: 1, _hidden: 2, opt?: 3, reg: 4 }`,
+ res: "{reg:4,}",
+ }, {
+ value: `{a:1,b:2,c:int}`,
+ err: "cannot convert incomplete value",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ obj := getInstance(t, tc.value).Value()
+
+ iter, err := obj.Fields()
+ checkFatal(t, err, tc.err, "init")
+
+ buf := []byte{'{'}
+ for iter.Next() {
+ buf = append(buf, iter.Label()...)
+ buf = append(buf, ':')
+ b, err := iter.Value().MarshalJSON()
+ checkFatal(t, err, tc.err, "Obj.At")
+ buf = append(buf, b...)
+ buf = append(buf, ',')
+ }
+ buf = append(buf, '}')
+ if got := string(buf); got != tc.res {
+ t.Errorf("got %v; want %v", got, tc.res)
+ }
+
+ iter, _ = obj.Fields()
+ for iter.Next() {
+ want, err := iter.Value().MarshalJSON()
+ checkFatal(t, err, tc.err, "Obj.At2")
+
+ got, err := obj.Lookup(iter.Label()).MarshalJSON()
+ checkFatal(t, err, tc.err, "Obj.At2")
+
+ if !bytes.Equal(got, want) {
+ t.Errorf("Lookup: got %q; want %q", got, want)
+ }
+ }
+ v := obj.Lookup("non-existing")
+ checkErr(t, v.Err(), "not found", "non-existing")
+ })
+ }
+}
+
+func TestAllFields(t *testing.T) {
+ testCases := []struct {
+ value string
+ res string
+ err string
+ }{{
+ value: `{a:1,"_b":2,c:3,_d:4}`,
+ res: "{a:1,_b:2,c:3,_d:4,}",
+ }, {
+ value: `{_a:"a"}`,
+ res: `{_a:"a",}`,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ obj := getInstance(t, tc.value).Value()
+
+ var iter *Iterator // Verify that the returned iterator is a pointer.
+ iter, err := obj.Fields(All())
+ checkFatal(t, err, tc.err, "init")
+
+ buf := []byte{'{'}
+ for iter.Next() {
+ buf = append(buf, iter.Label()...)
+ buf = append(buf, ':')
+ b, err := iter.Value().MarshalJSON()
+ checkFatal(t, err, tc.err, "Obj.At")
+ buf = append(buf, b...)
+ buf = append(buf, ',')
+ }
+ buf = append(buf, '}')
+ if got := string(buf); got != tc.res {
+ t.Errorf("got %v; want %v", got, tc.res)
+ }
+ })
+ }
+}
+
+func TestLookup(t *testing.T) {
+ var runtime = new(Runtime)
+ inst, err := runtime.Compile("x.cue", `
+#V: {
+ x: int
+}
+#X: {
+ [string]: int64
+} & #V
+v: #X
+`)
+ if err != nil {
+ t.Fatalf("compile: %v", err)
+ }
+ // expr, err := parser.ParseExpr("lookup.cue", `v`, parser.DeclarationErrors, parser.AllErrors)
+ // if err != nil {
+ // log.Fatalf("parseExpr: %v", err)
+ // }
+ // v := inst.Eval(expr)
+ testCases := []struct {
+ ref []string
+ raw string
+ eval string
+ }{{
+ ref: []string{"v", "x"},
+ raw: "(int & <=9223372036854775807 & int & >=-9223372036854775808)",
+ eval: "int64",
+ }}
+ for _, tc := range testCases {
+ v := inst.Lookup(tc.ref...)
+
+ if got := fmt.Sprint(v); got != tc.raw {
+ t.Errorf("got %v; want %v", got, tc.raw)
+ }
+
+ got := fmt.Sprint(internal.DebugStr(v.Eval().Syntax()))
+ if got != tc.eval {
+ t.Errorf("got %v; want %v", got, tc.eval)
+ }
+
+ v = inst.Lookup()
+ for _, ref := range tc.ref {
+ s, err := v.Struct()
+ if err != nil {
+ t.Fatal(err)
+ }
+ fi, err := s.FieldByName(ref, false)
+ if err != nil {
+ t.Fatal(err)
+ }
+ v = fi.Value
+ }
+
+ if got := fmt.Sprint(v); got != tc.raw {
+ t.Errorf("got %v; want %v", got, tc.raw)
+ }
+
+ got = fmt.Sprint(internal.DebugStr(v.Eval().Syntax()))
+ if got != tc.eval {
+ t.Errorf("got %v; want %v", got, tc.eval)
+ }
+ }
+}
+
+func compileT(t *testing.T, r *Runtime, s string) *Instance {
+ t.Helper()
+ inst, err := r.Compile("", s)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return inst
+}
+
+func goValue(v Value) interface{} {
+ var x interface{}
+ err := v.Decode(&x)
+ if err != nil {
+ return err
+ }
+ return x
+}
+
+func TestFill(t *testing.T) {
+ r := &Runtime{}
+
+ inst, err := r.CompileExpr(ast.NewStruct("bar", ast.NewString("baz")))
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ testCases := []struct {
+ in string
+ x interface{}
+ path string // comma-separated path
+ out string
+ }{{
+ in: `
+ foo: int
+ bar: foo
+ `,
+ x: 3,
+ path: "foo",
+ out: `
+ foo: 3
+ bar: 3
+ `,
+ }, {
+ in: `
+ string
+ `,
+ x: "foo",
+ path: "",
+ out: `
+ "foo"
+ `,
+ }, {
+ in: `
+ foo: _
+ `,
+ x: inst.Value(),
+ path: "foo",
+ out: `
+ {foo: {bar: "baz"}}
+ `,
+ }}
+
+ for _, tc := range testCases {
+ var path []string
+ if tc.path != "" {
+ path = strings.Split(tc.path, ",")
+ }
+
+ v := compileT(t, r, tc.in).Value().Fill(tc.x, path...)
+ w := compileT(t, r, tc.out).Value()
+
+ if !reflect.DeepEqual(goValue(v), goValue(w)) {
+ t.Errorf("\ngot: %s\nwant: %s", v, w)
+ }
+ }
+}
+
+func TestFill2(t *testing.T) {
+ r := &Runtime{}
+
+ root, err := r.Compile("test", `
+ #Provider: {
+ ID: string
+ notConcrete: bool
+ }
+ `)
+
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ spec := root.LookupDef("#Provider")
+ providerInstance := spec.Fill("12345", "ID")
+ root, err = root.Fill(providerInstance, "providers", "myprovider")
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ got := fmt.Sprint(root.Value())
+
+ if got != `{#Provider: C{ID: string, notConcrete: bool}, providers: {myprovider: C{ID: (string & "12345"), notConcrete: bool}}}` {
+ t.Error(got)
+ }
+}
+
+func TestValue_LookupDef(t *testing.T) {
+ r := &Runtime{}
+
+ testCases := []struct {
+ in string
+ def string // comma-separated path
+ exists bool
+ out string
+ }{{
+ in: `#foo: 3`,
+ def: "#foo",
+ out: `3`,
+ }, {
+ in: `_foo: 3`,
+ def: "_foo",
+ out: `_|_(definition "_foo" not found)`,
+ }, {
+ in: `_#foo: 3`,
+ def: "_#foo",
+ out: `_|_(definition "_#foo" not found)`,
+ }}
+
+ for _, tc := range testCases {
+ t.Run(tc.def, func(t *testing.T) {
+ v := compileT(t, r, tc.in).Value()
+ v = v.LookupDef(tc.def)
+ got := fmt.Sprint(v)
+
+ if got != tc.out {
+ t.Errorf("\ngot: %s\nwant: %s", got, tc.out)
+ }
+ })
+ }
+}
+
+func TestDefaults(t *testing.T) {
+ testCases := []struct {
+ value string
+ def string
+ val string
+ ok bool
+ }{{
+ value: `number | *1`,
+ def: "1",
+ val: "number",
+ ok: true,
+ }, {
+ value: `1 | 2 | *3`,
+ def: "3",
+ val: "1|2|3",
+ ok: true,
+ }, {
+ value: `*{a:1,b:2}|{a:1}|{b:2}`,
+ def: "{a: 1, b: 2}",
+ val: "{a: 1}|{b: 2}",
+ ok: true,
+ }, {
+ value: `{a:1}&{b:2}`,
+ def: `{a: 1, b: 2}`,
+ val: ``,
+ ok: false,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ v := getInstance(t, "a: "+tc.value).Lookup("a")
+
+ d, ok := v.Default()
+ if ok != tc.ok {
+ t.Errorf("hasDefault: got %v; want %v", ok, tc.ok)
+ }
+
+ if got := fmt.Sprint(d); got != tc.def {
+ t.Errorf("default: got %v; want %v", got, tc.def)
+ }
+
+ op, val := v.Expr()
+ if op != OrOp {
+ return
+ }
+ vars := []string{}
+ for _, v := range val {
+ vars = append(vars, fmt.Sprint(v))
+ }
+ if got := strings.Join(vars, "|"); got != tc.val {
+ t.Errorf("value: got %v; want %v", got, tc.val)
+ }
+ })
+ }
+}
+
+func TestLen(t *testing.T) {
+ testCases := []struct {
+ input string
+ length string
+ }{{
+ input: "[1, 3]",
+ length: "2",
+ }, {
+ input: "[1, 3, ...]",
+ length: "int & >=2",
+ }, {
+ input: `"foo"`,
+ length: "3",
+ }, {
+ input: `'foo'`,
+ length: "3",
+ // TODO: Currently not supported.
+ // }, {
+ // input: "{a:1, b:3, a:1, c?: 3, _hidden: 4}",
+ // length: "2",
+ }, {
+ input: "3",
+ length: "_|_(len not supported for type int)",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.input, func(t *testing.T) {
+ v := getInstance(t, "a: "+tc.input).Lookup("a")
+
+ length := v.Len()
+ if got := fmt.Sprint(length); got != tc.length {
+ t.Errorf("length: got %v; want %v", got, tc.length)
+ }
+ })
+ }
+}
+
+func TestTemplate(t *testing.T) {
+ testCases := []struct {
+ value string
+ path []string
+ want string
+ }{{
+ value: `
+ a: [Name=string]: Name
+ `,
+ path: []string{"a", ""},
+ want: `"label"`,
+ }, {
+ value: `
+ [Name=string]: { a: Name }
+ `,
+ path: []string{"", "a"},
+ want: `"label"`,
+ }, {
+ value: `
+ [Name=string]: { a: Name }
+ `,
+ path: []string{""},
+ want: `{"a":"label"}`,
+ }, {
+ value: `
+ a: [Foo=string]: [Bar=string]: { b: Foo+Bar }
+ `,
+ path: []string{"a", "", ""},
+ want: `{"b":"labellabel"}`,
+ }, {
+ value: `
+ a: [Foo=string]: b: [Bar=string]: { c: Foo+Bar }
+ a: foo: b: [Bar=string]: { d: Bar }
+ `,
+ path: []string{"a", "foo", "b", ""},
+ want: `{"c":"foolabel","d":"label"}`,
+ }}
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ v := getInstance(t, tc.value).Value()
+ for _, p := range tc.path {
+ if p == "" {
+ v = v.Template()("label")
+ } else {
+ v = v.Lookup(p)
+ }
+ }
+ b, err := v.MarshalJSON()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got := string(b); got != tc.want {
+ t.Errorf("\n got: %q\nwant: %q", got, tc.want)
+ }
+ })
+ }
+}
+
+func TestSubsumes(t *testing.T) {
+ a := []string{"a"}
+ b := []string{"b"}
+ testCases := []struct {
+ value string
+ pathA []string
+ pathB []string
+ want bool
+ }{{
+ value: `4`,
+ want: true,
+ }, {
+ value: `a: string, b: "foo"`,
+ pathA: a,
+ pathB: b,
+ want: true,
+ }, {
+ value: `a: string, b: "foo"`,
+ pathA: b,
+ pathB: a,
+ want: false,
+ }, {
+ value: `a: {a: string, b: 4}, b: {a: "foo", b: 4}`,
+ pathA: a,
+ pathB: b,
+ want: true,
+ }, {
+ value: `a: [string, 4], b: ["foo", 4]`,
+ pathA: a,
+ pathB: b,
+ want: true,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ v := getInstance(t, tc.value)
+ a := v.Lookup(tc.pathA...)
+ b := v.Lookup(tc.pathB...)
+ got := a.Subsumes(b)
+ if got != tc.want {
+ t.Errorf("got %v (%v); want %v (%v)", got, a, tc.want, b)
+ }
+ })
+ }
+}
+
+func TestUnify(t *testing.T) {
+ a := []string{"a"}
+ b := []string{"b"}
+ testCases := []struct {
+ value string
+ pathA []string
+ pathB []string
+ want string
+ }{{
+ value: `4`,
+ want: `4`,
+ }, {
+ value: `a: string, b: "foo"`,
+ pathA: a,
+ pathB: b,
+ want: `"foo"`,
+ }, {
+ value: `a: string, b: "foo"`,
+ pathA: b,
+ pathB: a,
+ want: `"foo"`,
+ }, {
+ value: `a: {a: string, b: 4}, b: {a: "foo", b: 4}`,
+ pathA: a,
+ pathB: b,
+ want: `{"a":"foo","b":4}`,
+ }, {
+ value: `a: [string, 4], b: ["foo", 4]`,
+ pathA: a,
+ pathB: b,
+ want: `["foo",4]`,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ v := getInstance(t, tc.value).Value()
+ x := v.Lookup(tc.pathA...)
+ y := v.Lookup(tc.pathB...)
+ b, err := x.Unify(y).MarshalJSON()
+ if err != nil {
+ t.Fatal(err)
+ }
+ if got := string(b); got != tc.want {
+ t.Errorf("got %v; want %v", got, tc.want)
+ }
+ })
+ }
+}
+
+func TestEquals(t *testing.T) {
+ testCases := []struct {
+ a, b string
+ want bool
+ }{{
+ `4`, `4`, true,
+ }, {
+ `"str"`, `2`, false,
+ }, {
+ `2`, `3`, false,
+ }, {
+ `[1]`, `[3]`, false,
+ }, {
+ `[{a: 1,...}]`, `[{a: 1,...}]`, true,
+ }, {
+ `[]`, `[]`, true,
+ }, {
+ `{
+ a: b,
+ b: a,
+ }`,
+ `{
+ a: b,
+ b: a,
+ }`,
+ true,
+ }, {
+ `{
+ a: "foo",
+ b: "bar",
+ }`,
+ `{
+ a: "foo",
+ }`,
+ false,
+ }}
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ var r Runtime
+ a, err := r.Compile("a", tc.a)
+ if err != nil {
+ t.Fatal(err)
+ }
+ b, err := r.Compile("b", tc.b)
+ if err != nil {
+ t.Fatal(err)
+ }
+ got := a.Value().Equals(b.Value())
+ if got != tc.want {
+ t.Errorf("got %v; want %v", got, tc.want)
+ }
+ })
+ }
+}
+
+func TestDecode(t *testing.T) {
+ type fields struct {
+ A int `json:"A"`
+ B int `json:"B"`
+ C int `json:"C"`
+ }
+ intList := func(ints ...int) *[]int {
+ ints = append([]int{}, ints...)
+ return &ints
+ }
+ testCases := []struct {
+ value string
+ dst interface{}
+ want interface{}
+ err string
+ }{{
+ value: `_|_`,
+ err: "from source",
+ }, {
+ value: `"str"`,
+ dst: new(string),
+ want: "str",
+ }, {
+ value: `"str"`,
+ dst: new(int),
+ err: "cannot unmarshal string into Go value of type int",
+ }, {
+ value: `{}`,
+ dst: &fields{},
+ want: fields{},
+ }, {
+ value: `{a:1,b:2,c:3}`,
+ dst: &fields{},
+ want: fields{A: 1, B: 2, C: 3},
+ }, {
+ value: `{for k, v in y if v > 1 {"\(k)": v} }
+ y: {a:1,b:2,c:3}`,
+ dst: &fields{},
+ want: fields{B: 2, C: 3},
+ }, {
+ value: `{a:1,b:2,c:int}`,
+ dst: new(fields),
+ err: "cannot convert incomplete value",
+ }, {
+ value: `[]`,
+ dst: intList(),
+ want: *intList(),
+ }, {
+ value: `[1,2,3]`,
+ dst: intList(),
+ want: *intList(1, 2, 3),
+ }, {
+ value: `[for x in #y if x > 1 { x }]
+ #y: [1,2,3]`,
+ dst: intList(),
+ want: *intList(2, 3),
+ }, {
+ value: `[int]`,
+ err: "cannot convert incomplete value",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.value, func(t *testing.T) {
+ err := getInstance(t, tc.value).Value().Decode(tc.dst)
+ checkFatal(t, err, tc.err, "init")
+
+ got := reflect.ValueOf(tc.dst).Elem().Interface()
+ if !cmp.Equal(got, tc.want) {
+ t.Error(cmp.Diff(got, tc.want))
+ t.Errorf("\n%#v\n%#v", got, tc.want)
+ }
+ })
+ }
+}
+
+func TestValidate(t *testing.T) {
+ testCases := []struct {
+ desc string
+ in string
+ err bool
+ opts []Option
+ }{{
+ desc: "issue #51",
+ in: `
+ a: [string]: foo
+ a: b: {}
+ `,
+ err: true,
+ }, {
+ desc: "concrete",
+ in: `
+ a: 1
+ b: { c: 2, d: 3 }
+ c: d: e: f: 5
+ g?: int
+ `,
+ opts: []Option{Concrete(true)},
+ }, {
+ desc: "definition error",
+ in: `
+ #b: 1 & 2
+ `,
+ opts: []Option{},
+ err: true,
+ }, {
+ desc: "definition error okay if optional",
+ in: `
+ #b?: 1 & 2
+ `,
+ opts: []Option{},
+ }, {
+ desc: "definition with optional",
+ in: `
+ #b: {
+ a: int
+ b?: >=0
+ }
+ `,
+ opts: []Option{Concrete(true)},
+ }, {
+ desc: "disjunction",
+ in: `a: 1 | 2`,
+ }, {
+ desc: "disjunction concrete",
+ in: `a: 1 | 2`,
+ opts: []Option{Concrete(true)},
+ err: true,
+ }, {
+ desc: "incomplete concrete",
+ in: `a: string`,
+ }, {
+ desc: "incomplete",
+ in: `a: string`,
+ opts: []Option{Concrete(true)},
+ err: true,
+ }, {
+ desc: "list",
+ in: `a: [{b: string}, 3]`,
+ }, {
+ desc: "list concrete",
+ in: `a: [{b: string}, 3]`,
+ opts: []Option{Concrete(true)},
+ err: true,
+ }, {
+ desc: "allow cycles",
+ in: `
+ a: b - 100
+ b: a + 100
+ c: [c[1], c[0]]
+ `,
+ }, {
+ desc: "disallow cycles",
+ in: `
+ a: b - 100
+ b: a + 100
+ c: [c[1], c[0]]
+ `,
+ opts: []Option{DisallowCycles(true)},
+ err: true,
+ }, {
+ desc: "builtins are okay",
+ in: `
+ import "time"
+
+ a: { b: time.Duration } | { c: time.Duration }
+ `,
+ }, {
+ desc: "comprehension error",
+ in: `
+ a: { if b == "foo" { field: 2 } }
+ `,
+ err: true,
+ }, {
+ desc: "ignore optional in schema",
+ in: `
+ #Schema1: {
+ a?: int
+ }
+ instance1: #Schema1
+ `,
+ opts: []Option{Concrete(true)},
+ }, {
+ desc: "issue324",
+ in: `
+ import "encoding/yaml"
+
+ x: string
+ a: b: c: *["\(x)"] | _
+ d: yaml.Marshal(a.b)
+ `,
+ }, {
+ desc: "allow non-concrete values for definitions",
+ in: `
+ variables: #variables
+
+ {[!~"^[.]"]: #job}
+
+ #variables: [string]: int | string
+
+ #job: ({a: int} | {b: int}) & {
+ "variables"?: #variables
+ }
+ `,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.desc, func(t *testing.T) {
+ r := Runtime{}
+ inst, err := r.Parse("validate", tc.in)
+ if err == nil {
+ err = inst.Value().Validate(tc.opts...)
+ }
+ if gotErr := err != nil; gotErr != tc.err {
+ t.Errorf("got %v; want %v", err, tc.err)
+ }
+ })
+ }
+}
+
+func TestPath(t *testing.T) {
+ config := `
+ a: b: c: 5
+ b: {
+ b1: 3
+ b2: 4
+ "b 3": 5
+ "4b": 6
+ l: [
+ {a: 2},
+ {c: 2},
+ ]
+ }
+ `
+ mkpath := func(p ...string) []string { return p }
+ testCases := [][]string{
+ mkpath("a", "b", "c"),
+ mkpath("b", "l", "1", "c"),
+ mkpath("b", `"b 3"`),
+ mkpath("b", `"4b"`),
+ }
+ for _, tc := range testCases {
+ r := Runtime{}
+ inst, err := r.Parse("config", config)
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Run(strings.Join(tc, "."), func(t *testing.T) {
+ v := inst.Lookup(tc[0])
+ for _, e := range tc[1:] {
+ if '0' <= e[0] && e[0] <= '9' {
+ i, err := strconv.Atoi(e)
+ if err != nil {
+ t.Fatal(err)
+ }
+ iter, err := v.List()
+ if err != nil {
+ t.Fatal(err)
+ }
+ for c := 0; iter.Next(); c++ {
+ if c == i {
+ v = iter.Value()
+ break
+ }
+ }
+ } else if e[0] == '"' {
+ v = v.Lookup(e[1 : len(e)-1])
+ } else {
+ v = v.Lookup(e)
+ }
+ }
+ got, _ := v.v.appendPath(nil, v.idx)
+ if !reflect.DeepEqual(got, tc) {
+ t.Errorf("got %v; want %v", got, tc)
+ }
+ })
+ }
+}
+
+func TestValueLookup(t *testing.T) {
+ config := `
+ a: {
+ a: 0
+ b: 1
+ c: 2
+ }
+ b: {
+ d: a.a
+ e: int
+ }
+ `
+
+ strList := func(s ...string) []string { return s }
+
+ testCases := []struct {
+ config string
+ path []string
+ str string
+ notExists bool
+ }{{
+ config: "_|_",
+ path: strList(""),
+ str: "from source",
+ }, {
+ config: "_|_",
+ path: strList("a"),
+ str: "from source",
+ }, {
+ config: config,
+ path: strList(),
+ str: "{a: {a: 0, b: 1, c: 2}, b: {d: a.a, e: int}",
+ }, {
+ config: config,
+ path: strList("a", "a"),
+ str: "0",
+ }, {
+ config: config,
+ path: strList("a"),
+ str: "{a: 0, b: 1, c: 2}",
+ }, {
+ config: config,
+ path: strList("b", "d"),
+ str: "0",
+ }, {
+ config: config,
+ path: strList("c", "non-existing"),
+ str: "not found",
+ notExists: true,
+ }, {
+ config: config,
+ path: strList("b", "d", "lookup in non-struct"),
+ str: "cannot use value 0 (type int) as struct",
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.str, func(t *testing.T) {
+ v := getInstance(t, tc.config).Value().Lookup(tc.path...)
+ if got := !v.Exists(); got != tc.notExists {
+ t.Errorf("exists: got %v; want %v", got, tc.notExists)
+ }
+
+ got := fmt.Sprint(v)
+ if tc.str == "" {
+ t.Fatalf("str empty, got %q", got)
+ }
+ if !strings.Contains(got, tc.str) {
+ t.Errorf("\n got %v\nwant %v", got, tc.str)
+ }
+ })
+ }
+}
+
+func cmpError(a, b error) bool {
+ if a == nil {
+ return b == nil
+ }
+ if b == nil {
+ return a == nil
+ }
+ return a.Error() == b.Error()
+}
+
+func TestAttributeErr(t *testing.T) {
+ const config = `
+ a: {
+ a: 0 @foo(a,b,c=1)
+ b: 1 @bar(a,b,c,d=1) @foo(a,,d=1)
+ }
+ `
+ testCases := []struct {
+ path string
+ attr string
+ err error
+ }{{
+ path: "a",
+ attr: "foo",
+ err: nil,
+ }, {
+ path: "a",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }, {
+ path: "xx",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }, {
+ path: "e",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.path+"-"+tc.attr, func(t *testing.T) {
+ v := getInstance(t, config).Value().Lookup("a", tc.path)
+ a := v.Attribute(tc.attr)
+ err := a.Err()
+ if !cmpError(err, tc.err) {
+ t.Errorf("got %v; want %v", err, tc.err)
+ }
+ })
+ }
+}
+
+func TestAttributeString(t *testing.T) {
+ const config = `
+ a: {
+ a: 0 @foo(a,b,c=1)
+ b: 1 @bar(a,b,c,d=1) @foo(a,,d=1)
+ }
+ `
+ testCases := []struct {
+ path string
+ attr string
+ pos int
+ str string
+ err error
+ }{{
+ path: "a",
+ attr: "foo",
+ pos: 0,
+ str: "a",
+ }, {
+ path: "a",
+ attr: "foo",
+ pos: 2,
+ str: "c=1",
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 3,
+ str: "d=1",
+ }, {
+ path: "e",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }, {
+ path: "b",
+ attr: "foo",
+ pos: 4,
+ err: errors.New("field does not exist"),
+ }}
+ for _, tc := range testCases {
+ t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+ v := getInstance(t, config).Value().Lookup("a", tc.path)
+ a := v.Attribute(tc.attr)
+ got, err := a.String(tc.pos)
+ if !cmpError(err, tc.err) {
+ t.Errorf("err: got %v; want %v", err, tc.err)
+ }
+ if got != tc.str {
+ t.Errorf("str: got %v; want %v", got, tc.str)
+ }
+ })
+ }
+}
+
+func TestAttributeInt(t *testing.T) {
+ const config = `
+ a: {
+ a: 0 @foo(1,3,c=1)
+ b: 1 @bar(a,-4,c,d=1) @foo(a,,d=1)
+ }
+ `
+ testCases := []struct {
+ path string
+ attr string
+ pos int
+ val int64
+ err error
+ }{{
+ path: "a",
+ attr: "foo",
+ pos: 0,
+ val: 1,
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 1,
+ val: -4,
+ }, {
+ path: "e",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }, {
+ path: "b",
+ attr: "foo",
+ pos: 4,
+ err: errors.New("field does not exist"),
+ }, {
+ path: "a",
+ attr: "foo",
+ pos: 2,
+ err: errors.New(`strconv.ParseInt: parsing "c=1": invalid syntax`),
+ }}
+ for _, tc := range testCases {
+ t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+ v := getInstance(t, config).Value().Lookup("a", tc.path)
+ a := v.Attribute(tc.attr)
+ got, err := a.Int(tc.pos)
+ if !cmpError(err, tc.err) {
+ t.Errorf("err: got %v; want %v", err, tc.err)
+ }
+ if got != tc.val {
+ t.Errorf("val: got %v; want %v", got, tc.val)
+ }
+ })
+ }
+}
+
+func TestAttributeFlag(t *testing.T) {
+ const config = `
+ a: {
+ a: 0 @foo(a,b,c=1)
+ b: 1 @bar(a,b,c,d=1) @foo(a,,d=1)
+ }
+ `
+ testCases := []struct {
+ path string
+ attr string
+ pos int
+ flag string
+ val bool
+ err error
+ }{{
+ path: "a",
+ attr: "foo",
+ pos: 0,
+ flag: "a",
+ val: true,
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 1,
+ flag: "a",
+ val: false,
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 0,
+ flag: "c",
+ val: true,
+ }, {
+ path: "e",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }, {
+ path: "b",
+ attr: "foo",
+ pos: 4,
+ err: errors.New("field does not exist"),
+ }}
+ for _, tc := range testCases {
+ t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+ v := getInstance(t, config).Value().Lookup("a", tc.path)
+ a := v.Attribute(tc.attr)
+ got, err := a.Flag(tc.pos, tc.flag)
+ if !cmpError(err, tc.err) {
+ t.Errorf("err: got %v; want %v", err, tc.err)
+ }
+ if got != tc.val {
+ t.Errorf("val: got %v; want %v", got, tc.val)
+ }
+ })
+ }
+}
+
+func TestAttributeLookup(t *testing.T) {
+ const config = `
+ a: {
+ a: 0 @foo(a,b,c=1)
+ b: 1 @bar(a,b,e=-5,d=1) @foo(a,,d=1)
+ }
+ `
+ testCases := []struct {
+ path string
+ attr string
+ pos int
+ key string
+ val string
+ err error
+ }{{
+ path: "a",
+ attr: "foo",
+ pos: 0,
+ key: "c",
+ val: "1",
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 1,
+ key: "a",
+ val: "",
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 0,
+ key: "e",
+ val: "-5",
+ }, {
+ path: "b",
+ attr: "bar",
+ pos: 0,
+ key: "d",
+ val: "1",
+ }, {
+ path: "b",
+ attr: "foo",
+ pos: 2,
+ key: "d",
+ val: "1",
+ }, {
+ path: "b",
+ attr: "foo",
+ pos: 2,
+ key: "f",
+ val: "",
+ }, {
+ path: "e",
+ attr: "bar",
+ err: errors.New(`attribute "bar" does not exist`),
+ }, {
+ path: "b",
+ attr: "foo",
+ pos: 4,
+ err: errors.New("field does not exist"),
+ }}
+ for _, tc := range testCases {
+ t.Run(fmt.Sprintf("%s.%s:%d", tc.path, tc.attr, tc.pos), func(t *testing.T) {
+ v := getInstance(t, config).Value().Lookup("a", tc.path)
+ a := v.Attribute(tc.attr)
+ got, _, err := a.Lookup(tc.pos, tc.key)
+ if !cmpError(err, tc.err) {
+ t.Errorf("err: got %v; want %v", err, tc.err)
+ }
+ if got != tc.val {
+ t.Errorf("val: got %v; want %v", got, tc.val)
+ }
+ })
+ }
+}
+
+func TestValueDoc(t *testing.T) {
+ const config = `
+ // foobar defines at least foo.
+ package foobar
+
+ // A Foo fooses stuff.
+ Foo: {
+ // field1 is an int.
+ field1: int
+
+ field2: int
+
+ // duplicate field comment
+ dup3: int
+ }
+
+ // foos are instances of Foo.
+ foos: [string]: Foo
+
+ // My first little foo.
+ foos: MyFoo: {
+ // local field comment.
+ field1: 0
+
+ // Dangling comment.
+
+ // other field comment.
+ field2: 1
+
+ // duplicate field comment
+ dup3: int
+ }
+
+ bar: {
+ // comment from bar on field 1
+ field1: int
+ // comment from bar on field 2
+ field2: int // don't include this
+ }
+
+ baz: bar & {
+ // comment from baz on field 1
+ field1: int
+ field2: int
+ }
+ `
+ config2 := `
+ // Another Foo.
+ Foo: {}
+ `
+ var r Runtime
+ getInst := func(name, body string) *Instance {
+ inst, err := r.Compile("dir/file1.cue", body)
+ if err != nil {
+ t.Fatal(err)
+ }
+ return inst
+ }
+
+ inst := getInst("config", config)
+
+ v1 := inst.Value()
+ v2 := getInst("config2", config2).Value()
+ both := v1.Unify(v2)
+
+ testCases := []struct {
+ val Value
+ path string
+ doc string
+ }{{
+ val: v1,
+ path: "foos",
+ doc: "foos are instances of Foo.\n",
+ }, {
+ val: v1,
+ path: "foos MyFoo",
+ doc: "My first little foo.\n",
+ }, {
+ val: v1,
+ path: "foos MyFoo field1",
+ doc: `field1 is an int.
+
+local field comment.
+`,
+ }, {
+ val: v1,
+ path: "foos MyFoo field2",
+ doc: "other field comment.\n",
+ }, {
+ val: v1,
+ path: "foos MyFoo dup3",
+ doc: `duplicate field comment
+
+duplicate field comment
+`,
+ }, {
+ val: v1,
+ path: "bar field1",
+ doc: "comment from bar on field 1\n",
+ }, {
+ val: v1,
+ path: "baz field1",
+ doc: `comment from baz on field 1
+
+comment from bar on field 1
+`,
+ }, {
+ val: v1,
+ path: "baz field2",
+ doc: "comment from bar on field 2\n",
+ }, {
+ val: v2,
+ path: "Foo",
+ doc: `Another Foo.
+`,
+ }, {
+ val: both,
+ path: "Foo",
+ doc: `Another Foo.
+
+A Foo fooses stuff.
+`,
+ }}
+ for _, tc := range testCases {
+ t.Run("field:"+tc.path, func(t *testing.T) {
+ v := tc.val.Lookup(strings.Split(tc.path, " ")...)
+ doc := docStr(v.Doc())
+ if doc != tc.doc {
+ t.Errorf("doc: got:\n%vwant:\n%v", doc, tc.doc)
+ }
+ })
+ }
+ want := "foobar defines at least foo.\n"
+ if got := docStr(inst.Doc()); got != want {
+ t.Errorf("pkg: got:\n%vwant:\n%v", got, want)
+ }
+}
+
+func docStr(docs []*ast.CommentGroup) string {
+ doc := ""
+ for _, d := range docs {
+ if doc != "" {
+ doc += "\n"
+ }
+ doc += d.Text()
+ }
+ return doc
+}
+
+func TestMarshalJSON(t *testing.T) {
+ testCases := []struct {
+ value string
+ json string
+ err string
+ }{{
+ value: `""`,
+ json: `""`,
+ }, {
+ value: `null`,
+ json: `null`,
+ }, {
+ value: `_|_`,
+ err: "from source",
+ }, {
+ value: `(a.b)
+ a: {}`,
+ err: "undefined field",
+ }, {
+ value: `true`,
+ json: `true`,
+ }, {
+ value: `false`,
+ json: `false`,
+ }, {
+ value: `bool`,
+ err: "cannot convert incomplete value",
+ }, {
+ value: `"str"`,
+ json: `"str"`,
+ }, {
+ value: `12_000`,
+ json: `12000`,
+ }, {
+ value: `12.000`,
+ json: `12.000`,
+ }, {
+ value: `12M`,
+ json: `12000000`,
+ }, {
+ value: `3.0e100`,
+ json: `3.0E+100`,
+ }, {
+ value: `0/0`,
+ err: "division undefined",
+ }, {
+ value: `[]`,
+ json: `[]`,
+ }, {
+ value: `[1, 2, 3]`,
+ json: `[1,2,3]`,
+ }, {
+ value: `[int]`,
+ err: `0: cannot convert incomplete value`,
+ }, {
+ value: `(>=3 * [1, 2])`,
+ err: "incomplete error", // TODO: improve error
+ }, {
+ value: `{}`,
+ json: `{}`,
+ }, {
+ value: `{a: 2, b: 3, c: ["A", "B"]}`,
+ json: `{"a":2,"b":3,"c":["A","B"]}`,
+ }, {
+ value: `{a: 2, b: 3, c: [string, "B"]}`,
+ err: `c.0: cannot convert incomplete value`,
+ }, {
+ value: `{a: [{b: [0, {c: string}] }] }`,
+ err: `a.0.b.1.c: cannot convert incomplete value`,
+ }, {
+ value: `{foo?: 1, bar?: 2, baz: 3}`,
+ json: `{"baz":3}`,
+ }, {
+ // Has an unresolved cycle, but should not matter as all fields involved
+ // are optional
+ value: `{foo?: bar, bar?: foo, baz: 3}`,
+ json: `{"baz":3}`,
+ }, {
+ // Issue #107
+ value: `a: 1.0/1`,
+ json: `{"a":1.0}`,
+ }, {
+ // Issue #108
+ value: `
+ a: int
+ a: >0
+ a: <2
+
+ b: int
+ b: >=0.9
+ b: <1.1
+
+ c: int
+ c: >1
+ c: <=2
+
+ d: int
+ d: >=1
+ d: <=1.5
+
+ e: int
+ e: >=1
+ e: <=1.32
+
+ f: >=1.1 & <=1.1
+ `,
+ json: `{"a":1,"b":1,"c":2,"d":1,"e":1,"f":1.1}`,
+ }, {
+ value: `
+ #Task: {
+ {
+ op: "pull"
+ tag: *"latest" | string
+ tagInString: tag + "dd"
+ } | {
+ op: "scratch"
+ }
+ }
+
+ foo: #Task & {"op": "pull"}
+ `,
+ json: `{"foo":{"op":"pull","tag":"latest","tagInString":"latestdd"}}`,
+ }, {
+ // Issue #326
+ value: `x: "\(string)": "v"`,
+ err: `x: incomplete value 'string' in interpolation`,
+ }, {
+ // Issue #326
+ value: `x: "\(bool)": "v"`,
+ err: `x: expression in interpolation must evaluate to a number kind or string (found bool)`,
+ }, {
+ // Issue #326
+ value: `
+ x: {
+ for k, v in y {
+ "\(k)": v
+ }
+ }
+ y: {}
+ `,
+ json: `{"x":{},"y":{}}`,
+ }, {
+ // Issue #326
+ value: `
+ x: {
+ for k, v in y {
+ "\(k)": v
+ }
+ }
+ y: _
+ `,
+ err: `x: incomplete feed source`,
+ }}
+ for i, tc := range testCases {
+ t.Run(fmt.Sprintf("%d/%v", i, tc.value), func(t *testing.T) {
+ inst := getInstance(t, tc.value)
+ b, err := inst.Value().MarshalJSON()
+ checkFatal(t, err, tc.err, "init")
+
+ if got := string(b); got != tc.json {
+ t.Errorf("\n got %v;\nwant %v", got, tc.json)
+ }
+ })
+ }
+}
+
+func TestWalk(t *testing.T) {
+ testCases := []struct {
+ value string
+ out string
+ }{{
+ value: `""`,
+ out: `""`,
+ }, {
+ value: `null`,
+ out: `null`,
+ }, {
+ value: `_|_`,
+ out: "_|_(from source)",
+ }, {
+ value: `(a.b)
+ a: {}`,
+ out: `_|_(undefined field "b")`,
+ }, {
+ value: `true`,
+ out: `true`,
+ }, {
+ value: `false`,
+ out: `false`,
+ }, {
+ value: `bool`,
+ out: "bool",
+ }, {
+ value: `"str"`,
+ out: `"str"`,
+ }, {
+ value: `12_000`,
+ out: `12000`,
+ }, {
+ value: `12.000`,
+ out: `12.000`,
+ }, {
+ value: `12M`,
+ out: `12000000`,
+ }, {
+ value: `3.0e100`,
+ out: `3.0e+100`,
+ }, {
+ value: `[]`,
+ out: `[]`,
+ }, {
+ value: `[1, 2, 3]`,
+ out: `[1,2,3]`,
+ }, {
+ value: `[int]`,
+ out: `[int]`,
+ }, {
+ value: `3 * [1, 2]`,
+ out: `[1,2,1,2,1,2]`,
+ }, {
+ value: `{}`,
+ out: `{}`,
+ }, {
+ value: `{a: 2, b: 3, c: ["A", "B"]}`,
+ out: `{a:2,b:3,c:["A","B"]}`,
+ }}
+ for i, tc := range testCases {
+ t.Run(fmt.Sprintf("%d/%v", i, tc.value), func(t *testing.T) {
+ inst := getInstance(t, tc.value)
+ buf := []byte{}
+ stripComma := func() {
+ if n := len(buf) - 1; buf[n] == ',' {
+ buf = buf[:n]
+ }
+ }
+ inst.Value().Walk(func(v Value) bool {
+ if k, ok := v.Label(); ok {
+ buf = append(buf, k+":"...)
+ }
+ switch v.Kind() {
+ case StructKind:
+ buf = append(buf, '{')
+ case ListKind:
+ buf = append(buf, '[')
+ default:
+ buf = append(buf, fmt.Sprint(v, ",")...)
+ }
+ return true
+ }, func(v Value) {
+ switch v.Kind() {
+ case StructKind:
+ stripComma()
+ buf = append(buf, "},"...)
+ case ListKind:
+ stripComma()
+ buf = append(buf, "],"...)
+ }
+ })
+ stripComma()
+ if got := string(buf); got != tc.out {
+ t.Errorf("\n got %v;\nwant %v", got, tc.out)
+ }
+ })
+ }
+}
+
+func TestTrimZeros(t *testing.T) {
+ testCases := []struct {
+ in string
+ out string
+ }{
+ {"", ""},
+ {"2", "2"},
+ {"2.0", "2.0"},
+ {"2.000000000000", "2.0"},
+ {"2000000000000", "2e+12"},
+ {"2000000", "2e+6"},
+ }
+ for _, tc := range testCases {
+ t.Run(tc.in, func(t *testing.T) {
+ if got := trimZeros(tc.in); got != tc.out {
+ t.Errorf("got %q; want %q", got, tc.out)
+ }
+ })
+ }
+}
+
+func TestReference(t *testing.T) {
+ testCases := []struct {
+ input string
+ want string
+ }{{
+ input: "v: w: x: _|_",
+ want: "",
+ }, {
+ input: "v: w: x: 2",
+ want: "",
+ }, {
+ input: "v: w: x: a, a: 1",
+ want: "a",
+ }, {
+ input: "v: w: x: a.b.c, a: b: c: 1",
+ want: "a b c",
+ }, {
+ input: "v: w: x: w.a.b.c, v: w: a: b: c: 1",
+ want: "v w a b c",
+ }, {
+ input: `v: w: x: w.a.b.c, v: w: a: b: c: 1, #D: 3, opt?: 3, "v\(#D)": 3, X: {a: 3}, X`,
+ want: "v w a b c",
+ }, {
+ input: `v: w: x: w.a[bb]["c"], v: w: a: b: c: 1, bb: "b"`,
+ want: "v w a b c",
+ }, {
+ input: `v: {
+ for t in src {
+ w: "t\(t)": 1
+ w: "\(t)": w["t\(t)"]
+ }
+ },
+ src: ["x", "y"]`,
+ want: "v w tx",
+ }, {
+ input: `
+ v: w: x: a
+ a: 1
+ for i in [] {
+ }
+ `,
+ want: "a",
+ }, {
+ input: `
+ v: w: close({x: a})
+ a: 1
+ `,
+ want: "a",
+ }}
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ var r Runtime
+ inst, _ := r.Compile("in", tc.input) // getInstance(t, tc.input)
+ v := inst.Lookup("v", "w", "x")
+ inst, a := v.Reference()
+ if got := strings.Join(a, " "); got != tc.want {
+ t.Errorf("\n got %v;\nwant %v", got, tc.want)
+ }
+
+ if tc.want != "" {
+ v := inst.Lookup(a...)
+ if x, _ := v.Int64(); x != 1 {
+ t.Errorf("path resolved to %s; want 1", v)
+ }
+ }
+ })
+ }
+}
+
+func TestPathCorrection(t *testing.T) {
+ testCases := []struct {
+ input string
+ lookup func(i *Instance) Value
+ want string
+ skip bool
+ }{{
+ input: `
+ a: b: {
+ c: d: b
+ }
+ `,
+ lookup: func(i *Instance) Value {
+ _, a := i.Lookup("a", "b", "c", "d").Expr()
+ return a[0].Lookup("b", "c", "d")
+ },
+ want: "a.b",
+ }, {
+ input: `
+ a: {
+ c: 3
+ {x: c}
+ }
+ `,
+ lookup: func(i *Instance) Value {
+ _, a := i.Lookup("a").Expr()
+ return a[1].Lookup("x")
+ },
+ want: "a.c",
+ }, {
+ input: `
+ a: b: [...T]
+ a: b: [...T]
+ T: 1
+ `,
+ lookup: func(i *Instance) Value {
+ v, _ := i.Lookup("a", "b").Elem()
+ _, a := v.Expr()
+ return a[0]
+ },
+ want: "T",
+ }, {
+ input: `
+ #S: {
+ b?: [...#T]
+ b?: [...#T]
+ }
+ #T: int
+ `,
+ lookup: func(i *Instance) Value {
+ v := i.LookupDef("#S")
+ f, _ := v.LookupField("b")
+ v, _ = f.Value.Elem()
+ _, a := v.Expr()
+ return a[0]
+ },
+ want: "#T",
+ }, {
+ input: `
+ #a: {
+ #T: {b: 3}
+ close({}) | close({c: #T}) | close({d: string})
+ }
+ `,
+ lookup: func(i *Instance) Value {
+ f, _ := i.LookupField("#a")
+ _, a := f.Value.Expr() // &
+ _, a = a[1].Expr() // |
+ return a[1].Lookup("c")
+ },
+ want: "#a.#T",
+ }, {
+ input: `
+ package foo
+
+ #Struct: {
+ #T: int
+
+ {b?: #T}
+ }`,
+ want: "#Struct.#T",
+ lookup: func(inst *Instance) Value {
+ // Locate Struct
+ i, _ := inst.Value().Fields(Definitions(true))
+ if !i.Next() {
+ t.Fatal("no fields")
+ }
+ // Locate b
+ i, _ = i.Value().Fields(Definitions(true), Optional(true))
+ if !(i.Next() && i.Next()) {
+ t.Fatal("no fields")
+ }
+ v := i.Value()
+ return v
+ },
+ }, {
+ input: `
+ package foo
+
+ #A: #B: #T
+
+ #T: {
+ a: #S.#U
+ #S: #U: {}
+ }
+ `,
+ want: "#T.#S.#U",
+ lookup: func(inst *Instance) Value {
+ f, _ := inst.Value().LookupField("#A")
+ f, _ = f.Value.LookupField("#B")
+ v := f.Value
+ v = Dereference(v)
+ v = v.Lookup("a")
+ return v
+ },
+ }, {
+ input: `
+ package foo
+
+ #A: #B: #T
+
+ #T: {
+ a: [...#S]
+ #S: {}
+ }
+ `,
+ want: "#T.#S",
+ lookup: func(inst *Instance) Value {
+ f, _ := inst.Value().LookupField("#A")
+ f, _ = f.Value.LookupField("#B")
+ v := f.Value
+ v = Dereference(v)
+ v, _ = v.Lookup("a").Elem()
+ return v
+ },
+ }, {
+ input: `
+ #A: {
+ b: #T
+ }
+
+ #T: {
+ a: #S
+ #S: {}
+ }
+ `,
+ want: "#T.#S",
+ lookup: func(inst *Instance) Value {
+ f, _ := inst.Value().LookupField("#A")
+ v := f.Value.Lookup("b")
+ v = Dereference(v)
+ v = v.Lookup("a")
+ return v
+ },
+ }, {
+ // TODO(eval): embedded structs are currently represented at the same
+ // level as the enclosing struct. This means that the parent of an
+ // embedded struct skips the struct in which it is embedded. Treat
+ // embedded structs as "anonymous" fields.
+ // This could perhaps be made fixed with dereferencing as well.
+ skip: true,
+ input: `
+ #Tracing: {
+ #T: { address?: string }
+ #S: { ip?: string }
+
+ close({}) | close({
+ t: #T
+ }) | close({
+ s: S
+ })
+ }
+ #X: {}
+ #X // Disconnect top-level struct from the one visible by close.
+ `,
+ want: "",
+ lookup: func(inst *Instance) Value {
+ f, _ := inst.Value().LookupField("#Tracing")
+ v := f.Value.Eval()
+ _, args := v.Expr()
+ v = args[1].Lookup("t")
+ v = Dereference(v)
+ return v
+ },
+ }}
+ for _, tc := range testCases {
+ if tc.skip {
+ continue
+ }
+ t.Run("", func(t *testing.T) {
+ var r Runtime
+ inst, err := r.Compile("in", tc.input)
+ if err != nil {
+ t.Fatal(err)
+ }
+ v := tc.lookup(inst)
+ gotInst, ref := v.Reference()
+ if gotInst != inst {
+ t.Error("reference not in original instance")
+ }
+ gotPath := strings.Join(ref, ".")
+ if gotPath != tc.want {
+ t.Errorf("got path %s; want %s", gotPath, tc.want)
+ }
+ })
+ }
+}
+
+func TestReferences(t *testing.T) {
+ config1 := `
+ a: {
+ b: 3
+ }
+ c: {
+ d: a.b
+ e: c.d
+ f: a
+ }
+ `
+ config2 := `
+ a: { c: 3 }
+ b: { c: int, d: 4 }
+ r: (a & b).c
+ c: {args: s1 + s2}.args
+ s1: string
+ s2: string
+ d: ({arg: b}).arg.c
+ e: f.arg.c
+ f: {arg: b}
+ `
+ testCases := []struct {
+ config string
+ in string
+ out string
+ }{
+ {config1, "c.d", "a.b"},
+ {config1, "c.e", "c.d"},
+ {config1, "c.f", "a"},
+
+ {config2, "r", "a.c b.c"},
+ {config2, "c", "s1 s2"},
+ // {config2, "d", "b.c"}, // TODO: make this work as well.
+ {config2, "e", "f.arg.c"}, // TODO: should also report b.c.
+ }
+ for _, tc := range testCases {
+ t.Run(tc.in, func(t *testing.T) {
+ ctx, st := compileFile(t, tc.config)
+ v := newValueRoot(ctx, st)
+ for _, k := range strings.Split(tc.in, ".") {
+ obj, err := v.structValFull(ctx)
+ if err != nil {
+ t.Fatal(err)
+ }
+ v = obj.Lookup(k)
+ }
+ got := []string{}
+ for _, r := range v.References() {
+ got = append(got, strings.Join(r, "."))
+ }
+ want := strings.Split(tc.out, " ")
+ if !reflect.DeepEqual(got, want) {
+ t.Errorf("got %v; want %v", got, want)
+ }
+ })
+ }
+}
+
+func checkErr(t *testing.T, err error, str, name string) bool {
+ t.Helper()
+ if err == nil {
+ if str != "" {
+ t.Errorf(`err:%s: got ""; want %q`, name, str)
+ }
+ return true
+ }
+ return checkFailed(t, err, str, name)
+}
+
+func checkFatal(t *testing.T, err error, str, name string) {
+ t.Helper()
+ if !checkFailed(t, err, str, name) {
+ t.SkipNow()
+ }
+}
+
+func checkFailed(t *testing.T, err error, str, name string) bool {
+ t.Helper()
+ if err != nil {
+ got := err.Error()
+ if str == "" {
+ t.Fatalf(`err:%s: got %q; want ""`, name, got)
+ }
+ if !strings.Contains(got, str) {
+ t.Errorf(`err:%s: got %q; want %q`, name, got, str)
+ }
+ return false
+ }
+ return true
+}
+
+func TestExpr(t *testing.T) {
+ testCases := []struct {
+ input string
+ want string
+ }{{
+ input: "v: 3",
+ want: "3",
+ }, {
+ input: "v: 3 + 4",
+ want: "+(3 4)",
+ }, {
+ input: "v: !a, a: 3",
+ want: `!(.(<0> "a"))`,
+ }, {
+ input: "v: 1 | 2 | 3 | *4",
+ want: "|(1 2 3 4)",
+ }, {
+ input: "v: 2 & 5",
+ want: "&(2 5)",
+ }, {
+ input: "v: 2 | 5",
+ want: "|(2 5)",
+ }, {
+ input: "v: 2 && 5",
+ want: "&&(2 5)",
+ }, {
+ input: "v: 2 || 5",
+ want: "||(2 5)",
+ }, {
+ input: "v: 2 == 5",
+ want: "==(2 5)",
+ }, {
+ input: "v: !b, b: true",
+ want: `!(.(<0> "b"))`,
+ }, {
+ input: "v: 2 != 5",
+ want: "!=(2 5)",
+ }, {
+ input: "v: <5",
+ want: "<(5)",
+ }, {
+ input: "v: 2 <= 5",
+ want: "<=(2 5)",
+ }, {
+ input: "v: 2 > 5",
+ want: ">(2 5)",
+ }, {
+ input: "v: 2 >= 5",
+ want: ">=(2 5)",
+ }, {
+ input: "v: 2 =~ 5",
+ want: "=~(2 5)",
+ }, {
+ input: "v: 2 !~ 5",
+ want: "!~(2 5)",
+ }, {
+ input: "v: 2 + 5",
+ want: "+(2 5)",
+ }, {
+ input: "v: 2 - 5",
+ want: "-(2 5)",
+ }, {
+ input: "v: 2 * 5",
+ want: "*(2 5)",
+ }, {
+ input: "v: 2 / 5",
+ want: "/(2 5)",
+ }, {
+ input: "v: 2 quo 5",
+ want: "quo(2 5)",
+ }, {
+ input: "v: 2 rem 5",
+ want: "rem(2 5)",
+ }, {
+ input: "v: 2 div 5",
+ want: "div(2 5)",
+ }, {
+ input: "v: 2 mod 5",
+ want: "mod(2 5)",
+ }, {
+ input: "v: a.b, a: b: 4",
+ want: `.(.(<0> "a") "b")`,
+ }, {
+ input: `v: a["b"], a: b: 3 `,
+ want: `[](.(<0> "a") "b")`,
+ }, {
+ input: "v: a[2:5], a: [1, 2, 3, 4, 5]",
+ want: `[:](.(<0> "a") 2 5)`,
+ }, {
+ input: "v: len([])",
+ want: "()(len [])",
+ }, {
+ input: "v: a.b, a: { b: string }",
+ want: `.(.(<0> "a") "b")`,
+ }, {
+ input: `v: "Hello, \(x)! Welcome to \(place)", place: string, x: string`,
+ want: `\()("Hello, " .(<0> "x") "! Welcome to " .(<0> "place") "")`,
+ }, {
+ input: `v: { a, b: 1 }, a: 2`,
+ want: `&(<0>{b: 1} .(<0> "a"))`,
+ }, {
+ input: `v: { {c: a}, b: a }, a: int`,
+ want: `&(<0>{b: <1>.a} <0>{c: <1>.a})`,
+ }, {
+ input: `v: [...number] | *[1, 2, 3]`,
+ want: `([, ...number] | *[1,2,3])`,
+ }}
+ for _, tc := range testCases {
+ t.Run(tc.input, func(t *testing.T) {
+ v := getInstance(t, tc.input).Lookup("v")
+ got := exprStr(v)
+ if got != tc.want {
+ t.Errorf("\n got %v;\nwant %v", got, tc.want)
+ }
+ })
+ }
+}
+func exprStr(v Value) string {
+ op, operands := v.Expr()
+ if op == NoOp {
+ return debugStr(v.ctx(), v.v.v)
+ }
+ s := op.String()
+ s += "("
+ for i, v := range operands {
+ if i > 0 {
+ s += " "
+ }
+ s += exprStr(v)
+ }
+ s += ")"
+ return s
+}
diff --git a/tmp.cue b/tmp.cue
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tmp.cue
