internal/legacy/cue: update to new build
Change-Id: I11752ef0df425970ca96dda73d362e10250d7059
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/6519
Reviewed-by: Marcel van Lohuizen <mpvl@golang.org>
diff --git a/internal/core/convert/go.go b/internal/core/convert/go.go
index 8aeca32..f84ff9f 100644
--- a/internal/core/convert/go.go
+++ b/internal/core/convert/go.go
@@ -33,8 +33,10 @@
"cuelang.org/go/cue/errors"
"cuelang.org/go/cue/parser"
"cuelang.org/go/cue/token"
+ "cuelang.org/go/internal"
"cuelang.org/go/internal/core/adt"
"cuelang.org/go/internal/core/compile"
+ "cuelang.org/go/internal/core/runtime"
)
// This file contains functionality for converting Go to CUE.
@@ -220,6 +222,15 @@
}
func convertRec(ctx *adt.OpContext, nilIsTop bool, x interface{}) adt.Value {
+ if internal.CoreValue != nil {
+ if ii, iv := internal.CoreValue(x); ii != nil {
+ i := ii.(*runtime.Index)
+ v := iv.(*adt.Vertex)
+ // TODO: panic if nto the same runtime.
+ _ = i
+ return v
+ }
+ }
src := ctx.Source()
switch v := x.(type) {
case nil:
diff --git a/internal/core/convert/go_test.go b/internal/core/convert/go_test.go
index 21492c2..88db590 100644
--- a/internal/core/convert/go_test.go
+++ b/internal/core/convert/go_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package convert
+package convert_test
import (
"math/big"
@@ -25,9 +25,11 @@
"cuelang.org/go/cue/errors"
"cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/convert"
"cuelang.org/go/internal/core/debug"
"cuelang.org/go/internal/core/eval"
"cuelang.org/go/internal/core/runtime"
+ _ "cuelang.org/go/internal/legacy/cue" // set internal.CoreValue
)
func mkBigInt(a int64) (v apd.Decimal) { v.SetInt64(a); return }
@@ -187,7 +189,7 @@
e := eval.New(r)
ctx := adt.NewContext(r, e, &adt.Vertex{})
t.Run("", func(t *testing.T) {
- v := GoValueToValue(ctx, tc.goVal, true)
+ v := convert.GoValueToValue(ctx, tc.goVal, true)
got := debug.NodeString(ctx, v, nil)
if got != tc.want {
t.Error(cmp.Diff(got, tc.want))
@@ -205,7 +207,7 @@
e := eval.New(r)
ctx := adt.NewContext(r, e, &adt.Vertex{})
- v := GoValueToValue(ctx, x, false)
+ v := convert.GoValueToValue(ctx, x, false)
// if err != nil {
// t.Fatal(err)
// }
@@ -327,7 +329,7 @@
t.Run("", func(t *testing.T) {
e := eval.New(r)
ctx := adt.NewContext(r, e, &adt.Vertex{})
- v, _ := GoTypeToExpr(ctx, tc.goTyp)
+ v, _ := convert.GoTypeToExpr(ctx, tc.goTyp)
got := debug.NodeString(ctx, v, nil)
if got != tc.want {
t.Errorf("\n got %q;\nwant %q", got, tc.want)
diff --git a/internal/internal.go b/internal/internal.go
index 8585992..d4e31dc 100644
--- a/internal/internal.go
+++ b/internal/internal.go
@@ -77,6 +77,10 @@
// GetRuntime reports the runtime for an Instance or Value.
var GetRuntimeNew func(instance interface{}) interface{}
+// CoreValue returns an *runtime.Index and *adt.Vertex for a cue.Value.
+// It returns nil if value is not a cue.Value.
+var CoreValue func(value interface{}) (runtime, vertex interface{})
+
// MakeInstance makes a new instance from a value.
var MakeInstance func(value interface{}) (instance interface{})
diff --git a/internal/legacy/cue/alias.go b/internal/legacy/cue/alias.go
index ee438fc..83146a6 100644
--- a/internal/legacy/cue/alias.go
+++ b/internal/legacy/cue/alias.go
@@ -19,34 +19,34 @@
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
+ 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
+ disjunction = adt.DisjunctionExpr
+ dValue = adt.Disjunct
+ customValidator = adt.BuiltinValidator
)
const (
@@ -61,9 +61,4 @@
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
index 9f86daf..65f0932 100644
--- a/internal/legacy/cue/build.go
+++ b/internal/legacy/cue/build.go
@@ -15,6 +15,7 @@
package cue
import (
+ "strings"
"sync"
"cuelang.org/go/cue/ast"
@@ -23,6 +24,8 @@
"cuelang.org/go/cue/errors"
"cuelang.org/go/cue/token"
"cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/compile"
"cuelang.org/go/internal/core/runtime"
)
@@ -38,7 +41,7 @@
}
func init() {
- internal.GetRuntime = func(instance interface{}) interface{} {
+ internal.GetRuntimeNew = func(instance interface{}) interface{} {
switch x := instance.(type) {
case Value:
return &Runtime{idx: x.idx}
@@ -51,7 +54,7 @@
}
}
- internal.CheckAndForkRuntime = func(runtime, value interface{}) interface{} {
+ internal.CheckAndForkRuntimeNew = func(runtime, value interface{}) interface{} {
r := runtime.(*Runtime)
idx := value.(Value).ctx().index
if idx != r.idx {
@@ -59,6 +62,13 @@
}
return &Runtime{idx: newIndex(idx)}
}
+
+ internal.CoreValue = func(value interface{}) (runtime, vertex interface{}) {
+ if v, ok := value.(Value); ok && v.v != nil {
+ return v.idx.Index, v.v
+ }
+ return nil, nil
+ }
}
func dummyLoad(token.Pos, string) *build.Instance { return nil }
@@ -192,6 +202,7 @@
//
// All instances belonging to the same package should share this index.
type index struct {
+ adt.Runtime
*runtime.Index
loaded map[*build.Instance]*Instance
@@ -201,16 +212,35 @@
// 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{},
+ Runtime: runtime.SharedRuntimeNew,
+ Index: runtime.SharedIndexNew,
+ loaded: map[*build.Instance]*Instance{},
+}
+
+// NewRuntime creates a *runtime.Runtime with builtins preloaded.
+func NewRuntime() *runtime.Runtime {
+ idx := runtime.NewIndex(sharedIndex.Index)
+ r := runtime.NewWithIndex(idx)
+ i := &index{
+ Runtime: r,
+ Index: idx,
+ loaded: map[*build.Instance]*Instance{},
+ }
+ r.Data = i
+ return r
}
// newIndex creates a new index.
func newIndex(parent *index) *index {
- return &index{
- Index: runtime.NewIndex(parent.Index),
- loaded: map[*build.Instance]*Instance{},
+ idx := runtime.NewIndex(parent.Index)
+ r := runtime.NewWithIndex(idx)
+ i := &index{
+ Runtime: r,
+ Index: idx,
+ loaded: map[*build.Instance]*Instance{},
}
+ r.Data = i
+ return i
}
func isBuiltin(s string) bool {
@@ -219,30 +249,93 @@
}
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")
+ _ = visitInstances(p, func(p *build.Instance, errs errors.Error) errors.Error {
+ 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.Err
}
- 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
+ err := runtime.ResolveFiles(idx.Index, p, isBuiltin)
+ errs = errors.Append(errs, err)
+
+ v, err := compile.Files(nil, idx.Runtime, p.Files...)
+ errs = errors.Append(errs, err)
+
+ inst := newInstance(idx, p, v)
+ idx.loaded[p] = inst
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.Err
+ })
+
+ return idx.loaded[p]
+}
+
+// TODO: runtime.Runtime has a similar, much simpler, implementation. This
+// code should go.
+
+type visitFunc func(b *build.Instance, err errors.Error) (errs errors.Error)
+
+// visitInstances calls f for each transitive dependency.
+//
+// It passes any errors that occur in transitive dependencies to the visitFunc.
+// visitFunc must return the errors it is passed or return nil to ignore it.
+func visitInstances(b *build.Instance, f visitFunc) (errs errors.Error) {
+ v := visitor{b: b, f: f, errs: b.Err}
+ for _, file := range b.Files {
+ v.file(file)
+ }
+ return v.f(b, v.errs)
+}
+
+type visitor struct {
+ b *build.Instance
+ f visitFunc
+ errs errors.Error
+}
+
+func (v *visitor) addErr(e errors.Error) {
+ v.errs = errors.Append(v.errs, e)
+}
+
+func (v *visitor) file(file *ast.File) {
+ for _, d := range file.Decls {
+ switch x := d.(type) {
+ case *ast.Package:
+ case *ast.ImportDecl:
+ for _, s := range x.Specs {
+ v.spec(s)
+ }
+ case *ast.CommentGroup:
+ default:
+ return
}
}
- inst.ImportPath = p.ImportPath
+}
- inst.complete = true
- return inst
+func (v *visitor) spec(spec *ast.ImportSpec) {
+ info, err := astutil.ParseImportSpec(spec)
+ if err != nil {
+ v.addErr(errors.Promote(err, "invalid import path"))
+ return
+ }
+
+ pkg := v.b.LookupImport(info.ID)
+ if pkg == nil {
+ if strings.Contains(info.ID, ".") {
+ v.addErr(errors.Newf(spec.Pos(),
+ "package %q imported but not defined in %s",
+ info.ID, v.b.ImportPath))
+ }
+ return
+ }
+
+ v.addErr(visitInstances(pkg, v.f))
}
diff --git a/internal/legacy/cue/build_test.go b/internal/legacy/cue/build_test.go
index 7817ec7..4cf0ccb 100644
--- a/internal/legacy/cue/build_test.go
+++ b/internal/legacy/cue/build_test.go
@@ -16,12 +16,12 @@
import (
"fmt"
- "strings"
"testing"
"cuelang.org/go/cue/ast"
"cuelang.org/go/cue/build"
"cuelang.org/go/cue/token"
+ "cuelang.org/go/internal/core/debug"
)
func TestFromExpr(t *testing.T) {
@@ -36,7 +36,7 @@
ast.NewString("Hello"),
ast.NewString("World"),
),
- out: `["Hello","World"]`,
+ out: `["Hello", "World"]`,
}}
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
@@ -45,8 +45,7 @@
if err != nil {
t.Fatal(err)
}
- ctx := inst.newContext()
- if got := debugStr(ctx, inst.eval(ctx)); got != tc.out {
+ if got := fmt.Sprint(inst.Value()); got != tc.out {
t.Errorf("\n got: %v; want %v", got, tc.out)
}
})
@@ -86,7 +85,7 @@
emit string
}{{
insts(&bimport{"", files(`test: "ok"`)}),
- `{test: "ok"}`,
+ `{test:"ok"}`,
}, {
insts(&bimport{"",
files(
@@ -200,7 +199,8 @@
if err := insts[0].Err; err != nil {
got = err.Error()
} else {
- got = strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+ cfg := &debug.Config{Compact: true}
+ got = debug.NodeString(insts[0].Index, insts[0].Value().v, cfg)
}
if got != tc.emit {
t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
diff --git a/internal/legacy/cue/builtin.go b/internal/legacy/cue/builtin.go
index cfd98a6..79b4a75 100644
--- a/internal/legacy/cue/builtin.go
+++ b/internal/legacy/cue/builtin.go
@@ -33,6 +33,10 @@
"cuelang.org/go/cue/parser"
"cuelang.org/go/cue/token"
"cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/compile"
+ "cuelang.org/go/internal/core/convert"
+ "cuelang.org/go/internal/core/runtime"
)
// A builtin is a builtin function or constant.
@@ -54,7 +58,6 @@
// map[string]T
//
type builtin struct {
- baseValue
Name string
pkg label
Params []kind
@@ -69,21 +72,27 @@
cue string
}
-func mustCompileBuiltins(ctx *context, p *builtinPkg, pkgName string) *structLit {
- obj := &structLit{}
+func mustCompileBuiltins(ctx *context, p *builtinPkg, pkgName string) *adt.Vertex {
+ obj := &adt.Vertex{}
pkgLabel := ctx.Label(pkgName, false)
+ st := &adt.StructLit{}
+ if len(p.native) > 0 {
+ obj.AddConjunct(adt.MakeConjunct(nil, st))
+ }
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
+ var v adt.Expr = toBuiltin(ctx, b)
if b.Const != "" {
v = mustParseConstBuiltin(ctx, b.Name, b.Const)
}
- obj.Arcs = append(obj.Arcs, arc{Label: f, v: v})
+ st.Decls = append(st.Decls, &adt.Field{
+ Label: f,
+ Value: v,
+ })
}
- sort.Sort(obj)
// Parse builtin CUE
if p.cue != "" {
@@ -91,32 +100,77 @@
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)
+ c, err := compile.Expr(nil, ctx.opCtx.Runtime, expr)
+ if err != nil {
+ panic(fmt.Errorf("could compile parse %v: %v", p.cue, err))
}
+ obj.AddConjunct(c)
+ }
+
+ // We could compile lazily, but this is easier for debugging.
+ obj.Finalize(ctx.opCtx)
+ if err := obj.Err(ctx.opCtx, adt.Finalized); err != nil {
+ panic(err.Err)
}
return obj
}
+func toBuiltin(ctx *context, b *builtin) *adt.Builtin {
+ x := &adt.Builtin{
+ Params: b.Params,
+ Result: b.Result,
+ Package: b.pkg,
+ Name: b.Name,
+ }
+ x.Func = func(ctx *adt.OpContext, args []adt.Value) (ret adt.Expr) {
+ runtime := ctx.Impl().(*runtime.Runtime)
+ index := runtime.Data.(*index)
+
+ // call, _ := ctx.Source().(*ast.CallExpr)
+ c := &callCtxt{
+ idx: index,
+ // src: call,
+ ctx: index.newContext(),
+ args: args,
+ builtin: b,
+ }
+ defer func() {
+ var errVal interface{} = c.err
+ if err := recover(); err != nil {
+ errVal = err
+ }
+ ret = processErr(c, errVal, ret)
+ }()
+ b.Func(c)
+ switch v := c.ret.(type) {
+ case adt.Value:
+ return v
+ case *valueError:
+ return v.err
+ }
+ if c.err != nil {
+ return nil
+ }
+ return convert.GoValueToValue(ctx, c.ret, true)
+ }
+ return x
+}
+
// newConstBuiltin parses and creates any CUE expression that does not have
// fields.
-func mustParseConstBuiltin(ctx *context, name, val string) evaluated {
+func mustParseConstBuiltin(ctx *context, name, val string) adt.Expr {
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)
-}
+ c, err := compile.Expr(nil, ctx.Runtime, expr)
+ if err != nil {
+ panic(err)
+ }
+ return c.Expr()
-var _ caller = &builtin{}
+}
var lenBuiltin = &builtin{
Name: "len",
@@ -163,17 +217,34 @@
},
}
+func pos(n adt.Node) (p token.Pos) {
+ if n == nil {
+ return
+ }
+ src := n.Source()
+ if src == nil {
+ return
+ }
+ return src.Pos()
+}
+
var closeBuiltin = &builtin{
Name: "close",
Params: []kind{structKind},
Result: structKind,
Func: func(c *callCtxt) {
- s, ok := c.args[0].(*structLit)
+ s, ok := c.args[0].(*adt.Vertex)
if !ok {
- c.ret = errors.Newf(c.args[0].Pos(), "struct argument must be concrete")
+ c.ret = errors.Newf(pos(c.args[0]), "struct argument must be concrete")
return
}
- c.ret = s.close()
+ if s.IsClosed(c.ctx.opCtx) {
+ c.ret = s
+ } else {
+ v := *s
+ v.Closed = nil // TODO: set dedicated Closer.
+ c.ret = &v
+ }
},
}
@@ -184,12 +255,12 @@
Func: func(c *callCtxt) {
iter := c.iter(0)
if !iter.Next() {
- c.ret = &top{baseValue{c.src}}
+ c.ret = &top{}
return
}
- u := iter.Value().v.v
+ var u adt.Expr = iter.Value().v
for iter.Next() {
- u = mkBin(c.ctx, c.src.Pos(), opUnify, u, iter.Value().v.v)
+ u = &adt.BinaryExpr{Op: adt.AndOp, X: u, Y: iter.Value().v}
}
c.ret = u
},
@@ -201,11 +272,11 @@
Result: intKind,
Func: func(c *callCtxt) {
iter := c.iter(0)
- d := []dValue{}
+ d := []adt.Disjunct{}
for iter.Next() {
- d = append(d, dValue{iter.Value().v.v, false})
+ d = append(d, adt.Disjunct{iter.Value().v, false})
}
- c.ret = &disjunction{baseValue{c.src}, d, nil, false}
+ c.ret = &adt.DisjunctionExpr{nil, d, false}
if len(d) == 0 {
// TODO(manifest): This should not be unconditionally incomplete,
// but it requires results from comprehensions and all to have
@@ -214,33 +285,14 @@
// 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")
+ c.ret = &adt.Bottom{
+ Code: adt.IncompleteError,
+ Err: errors.Newf(c.Pos(), "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
@@ -252,61 +304,9 @@
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 {
+func processErr(call *callCtxt, errVal interface{}, ret adt.Expr) adt.Expr {
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:
@@ -316,30 +316,92 @@
ret = err.b
}
case *marshalError:
- ret = err.b
- ret = ctx.mkErr(src, x, ret, msg, x.name(ctx), err)
+ ret = wrapCallErr(call, err.b)
case *valueError:
- ret = err.err
- ret = ctx.mkErr(src, x, ret, msg, x.name(ctx), err)
- default:
+ ret = wrapCallErr(call, err.err)
+ case errors.Error:
+ ret = wrapCallErr(call, &adt.Bottom{Err: err})
+ case error:
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)
+ ret = wrapCallErr(call, &adt.Bottom{Err: errors.Promote(err, "")})
}
+ default:
+ // Likely a string passed to panic.
+ ret = wrapCallErr(call, &adt.Bottom{
+ Err: errors.Newf(call.Pos(), "%s", err),
+ })
}
return ret
}
+func wrapCallErr(c *callCtxt, b *adt.Bottom) *adt.Bottom {
+ pos := token.NoPos
+ if c.src != nil {
+ if src := c.src.Source(); src != nil {
+ pos = src.Pos()
+ }
+ }
+ const msg = "error in call to %s"
+ return &adt.Bottom{
+ Code: b.Code,
+ Err: errors.Wrapf(b.Err, pos, msg, c.builtin.name(c.ctx)),
+ }
+}
+
+func (c *callCtxt) convertError(x interface{}, name string) *adt.Bottom {
+ var err errors.Error
+ switch v := x.(type) {
+ case nil:
+ return nil
+
+ case *adt.Bottom:
+ return v
+
+ case *json.MarshalerError:
+ err = errors.Promote(v, "marshal error")
+
+ case errors.Error:
+ err = v
+
+ case error:
+ if name != "" {
+ err = errors.Newf(c.Pos(), "%s: %v", name, v)
+ } else {
+ err = errors.Newf(c.Pos(), "error in call to %s: %v", c.name(), v)
+ }
+
+ default:
+ err = errors.Newf(token.NoPos, "%s", name)
+ }
+ if err != internal.ErrIncomplete {
+ return &adt.Bottom{
+ // Wrap to preserve position information.
+ Err: errors.Wrapf(err, c.Pos(), "error in call to %s", c.name()),
+ }
+ }
+ return &adt.Bottom{
+ Code: adt.IncompleteError,
+ Err: errors.Newf(c.Pos(), "incomplete values in call to %s", c.name()),
+ }
+}
+
// callCtxt is passed to builtin implementations.
type callCtxt struct {
- src source
+ idx *index
+ src adt.Expr // *adt.CallExpr
ctx *context
builtin *builtin
- args []evaluated
- err error
+ err interface{}
ret interface{}
+
+ args []adt.Value
+}
+
+func (c *callCtxt) Pos() token.Pos {
+ return c.ctx.opCtx.Pos()
}
func (c *callCtxt) name() string {
@@ -362,8 +424,7 @@
i := sharedIndex.addInst(&Instance{
ImportPath: k,
PkgName: path.Base(k),
- rootStruct: e,
- rootValue: e,
+ root: e,
})
builtins[k] = i
@@ -380,7 +441,7 @@
if !ok {
return nil
}
- return p.rootStruct
+ return p.root
}
func init() {
@@ -394,12 +455,12 @@
if s == nil {
return v
}
- a := s.Lookup(ctx, ctx.Label(name, false))
- if a.v == nil {
+ a := s.Lookup(ctx.Label(name, false))
+ if a == nil {
return v
}
- return v.Unify(newValueRoot(ctx, a.v.evalPartial(ctx)))
+ return v.Unify(makeValue(v.idx, a))
}
}
@@ -427,12 +488,21 @@
c.err = &callError{err}
}
+func (c *callCtxt) errcf(src source, code adt.ErrorCode, format string, args ...interface{}) {
+ a := make([]interface{}, 0, 2+len(args))
+ a = append(a, code)
+ 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()
+ // TODO: remove default
+ // v, _ = v.Default()
if !v.IsConcrete() {
- c.errf(c.src, v.toErr(c.ctx.mkErr(c.src, codeIncomplete,
- "non-concrete value")), "incomplete")
+ c.errcf(c.src, adt.IncompleteError, "non-concrete argument %d", i)
}
return v
}
@@ -448,12 +518,26 @@
}
func (c *callCtxt) invalidArgType(arg value, i int, typ string, err error) {
+ if ve, ok := err.(*valueError); ok && ve.err.IsIncomplete() {
+ c.err = ve
+ return
+ }
+ v, ok := arg.(adt.Value)
+ // TODO: make these permanent errors if the value did not originate from
+ // a reference.
+ if !ok {
+ c.errf(c.src, nil,
+ "cannot use incomplete value %s as %s in argument %d to %s: %v",
+ c.ctx.str(arg), typ, i, c.name(), err)
+ }
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)
+ c.errf(c.src, err,
+ "cannot use %s (type %s) as %s in argument %d to %s: %v",
+ c.ctx.str(arg), v.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())
+ c.errf(c.src, err,
+ "cannot use %s (type %s) as %s in argument %d to %s",
+ c.ctx.str(arg), v.Kind(), typ, i, c.name())
}
}
@@ -531,6 +615,8 @@
return n
}
+var ten = big.NewInt(10)
+
func (c *callCtxt) bigFloat(i int) *big.Float {
x := newValueRoot(c.ctx, c.args[i])
var mant big.Int
@@ -646,8 +732,8 @@
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)
+ c.err = errors.Wrapf(err, c.Pos(),
+ "element %d of list argument %d", j, i)
break
}
a = append(a, str)
diff --git a/internal/legacy/cue/builtin_test.go b/internal/legacy/cue/builtin_test.go
index 1901d34..21ac694 100644
--- a/internal/legacy/cue/builtin_test.go
+++ b/internal/legacy/cue/builtin_test.go
@@ -49,7 +49,7 @@
`3`,
}, {
test("math", "math.Pi(3)"),
- `_|_(cannot call non-function Pi (type float))`,
+ `_|_(cannot call non-function math.Pi (type float))`,
}, {
test("math", "math.Floor(3, 5)"),
`_|_(too many arguments in call to math.Floor (have 2, want 1))`,
@@ -91,10 +91,10 @@
`'foo'`,
}, {
test("encoding/base64", `base64.Decode(null, "foo")`),
- `_|_(error in call to encoding/base64.Decode: illegal base64 data at input byte 0)`,
+ `_|_(error in call to encoding/base64.Decode: illegal base64 data at input byte 0 (and 1 more errors))`,
}, {
test("encoding/base64", `base64.Decode({}, "foo")`),
- `_|_(error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null)`,
+ `_|_(error in call to encoding/base64.Decode: base64: unsupported encoding: cannot use value {} (type struct) as null (and 1 more errors))`,
}, {
test("encoding/hex", `hex.Encode("foo")`),
`"666f6f"`,
@@ -103,7 +103,7 @@
`'foo'`,
}, {
test("encoding/hex", `hex.Decode("foo")`),
- `_|_(error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o')`,
+ `_|_(error in call to encoding/hex.Decode: encoding/hex: invalid byte: U+006F 'o' (and 1 more errors))`,
}, {
test("encoding/hex", `hex.Dump('foo')`),
`"00000000 66 6f 6f |foo|\n"`,
@@ -112,19 +112,19 @@
`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))`,
+ `_|_(error in call to encoding/json.Validate: invalid value 10 (out of bound <3) (and 1 more errors))`,
}, {
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))`,
+ `_|_(error in call to encoding/yaml.Validate: invalid value 4 (out of bound <3) (and 1 more errors))`,
}, {
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))`,
+ `_|_(error in call to encoding/yaml.Validate: incomplete value int (and 1 more errors))`,
}, {
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))`,
+ `_|_(error in call to encoding/yaml.ValidatePartial: invalid value 4 (out of bound <3) (and 1 more errors))`,
}, {
test("encoding/yaml", `yaml.ValidatePartial("a: 2\n---\na: 4", {a:<5})`),
`true`,
@@ -137,11 +137,11 @@
}, {
// 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)`,
+ `_|_(int 300 overflows byte in argument 1 in call to strconv.FormatFloat (and 1 more errors))`,
}, {
// 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)`,
+ `_|_(cannot use -1 (type int) as byte in argument 1 to strconv.FormatFloat (and 1 more errors))`,
}, {
// Find a better alternative, as this call should go.
test("strconv", `strconv.FormatFloat(3.02, 1.0, 4, 64)`),
@@ -151,7 +151,7 @@
`2.5`,
}, {
test("list", `list.Avg([])`),
- `_|_(error in call to list.Avg: empty list)`,
+ `_|_(error in call to list.Avg: empty list (and 1 more errors))`,
}, {
test("list", `list.Avg("foo")`),
`_|_(cannot use "foo" (type string) as list in argument 1 to list.Avg)`,
@@ -166,7 +166,7 @@
`[]`,
}, {
test("list", `list.Drop([1, 2, 3, 4], -1)`),
- `_|_(error in call to list.Drop: negative index)`,
+ `_|_(error in call to list.Drop: negative index (and 1 more errors))`,
}, {
test("list", `list.FlattenN([1, [[2, 3], []], [4]], -1)`),
`[1,2,3,4]`,
@@ -184,7 +184,7 @@
`[]`,
}, {
test("list", `list.FlattenN("foo", 1)`),
- `_|_(error in call to list.FlattenN: cannot use value "foo" (type string) as list)`,
+ `_|_(error in call to list.FlattenN: cannot use value "foo" (type string) as list (and 1 more errors))`,
}, {
test("list", `list.FlattenN([], "foo")`),
`_|_(cannot use "foo" (type string) as int in argument 2 to list.FlattenN)`,
@@ -193,7 +193,7 @@
`4`,
}, {
test("list", `list.Max([])`),
- `_|_(error in call to list.Max: empty list)`,
+ `_|_(error in call to list.Max: empty list (and 1 more errors))`,
}, {
test("list", `list.Max("foo")`),
`_|_(cannot use "foo" (type string) as list in argument 1 to list.Max)`,
@@ -202,7 +202,7 @@
`1`,
}, {
test("list", `list.Min([])`),
- `_|_(error in call to list.Min: empty list)`,
+ `_|_(error in call to list.Min: empty list (and 1 more errors))`,
}, {
test("list", `list.Min("foo")`),
`_|_(cannot use "foo" (type string) as list in argument 1 to list.Min)`,
@@ -217,13 +217,13 @@
`_|_(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)`,
+ `_|_(error in call to list.Range: step must be non zero (and 1 more errors))`,
}, {
test("list", `list.Range(5, 0, 1)`),
- `_|_(error in call to list.Range: end must be greater than start when step is positive)`,
+ `_|_(error in call to list.Range: end must be greater than start when step is positive (and 1 more errors))`,
}, {
test("list", `list.Range(0, 5, -1)`),
- `_|_(error in call to list.Range: end must be less than start when step is negative)`,
+ `_|_(error in call to list.Range: end must be less than start when step is negative (and 1 more errors))`,
}, {
test("list", `list.Range(0, 5, 1)`),
`[0,1,2,3,4]`,
@@ -244,16 +244,16 @@
`[2,3]`,
}, {
test("list", `list.Slice([1, 2, 3, 4], -1, 3)`),
- `_|_(error in call to list.Slice: negative index)`,
+ `_|_(error in call to list.Slice: negative index (and 1 more errors))`,
}, {
test("list", `list.Slice([1, 2, 3, 4], 3, 1)`),
- `_|_(error in call to list.Slice: invalid index: 3 > 1)`,
+ `_|_(error in call to list.Slice: invalid index: 3 > 1 (and 1 more errors))`,
}, {
test("list", `list.Slice([1, 2, 3, 4], 5, 5)`),
- `_|_(error in call to list.Slice: slice bounds out of range)`,
+ `_|_(error in call to list.Slice: slice bounds out of range (and 1 more errors))`,
}, {
test("list", `list.Slice([1, 2, 3, 4], 1, 5)`),
- `_|_(error in call to list.Slice: slice bounds out of range)`,
+ `_|_(error in call to list.Slice: slice bounds out of range (and 1 more errors))`,
}, {
test("list", `list.Sort([], list.Ascending)`),
`[]`,
@@ -266,16 +266,16 @@
y:_,
less: (x.a < y.a)
})`),
- `[{a: 1, v: 2},{a: 1, v: 3},{a: 2, v: 1}]`,
+ `[{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))`,
+ `_|_(error in call to list.Sort: invalid operands {b:2} and {a:1} to '<' (type struct and struct) (and 1 more errors))`,
}, {
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)`,
+ `_|_(error in call to list.SortStrings: element 0 of list argument 0: 0: cannot use value 1 (type int) as string (and 1 more errors))`,
}, {
test("list", `list.Sum([1, 2, 3, 4])`),
`10`,
@@ -296,7 +296,7 @@
`[1,2,3,4]`,
}, {
test("list", `list.Take([1, 2, 3, 4], -1)`),
- `_|_(error in call to list.Take: negative index)`,
+ `_|_(error in call to list.Take: negative index (and 1 more errors))`,
}, {
test("list", `list.MinItems([1, 2, 3, 4], 2)`),
`true`,
@@ -312,20 +312,20 @@
}, {
// 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)`,
+ `_|_(error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000 (and 1 more errors))`,
}, {
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)`,
+ `_|_(cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up (and 1 more errors))`,
}, {
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)`,
+ `_|_(error in call to math.MultipleOf: division by zero (and 1 more errors))`,
}, {
test("math", `math.MultipleOf(100, 1.00001)`), `false`,
}, {
@@ -342,7 +342,7 @@
`"foo"`,
}, {
test("regexp", `regexp.Find(#"f\w\w"#, "bar")`),
- `_|_(error in call to regexp.Find: no match)`,
+ `_|_(error in call to regexp.Find: no match (and 1 more errors))`,
}, {
test("regexp", `regexp.FindAll(#"f\w\w"#, "afoot afloat from", 2)`),
`["foo","flo"]`,
@@ -351,7 +351,7 @@
`["foo","flo"]`,
}, {
test("regexp", `regexp.FindAll(#"f\w\w"#, "bla bla", -1)`),
- `_|_(error in call to regexp.FindAll: no match)`,
+ `_|_(error in call to regexp.FindAll: no match (and 1 more errors))`,
}, {
test("regexp", `regexp.FindSubmatch(#"f(\w)(\w)"#, "afloat afoot from")`),
`["flo","l","o"]`,
@@ -360,19 +360,19 @@
`[["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)`,
+ `_|_(error in call to regexp.FindAllSubmatch: no match (and 1 more errors))`,
}, {
test("regexp", `regexp.FindNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "afloat afoot from")`),
- `{A: "l", B: "o"}`,
+ `{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"}]`,
+ `[{A:"l",B:"o"},{A:"o",B:"o"},{A:"r",B:"o"}]`,
}, {
test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>optional)?"#, "fbla", -1)`),
- `[{A: ""}]`,
+ `[{A:""}]`,
}, {
test("regexp", `regexp.FindAllNamedSubmatch(#"f(?P<A>\w)(?P<B>\w)"#, "aglom", -1)`),
- `_|_(error in call to regexp.FindAllNamedSubmatch: no match)`,
+ `_|_(error in call to regexp.FindAllNamedSubmatch: no match (and 1 more errors))`,
}, {
test("regexp", `regexp.Valid & "valid"`),
`"valid"`,
@@ -387,7 +387,7 @@
`"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)`,
+ `_|_(error in call to strings.Join: element 0 of list argument 0: 0: cannot use value 1 (type int) as string (and 1 more errors))`,
}, {
test("strings", `strings.ByteAt("a", 0)`),
strconv.Itoa('a'),
@@ -432,7 +432,7 @@
`2`,
}, {
testExpr(`or([])`),
- `_|_(empty list in call to or)`,
+ `_|_(empty list in call to or (and 1 more errors))`,
}, {
test("encoding/csv", `csv.Encode([[1,2,3],[4,5],[7,8,9]])`),
`"1,2,3\n4,5\n7,8,9\n"`,
@@ -459,7 +459,7 @@
x: int
y: json.Marshal({a: x})
}`),
- `{x: int, y: Marshal ({a: x})}`,
+ `{x:int,y:_|_(cannot convert incomplete value "int" to JSON (and 1 more errors))}`,
}, {
test("encoding/yaml", `yaml.MarshalStream([{a: 1}, {b: 2}])`),
`"a: 1\n---\nb: 2\n"`,
@@ -482,14 +482,15 @@
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])`,
+ // TODO: why is this not printing compactly?
+ test("net", `net.JoinHostPort([192, 30, 4], 80)`),
+ `_|_(error in call to net.JoinHostPort: invalid host [192, 30, 4] (and 1 more errors))`,
}, {
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()))`,
+ `_|_(invalid value "23.23.23.2333" (does not satisfy net.IPv4))`,
}, {
test("net", `net.IP("23.23.23.23")`),
`true`,
@@ -501,7 +502,7 @@
`false`,
}, {
test("net", `net.IPv4() & "ff02::1:3"`),
- `_|_(invalid value "ff02::1:3" (does not satisfy net.IPv4()))`,
+ `_|_(invalid value "ff02::1:3" (does not satisfy net.IPv4))`,
}, {
test("net", `net.LoopbackIP([127, 0, 0, 1])`),
`true`,
@@ -549,23 +550,23 @@
`_|_(invalid value "hello" (does not satisfy strings.MinRunes(10)))`,
}, {
test("struct", `struct.MinFields(0) & ""`),
- `_|_(conflicting values MinFields (0) and "" (mismatched types struct and string))`,
+ `_|_(invalid value "" (mismatched types string and struct))`,
}, {
test("struct", `struct.MinFields(0) & {a: 1}`),
- `{a: 1}`,
+ `{a:1}`,
}, {
test("struct", `struct.MinFields(2) & {a: 1}`),
- `_|_(invalid value {a: 1} (does not satisfy struct.MinFields(2)))`,
+ `_|_(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)))`,
+ `_|_(invalid value {a:1} (does not satisfy struct.MaxFields(0)))`,
}, {
test("struct", `struct.MaxFields(2) & {a: 1}`),
- `{a: 1}`,
+ `{a:1}`,
}, {
test("math", `math.Pow(8, 4)`), `4096`,
}, {
- test("math", `math.Pow10(4)`), `10000`,
+ test("math", `math.Pow10(4)`), `1E+4`,
}, {
test("math", `math.Signbit(-4)`), `true`,
}, {
@@ -669,7 +670,41 @@
if err := insts[0].Err; err != nil {
t.Fatal(err)
}
- got := strings.TrimSpace(fmt.Sprintf("%s\n", insts[0].Value()))
+ v := insts[0].Value()
+ ctx := v.ctx()
+ got := ctx.opCtx.Str(v.v)
+ if got != tc.emit {
+ t.Errorf("\n got: %s\nwant: %s", got, tc.emit)
+ }
+ })
+ }
+}
+
+// For debugging purposes. Do not remove.
+func TestSingleBuiltin(t *testing.T) {
+ // t.Skip()
+
+ test := func(pkg, expr string) []*bimport {
+ return []*bimport{{"",
+ []string{fmt.Sprintf("import %q\n(%s)", pkg, expr)},
+ }}
+ }
+ testCases := []struct {
+ instances []*bimport
+ emit string
+ }{{
+ test("list", `list.Sort([{a:1}, {b:2}], list.Ascending)`),
+ `_|_(error in call to list.Sort: invalid operands {b:2} and {a:1} to '<' (type struct and struct) (and 1 more errors))`,
+ }}
+ 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)
+ }
+ v := insts[0].Value()
+ ctx := v.ctx()
+ got := ctx.opCtx.Str(v.v)
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
index 290ab79..87ad902 100644
--- a/internal/legacy/cue/builtins.go
+++ b/internal/legacy/cue/builtins.go
@@ -148,9 +148,9 @@
}
var builtinPackages = map[string]*builtinPkg{
- "": {
- native: []*builtin{},
- },
+ // "": {
+ // native: []*builtin{},
+ // },
"crypto/md5": {
native: []*builtin{{
Name: "Size",
@@ -612,13 +612,15 @@
if !json.Valid(b) {
return false, fmt.Errorf("json: invalid JSON")
}
- r := internal.GetRuntime(v).(*Runtime)
+ r := internal.GetRuntimeNew(v).(*Runtime)
inst, err := r.Compile("json.Validate", b)
if err != nil {
return false, err
}
- v = v.Unify(inst.Value())
+ t := inst.Value()
+
+ v = v.Unify(t)
if v.Err() != nil {
return false, v.Err()
}
@@ -709,7 +711,7 @@
if err != nil {
return false, err
}
- r := internal.GetRuntime(v).(*Runtime)
+ r := internal.GetRuntimeNew(v).(*Runtime)
for {
expr, err := d.Decode()
if err != nil {
@@ -748,7 +750,7 @@
if err != nil {
return false, err
}
- r := internal.GetRuntime(v).(*Runtime)
+ r := internal.GetRuntimeNew(v).(*Runtime)
for {
expr, err := d.Decode()
if err != nil {
diff --git a/internal/legacy/cue/builtinutil.go b/internal/legacy/cue/builtinutil.go
index df22d71..e226cfa 100644
--- a/internal/legacy/cue/builtinutil.go
+++ b/internal/legacy/cue/builtinutil.go
@@ -14,6 +14,11 @@
package cue
+import (
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/convert"
+)
+
// TODO: this code could be generated, but currently isn't.
type valueSorter struct {
@@ -33,9 +38,12 @@
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()
+ ctx := s.cmp.ctx()
+ x := fill(ctx, s.cmp.v, s.a[i], "x")
+ x = fill(ctx, x, s.a[j], "y")
+ ctx.opCtx.Unify(ctx.opCtx, x, adt.Finalized) // TODO: remove.
+ v := Value{s.cmp.idx, x}
+ isLess, err := v.Lookup("less").Bool()
if err != nil && s.err == nil {
s.err = err
return true
@@ -45,13 +53,22 @@
// 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()
+func fill(ctx *context, v *adt.Vertex, x interface{}, path ...string) *adt.Vertex {
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)
+ value := convertVal(ctx, v, false, x)
+
+ w := adt.ToVertex(value)
+ n := &adt.Vertex{Label: v.Label}
+ n.AddConjunct(adt.MakeConjunct(nil, v))
+ n.AddConjunct(adt.MakeConjunct(nil, w))
+
+ // n.Add(v)
+ // n.Add(w)
+ return n
+}
+
+func convertVal(ctx *context, src source, nullIsTop bool, x interface{}) adt.Value {
+ return convert.GoValueToValue(ctx.opCtx, x, nullIsTop)
}
diff --git a/internal/legacy/cue/context.go b/internal/legacy/cue/context.go
index a63e3e9..3f00329 100644
--- a/internal/legacy/cue/context.go
+++ b/internal/legacy/cue/context.go
@@ -15,48 +15,17 @@
package cue
import (
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/debug"
+ "cuelang.org/go/internal/core/eval"
"github.com/cockroachdb/apd/v2"
)
// context manages evaluation state.
type context struct {
+ opCtx *adt.OpContext
*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
@@ -72,50 +41,56 @@
Context: &baseContext,
index: idx,
}
+ if idx != nil {
+ c.opCtx = eval.NewContext(idx.Runtime, nil)
+ }
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 debugStr(ctx *context, v adt.Node) string {
+ return debug.NodeString(ctx.opCtx, v, nil)
}
-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
- }
+func (c *context) str(v adt.Node) string {
+ return debugStr(c, v)
+}
+
+func (c *context) mkErr(src source, args ...interface{}) *bottom {
+ return c.index.mkErr(src, args...)
+}
+
+func (c *context) vertex(v *adt.Vertex) *adt.Vertex {
+ return v
+}
+
+// vertex returns the evaluated vertex of v.
+func (v Value) vertex(ctx *context) *adt.Vertex {
+ return ctx.vertex(v.v)
+}
+
+// eval returns the evaluated value. This may not be the vertex.
+//
+// Deprecated: use ctx.value
+func (v Value) eval(ctx *context) adt.Value {
+ if v.v == nil {
+ panic("undefined value")
}
- 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
+ x := ctx.manifest(v.v)
+ switch x.Kind() {
+ case adt.StructKind, adt.ListKind:
+ return x
+ default:
+ return x.Value
}
}
-func (c *context) pushForwards(pairs ...scope) *context {
- c.oldSize = append(c.oldSize, len(c.forwardMap))
- c.forwardMap = append(c.forwardMap, pairs...)
- return c
-}
+// func (v Value) evalFull(u value) (Value, adt.Value) {
+// ctx := v.ctx()
+// x := ctx.manifest(u)
+// }
-func (c *context) popForwards() {
- last := len(c.oldSize) - 1
- c.forwardMap = c.forwardMap[:c.oldSize[last]]
- c.oldSize = c.oldSize[:last]
+// TODO: change from Vertex to Vertex.
+func (c *context) manifest(v *adt.Vertex) *adt.Vertex {
+ v.Finalize(c.opCtx)
+ return v
}
diff --git a/internal/legacy/cue/errors.go b/internal/legacy/cue/errors.go
index 467254f..21ed886 100644
--- a/internal/legacy/cue/errors.go
+++ b/internal/legacy/cue/errors.go
@@ -18,63 +18,22 @@
"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 &valueError{
+ v: v,
+ err: &adt.Bottom{
+ Err: errors.Append(err, b.Err),
+ },
}
- return err
}
func (v Value) toErr(b *bottom) (err errors.Error) {
- return v.appendErr(nil, b)
+ return &valueError{v: v, err: b}
}
var _ errors.Error = &valueError{}
@@ -90,23 +49,29 @@
}
func (e *valueError) Position() token.Pos {
- return e.err.Pos()
+ src := e.err.Source()
+ if src == nil {
+ return token.NoPos
+ }
+ return src.Pos()
}
func (e *valueError) InputPositions() []token.Pos {
- return e.err.Positions(e.v.ctx())
+ if e.err.Err == nil {
+ return nil
+ }
+ return e.err.Err.InputPositions()
}
func (e *valueError) Msg() (string, []interface{}) {
- return e.err.Msg()
+ if e.err.Err == nil {
+ return "", nil
+ }
+ return e.err.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
+ return e.v.appendPath(nil)
}
type errCode = adt.ErrorCode
@@ -135,7 +100,10 @@
return false
}
-var errNotExists = &bottom{Code: codeNotExist, format: "undefined value"}
+var errNotExists = &adt.Bottom{
+ Code: codeNotExist,
+ Err: errors.Newf(token.NoPos, "undefined value"),
+}
func exists(v value) bool {
if err, ok := v.(*bottom); ok {
@@ -144,126 +112,39 @@
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
- }
+ var e *adt.Bottom
+ var code errCode = -1
outer:
for i, a := range args {
switch x := a.(type) {
case errCode:
- e.Code = x
+ code = x
case *bottom:
- e.wrapped = x
+ e = adt.CombineErrors(nil, e, x)
case []*bottom:
- e.sub = x
+ for _, b := range x {
+ e = adt.CombineErrors(nil, e, b)
+ }
case errors.Error:
- e.err = x
+ e = adt.CombineErrors(nil, e, &adt.Bottom{Err: x})
case value:
case string:
- e.format = x
- e.args = args[i+1:]
+ 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)
+ pos := pos(src)
+ if code < 0 {
+ code = 0
}
+ e = adt.CombineErrors(nil, e, &adt.Bottom{
+ Code: code,
+ Err: errors.Newf(pos, x, args...),
+ })
break outer
}
}
- if e.Code == codeNone && e.wrapped != nil {
- e.Code = e.wrapped.Code
+ if code >= 0 {
+ e.Code = code
}
return e
}
@@ -283,22 +164,12 @@
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(x adt.Node) bool {
+ if x == nil {
+ return true
}
-}
-
-func isBottom(n value) bool {
- return n.Kind() == bottomKind
+ b, _ := x.(*adt.Bottom)
+ return b != nil
}
func firstBottom(v ...value) *bottom {
diff --git a/internal/legacy/cue/go.go b/internal/legacy/cue/go.go
new file mode 100644
index 0000000..28399d9
--- /dev/null
+++ b/internal/legacy/cue/go.go
@@ -0,0 +1,46 @@
+// 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"
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/convert"
+ "cuelang.org/go/internal/core/eval"
+)
+
+func init() {
+ internal.FromGoValue = func(runtime, x interface{}, nilIsTop bool) interface{} {
+ r := runtime.(*Runtime)
+ ctx := eval.NewContext(r.index().Runtime, nil)
+ v := convert.GoValueToValue(ctx, x, nilIsTop)
+ n := adt.ToVertex(v)
+ return Value{r.idx, n}
+ }
+
+ internal.FromGoType = func(runtime, x interface{}) interface{} {
+ r := runtime.(*Runtime)
+ ctx := eval.NewContext(r.index().Runtime, nil)
+ expr, err := convert.GoTypeToExpr(ctx, x)
+ if err != nil {
+ expr = &adt.Bottom{Err: err}
+ }
+ n := &adt.Vertex{}
+ n.AddConjunct(adt.MakeConjunct(nil, expr))
+ return Value{r.idx, n}
+
+ // return convertType(runtime.(*Runtime), x)
+ }
+}
diff --git a/internal/legacy/cue/instance.go b/internal/legacy/cue/instance.go
index a779041..5b954ea 100644
--- a/internal/legacy/cue/instance.go
+++ b/internal/legacy/cue/instance.go
@@ -18,8 +18,11 @@
"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/adt"
+ "cuelang.org/go/internal/core/compile"
+ "cuelang.org/go/internal/core/convert"
+ "cuelang.org/go/internal/core/eval"
"cuelang.org/go/internal/core/runtime"
)
@@ -28,12 +31,7 @@
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
+ root *adt.Vertex
ImportPath string
Dir string
@@ -49,12 +47,12 @@
}
func (x *index) addInst(p *Instance) *Instance {
- x.Index.AddInst(p.ImportPath, p.rootStruct, p)
+ x.Index.AddInst(p.ImportPath, p.root, p)
p.index = x
return p
}
-func (x *index) getImportFromNode(v value) *Instance {
+func (x *index) getImportFromNode(v *adt.Vertex) *Instance {
p := x.Index.GetImportFromNode(v)
if p == nil {
return nil
@@ -74,25 +72,23 @@
internal.MakeInstance = func(value interface{}) interface{} {
v := value.(Value)
x := v.eval(v.ctx())
- st, ok := x.(*structLit)
+ st, ok := x.(*adt.Vertex)
if !ok {
- st = &structLit{baseValue: x.base(), emit: x}
+ st = &adt.Vertex{}
+ st.AddConjunct(adt.MakeConjunct(nil, x))
}
return v.ctx().index.addInst(&Instance{
- rootStruct: st,
- rootValue: v.v.v,
+ root: st,
})
}
}
// newInstance creates a new instance. Use Insert to populate the instance.
-func newInstance(x *index, p *build.Instance) *Instance {
+func newInstance(x *index, p *build.Instance, v *adt.Vertex) *Instance {
// TODO: associate root source with structLit.
- st := &structLit{baseValue: baseValue{nil}}
i := &Instance{
- rootStruct: st,
- rootValue: st,
- inst: p,
+ root: v,
+ inst: p,
}
if p != nil {
i.ImportPath = p.ImportPath
@@ -118,28 +114,7 @@
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
- }
- }
+ v := ctx.manifest(inst.root)
return v
}
@@ -148,20 +123,63 @@
v := value.(Value)
e := expr.(ast.Expr)
ctx := v.idx.newContext()
- return newValueRoot(ctx, evalExpr(ctx, v.eval(ctx), e))
+ return newValueRoot(ctx, evalExpr(ctx, v.vertex(ctx), e))
}
}
-func evalExpr(ctx *context, x value, expr ast.Expr) evaluated {
- if isBottom(x) {
- return ctx.mkErr(x, "error evaluating instance: %v", x)
+// evalExpr evaluates expr within scope.
+func evalExpr(ctx *context, scope *adt.Vertex, expr ast.Expr) evaluated {
+ cfg := &compile.Config{
+ Scope: scope,
+ Imports: func(x *ast.Ident) (pkgPath string) {
+ if _, ok := builtins[x.Name]; !ok {
+ return ""
+ }
+ return x.Name
+ },
}
- obj, ok := x.(*structLit)
- if !ok {
- return ctx.mkErr(x, "instance is not a struct, found %s", x.Kind())
+
+ c, err := compile.Expr(cfg, ctx.opCtx, expr)
+ if err != nil {
+ return &adt.Bottom{Err: err}
}
- v := newVisitor(ctx.index, nil, nil, obj, true)
- return v.walk(expr).evalPartial(ctx)
+ return adt.Resolve(ctx.opCtx, c)
+
+ // scope.Finalize(ctx.opCtx) // TODO: not appropriate here.
+ // switch s := scope.Value.(type) {
+ // case *bottom:
+ // return s
+ // case *adt.StructMarker:
+ // default:
+ // return ctx.mkErr(scope, "instance is not a struct, found %s", scope.Kind())
+ // }
+
+ // c := ctx.opCtx
+
+ // x, err := compile.Expr(&compile.Config{Scope: scope}, c.Runtime, expr)
+ // if err != nil {
+ // return c.NewErrf("could not evaluate %s: %v", c.Str(x), err)
+ // }
+
+ // env := &adt.Environment{Vertex: scope}
+
+ // switch v := x.(type) {
+ // case adt.Value:
+ // return v
+ // case adt.Resolver:
+ // r, err := c.Resolve(env, v)
+ // if err != nil {
+ // return err
+ // }
+ // return r
+
+ // case adt.Evaluator:
+ // e, _ := c.Evaluate(env, x)
+ // return e
+
+ // }
+
+ // return c.NewErrf("could not evaluate %s", c.Str(x))
}
// Doc returns the package comments for this instance.
@@ -183,7 +201,8 @@
// top-level values.
func (inst *Instance) Value() Value {
ctx := inst.newContext()
- return newValueRoot(ctx, inst.eval(ctx))
+ inst.root.Finalize(ctx.opCtx)
+ return newVertexRoot(ctx, inst.root)
}
// Eval evaluates an expression within an existing instance.
@@ -191,7 +210,9 @@
// 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)
+ v := inst.root
+ v.Finalize(ctx.opCtx)
+ result := evalExpr(ctx, v, expr)
return newValueRoot(ctx, result)
}
@@ -201,33 +222,22 @@
// 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]
- }
+ v := &adt.Vertex{}
- values := []value{}
+ i := inst[0]
+ ctx := i.index.newContext().opCtx
+
+ // TODO: interesting test: use actual unification and then on K8s corpus.
+
for _, i := range inst {
- if i.Err != nil {
- return i
- }
- values = append(values, i.rootValue)
+ w := i.Value()
+ v.AddConjunct(adt.MakeConjunct(nil, w.v.ToDataAll()))
}
- merged := &mergedValues{values: values}
+ v.Finalize(ctx)
- 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,
+ p := i.index.addInst(&Instance{
+ root: v,
+ complete: true,
})
return p
}
@@ -239,37 +249,33 @@
p.Complete()
idx := inst.index
+ r := inst.index.Runtime
- i := newInstance(idx, p)
+ rErr := runtime.ResolveFiles(idx.Index, p, isBuiltin)
+
+ v, err := compile.Files(&compile.Config{Scope: inst.root}, r, p.Files...)
+
+ v.AddConjunct(adt.MakeConjunct(nil, inst.root))
+
+ i := newInstance(idx, p, v)
+ if rErr != nil {
+ i.setListOrError(err)
+ }
if i.Err != nil {
- return i
+ i.setListOrError(err)
}
- ctx := inst.newContext()
- val := newValueRoot(ctx, inst.rootValue)
- v, err := val.structValFull(ctx)
if err != nil {
- i.setError(val.toErr(err))
- return i
+ i.setListOrError(err)
}
- 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)
+ return newVertexRoot(inst.newContext(), inst.root)
}
// Lookup reports the value at a path starting from the top level struct. The
@@ -322,44 +328,36 @@
// 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
+ a := make([]adt.Conjunct, len(inst.root.Conjuncts))
+ copy(a, inst.root.Conjuncts)
+ u := &adt.Vertex{Conjuncts: a}
+
+ if v, ok := x.(Value); ok {
+ if inst.index != v.idx {
+ panic("value of type Value is not created with same Runtime as Instance")
+ }
+ for _, c := range v.v.Conjuncts {
+ u.AddConjunct(c)
+ }
+ } else {
+ ctx := eval.NewContext(inst.index.Runtime, nil)
+ expr := convert.GoValueToExpr(ctx, true, x)
+ u.AddConjunct(adt.MakeConjunct(nil, expr))
+ u.Finalize(ctx)
}
inst = inst.index.addInst(&Instance{
- rootStruct: st,
- rootValue: stVal,
- inst: nil,
+ root: u,
+ 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,
+ complete: true,
})
- return inst, err
+ return inst, nil
}
diff --git a/internal/legacy/cue/marshal.go b/internal/legacy/cue/marshal.go
index fd3cbe1..c48d136 100644
--- a/internal/legacy/cue/marshal.go
+++ b/internal/legacy/cue/marshal.go
@@ -28,6 +28,7 @@
"cuelang.org/go/cue/format"
"cuelang.org/go/cue/token"
"cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/export"
)
// root.
@@ -141,7 +142,7 @@
return p
}
// TODO: support exporting instance
- file, _ := exportFile(ctx, nil, i.rootValue, options{raw: true})
+ file, _ := export.Def(r.idx.Runtime, i.root)
imports := []string{}
for _, i := range internal.Imports(file) {
for _, spec := range i.(*ast.ImportDecl).Specs {
@@ -151,8 +152,15 @@
}
if i.PkgName != "" {
- pkg := &ast.Package{Name: ast.NewIdent(i.PkgName)}
- file.Decls = append([]ast.Decl{pkg}, file.Decls...)
+ p, name, _ := internal.PackageInfo(file)
+ if p == nil {
+ pkg := &ast.Package{Name: ast.NewIdent(i.PkgName)}
+ file.Decls = append([]ast.Decl{pkg}, file.Decls...)
+ } else if name != i.PkgName {
+ // p is guaranteed to be generated by Def, so it is "safe" to
+ // modify.
+ p.Name = ast.NewIdent(i.PkgName)
+ }
}
b, err := format.Node(file)
diff --git a/internal/legacy/cue/marshal_test.go b/internal/legacy/cue/marshal_test.go
index b380b1a..64775aa 100644
--- a/internal/legacy/cue/marshal_test.go
+++ b/internal/legacy/cue/marshal_test.go
@@ -100,7 +100,7 @@
insts := func(i ...*instanceData) []*instanceData { return i }
pkg1 := &instanceData{
true,
- "pkg1",
+ "example.com/foo/pkg1",
files(`
package pkg1
@@ -137,7 +137,7 @@
files(
`package test
- import "pkg1"
+ import "example.com/foo/pkg1"
"Hello \(pkg1.Object)!"`),
}),
@@ -147,7 +147,7 @@
files(
`package test
- import pkg2 "pkg1"
+ import pkg2 "example.com/foo/pkg1"
pkg1: pkg2.Object
"Hello \(pkg1)!"`),
diff --git a/internal/legacy/cue/resolve_test.go b/internal/legacy/cue/resolve_test.go
index e7480da..b9ad808 100644
--- a/internal/legacy/cue/resolve_test.go
+++ b/internal/legacy/cue/resolve_test.go
@@ -15,3031 +15,12 @@
package cue
import (
- "flag"
"strings"
"testing"
+
+ "cuelang.org/go/internal/core/adt"
)
-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 := `
@@ -3048,5 +29,34 @@
if strings.TrimSpace(in) == "" {
t.Skip()
}
- rewriteHelper(t, []testCase{{in: in}}, evalFull)
+}
+
+// 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.root, 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.root
+// }
+
+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, &adt.Vertex{})
+ ctx := x.newContext()
+ return ctx, x, err
+ }
+
+ return r.index().newContext(), inst, nil
}
diff --git a/internal/legacy/cue/types.go b/internal/legacy/cue/types.go
index a5deb07..c3665c7 100644
--- a/internal/legacy/cue/types.go
+++ b/internal/legacy/cue/types.go
@@ -27,10 +27,17 @@
"github.com/cockroachdb/apd/v2"
"cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/ast/astutil"
"cuelang.org/go/cue/errors"
+ "cuelang.org/go/cue/format"
"cuelang.org/go/cue/token"
"cuelang.org/go/internal"
"cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/convert"
+ "cuelang.org/go/internal/core/eval"
+ "cuelang.org/go/internal/core/export"
+ "cuelang.org/go/internal/core/subsume"
+ "cuelang.org/go/internal/core/validate"
)
// Kind determines the underlying type of a Value.
@@ -71,17 +78,17 @@
// NumberKind represents any kind of number.
NumberKind = IntKind | FloatKind
- TopKind = Kind(adt.TopKind)
+ TopKind = adt.TopKind
)
// An structValue represents a JSON object.
//
// TODO: remove
type structValue struct {
- ctx *context
- path *valueData
- obj *structLit
- Arcs arcs
+ ctx *context
+ v Value
+ obj *adt.Vertex
+ features []adt.Feature
}
// Len reports the number of fields in this struct.
@@ -89,14 +96,28 @@
if o.obj == nil {
return 0
}
- return len(o.Arcs)
+ return len(o.features)
}
// 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
+ f := o.features[i]
+ return o.ctx.LabelStr(f), newChildValue(o, i)
+}
+
+func (o *structValue) at(i int) (v *adt.Vertex, isOpt bool) {
+ f := o.features[i]
+ arc := o.obj.Lookup(f)
+ if arc == nil {
+ arc = &adt.Vertex{
+ Parent: o.v.v,
+ Label: f,
+ }
+ o.obj.MatchAndInsert(o.ctx.opCtx, arc)
+ arc.Finalize(o.ctx.opCtx)
+ isOpt = true
+ }
+ return arc, isOpt
}
// Lookup reports the field for the given key. The returned Value is invalid
@@ -106,7 +127,7 @@
i := 0
len := o.Len()
for ; i < len; i++ {
- if o.Arcs[i].Label == f {
+ if o.features[i] == f {
break
}
}
@@ -114,8 +135,7 @@
// 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 newErrValue(o.v, x)
}
return newChildValue(o, i)
}
@@ -190,25 +210,32 @@
// An Iterator iterates over values.
//
type Iterator struct {
- val Value
- ctx *context
- iter iterAtter
- len int
- p int
- cur Value
- f label
+ val Value
+ ctx *context
+ arcs []field
+ p int
+ cur Value
+ f label
+ isOpt bool
+}
+
+type field struct {
+ arc *adt.Vertex
+ isOptional bool
}
// 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 {
+ if i.p >= len(i.arcs) {
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
+ f := i.arcs[i.p]
+ f.arc.Finalize(i.ctx.opCtx)
+ i.cur = makeValue(i.val.idx, f.arc)
+ i.f = f.arc.Label
+ i.isOpt = f.isOptional
i.p++
return true
}
@@ -219,6 +246,10 @@
return i.cur
}
+func (i *Iterator) Feature() adt.Feature {
+ return i.f
+}
+
// Label reports the label of the value if i iterates over struct fields and
// "" otherwise.
func (i *Iterator) Label() string {
@@ -235,12 +266,12 @@
// IsOptional reports if a field is optional.
func (i *Iterator) IsOptional() bool {
- return i.cur.v.arc.optional
+ return i.isOpt
}
// IsDefinition reports if a field is a definition.
func (i *Iterator) IsDefinition() bool {
- return i.cur.v.arc.definition
+ return i.f.IsDef()
}
// marshalJSON iterates over the list and generates JSON output. HasNext
@@ -266,10 +297,11 @@
func (v Value) getNum(k kind) (*numLit, errors.Error) {
v, _ = v.Default()
- if err := v.checkKind(v.ctx(), k); err != nil {
+ ctx := v.ctx()
+ if err := v.checkKind(ctx, k); err != nil {
return nil, v.toErr(err)
}
- n, _ := v.v.Value.(*numLit)
+ n, _ := v.eval(ctx).(*numLit)
return n, nil
}
@@ -491,183 +523,111 @@
return f, nil
}
-type valueData struct {
- parent *valueData
- index uint32
- arc
-}
+func (v Value) appendPath(a []string) []string {
+ for _, f := range v.v.Path() {
+ switch f.Typ() {
+ case adt.IntLabel:
+ a = append(a, strconv.FormatInt(int64(f.Index()), 10))
-// 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)
+ case adt.StringLabel:
+ label := v.idx.LabelStr(f)
+ if !f.IsDef() && !f.IsHidden() {
+ if !ast.IsValidIdent(label) {
+ label = strconv.Quote(label)
+ }
}
+ a = append(a, label)
+ default:
+ a = append(a, f.SelectorString(v.idx.Index))
}
- a = append(a, label)
}
- return a, v.arc.Value.Kind()
+ return a
}
// Value holds any value, which may be a Boolean, Error, List, Null, Number,
// Struct, or String.
type Value struct {
idx *index
- v *valueData
+ v *adt.Vertex
}
func newErrValue(v Value, b *bottom) Value {
- ctx := v.ctx()
- p := v.v
- if p == nil {
- return newValueRoot(ctx, b)
+ node := &adt.Vertex{Value: b}
+ if v.v != nil {
+ node.Label = v.v.Label
+ node.Parent = v.v.Parent
}
- return Value{
- ctx.index,
- &valueData{p.parent, p.index, arc{
- Label: p.arc.Label,
- Value: b,
- v: b,
- }},
+ node.UpdateStatus(adt.Finalized)
+ node.AddConjunct(adt.MakeConjunct(nil, b))
+ return makeValue(v.idx, node)
+}
+
+func newVertexRoot(ctx *context, x *adt.Vertex) Value {
+ if ctx.opCtx != nil {
+ // This is indicative of an zero Value. In some cases this is called
+ // with an error value.
+ x.Finalize(ctx.opCtx)
+ } else {
+ x.UpdateStatus(adt.Finalized)
}
+ return makeValue(ctx.index, x)
}
func newValueRoot(ctx *context, x value) Value {
- v := x.evalPartial(ctx)
- return Value{ctx.index, &valueData{nil, 0, arc{Value: v, v: x}}}
+ if n, ok := x.(*adt.Vertex); ok {
+ return newVertexRoot(ctx, n)
+ }
+ node := &adt.Vertex{}
+ node.AddConjunct(adt.MakeConjunct(nil, x))
+ return newVertexRoot(ctx, node)
}
-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}}
+func newChildValue(o *structValue, i int) Value {
+ arc, _ := o.at(i)
+ return makeValue(o.v.idx, arc)
}
// 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 {
+ n := v.v
+ if n == nil || len(n.Conjuncts) != 1 {
+ return v
+ }
+
+ c := n.Conjuncts[0]
+ r, _ := c.Expr().(adt.Resolver)
+ if r == nil {
return v
}
ctx := v.ctx()
- a, n := appendPath(ctx, make([]label, 0, 3), v.v.v)
-
- if n == nil {
- return v
-
+ n, b := ctx.opCtx.Resolve(c.Env, r)
+ if b != nil {
+ return newErrValue(v, b)
}
-
- 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
+ return makeValue(v.idx, n)
}
-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
+func makeValue(idx *index, v *adt.Vertex) Value {
+ if v.Status() == 0 || v.Value == nil {
+ panic(fmt.Sprintf("not properly initialized (state: %v, value: %T)",
+ v.Status(), v.Value))
}
- return a, n
+ return Value{idx, v}
}
-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 remakeValue(base Value, env *adt.Environment, v value) Value {
+ n := &adt.Vertex{Parent: base.v.Parent, Label: base.v.Label}
+ n.AddConjunct(adt.MakeConjunct(env, v))
+ n = base.ctx().manifest(n)
+ return makeValue(base.idx, n)
}
-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 remakeFinal(base Value, env *adt.Environment, v adt.Value) Value {
+ n := &adt.Vertex{Parent: base.v.Parent, Label: base.v.Label, Value: v}
+ n.UpdateStatus(adt.Finalized)
+ return makeValue(base.idx, n)
}
func (v Value) ctx() *context {
@@ -675,41 +635,8 @@
}
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
+ a.Parent = v.v
+ return makeValue(v.idx, a)
}
// Eval resolves the references of a value and returns the result.
@@ -718,7 +645,12 @@
if v.v == nil {
return v
}
- return remakeValue(v.evalFull(v.v.v))
+ x := v.v
+ // x = eval.FinalizeValue(v.idx.Runtime, v.v)
+ // x.Finalize(v.ctx().opCtx)
+ x = x.ToDataSingle()
+ return makeValue(v.idx, x)
+ // return remakeValue(v, nil, ctx.value(x))
}
// Default reports the default value and whether it existed. It returns the
@@ -727,12 +659,139 @@
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
+
+ d := v.v.Default()
+ if d == v.v {
+ return v, false
}
- return v, false
+ return makeValue(v.idx, d), true
+
+ // d, ok := v.v.Value.(*adt.Disjunction)
+ // if !ok {
+ // return v, false
+ // }
+
+ // var w *adt.Vertex
+
+ // switch d.NumDefaults {
+ // case 0:
+ // return v, false
+
+ // case 1:
+ // w = d.Values[0]
+
+ // default:
+ // x := *v.v
+ // x.Value = &adt.Disjunction{
+ // Src: d.Src,
+ // Values: d.Values[:d.NumDefaults],
+ // NumDefaults: 0,
+ // }
+ // w = &x
+ // }
+
+ // w.Conjuncts = nil
+ // for _, c := range v.v.Conjuncts {
+ // // TODO: preserve field information.
+ // expr, _ := stripNonDefaults(c.Expr())
+ // w.AddConjunct(adt.MakeConjunct(c.Env, expr))
+ // }
+
+ // return makeValue(v.idx, w), true
+
+ // if !stripped {
+ // return v, false
+ // }
+
+ // n := *v.v
+ // n.Conjuncts = conjuncts
+ // return Value{v.idx, &n}, true
+
+ // isDefault := false
+ // for _, c := range v.v.Conjuncts {
+ // if hasDisjunction(c.Expr()) {
+ // isDefault = true
+ // break
+ // }
+ // }
+
+ // if !isDefault {
+ // return v, false
+ // }
+
+ // TODO: record expanded disjunctions in output.
+ // - Rename Disjunction to DisjunctionExpr
+ // - Introduce Disjuncts with Values.
+ // - In Expr introduce Star
+ // - Don't pick default by default?
+
+ // Evaluate the value.
+ // x := eval.FinalizeValue(v.idx.Runtime, v.v)
+ // if b, _ := x.Value.(*adt.Bottom); b != nil { // && b.IsIncomplete() {
+ // return v, false
+ // }
+ // // Finalize and return here.
+ // return Value{v.idx, x}, isDefault
+}
+
+// TODO: this should go: record preexpanded disjunctions in Vertex.
+func hasDisjunction(expr adt.Expr) bool {
+ switch x := expr.(type) {
+ case *adt.DisjunctionExpr:
+ return true
+ case *adt.Conjunction:
+ for _, v := range x.Values {
+ if hasDisjunction(v) {
+ return true
+ }
+ }
+ case *adt.BinaryExpr:
+ switch x.Op {
+ case adt.OrOp:
+ return true
+ case adt.AndOp:
+ return hasDisjunction(x.X) || hasDisjunction(x.Y)
+ }
+ }
+ return false
+}
+
+// TODO: this should go: record preexpanded disjunctions in Vertex.
+func stripNonDefaults(expr adt.Expr) (r adt.Expr, stripped bool) {
+ switch x := expr.(type) {
+ case *adt.DisjunctionExpr:
+ if !x.HasDefaults {
+ return x, false
+ }
+ d := *x
+ d.Values = []adt.Disjunct{}
+ for _, v := range x.Values {
+ if v.Default {
+ d.Values = append(d.Values, v)
+ }
+ }
+ if len(d.Values) == 1 {
+ return d.Values[0].Val, true
+ }
+ return &d, true
+
+ case *adt.BinaryExpr:
+ if x.Op != adt.AndOp {
+ return x, false
+ }
+ a, sa := stripNonDefaults(x.X)
+ b, sb := stripNonDefaults(x.Y)
+ if sa || sb {
+ bin := *x
+ bin.X = a
+ bin.Y = b
+ return &bin, true
+ }
+ return x, false
+
+ default:
+ return x, false
+ }
}
// Label reports he label used to obtain this value from the enclosing struct.
@@ -740,7 +799,7 @@
// 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 {
+ if v.v == nil || v.v.Label == 0 {
return "", false
}
return v.idx.LabelStr(v.v.Label), true
@@ -754,33 +813,13 @@
return BottomKind
}
c := v.v.Value
- if c == nil {
- c = v.v.v.evalPartial(v.ctx())
+ if !adt.IsConcrete(c) {
+ return BottomKind
}
- 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
- }
+ if v.IncompleteKind() == adt.ListKind && !v.IsClosed() {
+ return BottomKind
}
- return BottomKind
+ return c.Kind()
}
// IncompleteKind returns a mask of all kinds that this value may be.
@@ -788,40 +827,7 @@
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
+ return v.v.Kind()
}
// MarshalJSON marshalls this value into valid JSON.
@@ -840,6 +846,14 @@
}
ctx := v.idx.newContext()
x := v.eval(ctx)
+
+ if _, ok := x.(adt.Resolver); ok {
+ return nil, marshalErrf(v, x, codeIncomplete, "value %q contains unresolved references", ctx.str(x))
+ }
+ if !adt.IsConcrete(x) {
+ return nil, marshalErrf(v, x, codeIncomplete, "cannot convert incomplete value %q to JSON", ctx.str(x))
+ }
+
// TODO: implement marshalles in value.
switch k := x.Kind(); k {
case nullKind:
@@ -847,7 +861,9 @@
case boolKind:
return json.Marshal(x.(*boolLit).B)
case intKind, floatKind, numKind:
- return x.(*numLit).X.MarshalText()
+ b, err := x.(*numLit).X.MarshalText()
+ b = bytes.TrimLeft(b, "+")
+ return b, err
case stringKind:
return json.Marshal(x.(*stringLit).Str)
case bytesKind:
@@ -857,15 +873,6 @@
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)
}
@@ -873,12 +880,6 @@
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)
}
}
@@ -889,21 +890,57 @@
// 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 {
+ if v.v == nil {
return nil
}
- ctx := v.ctx()
- o := getOptions(opts)
- var inst *Instance
- if !o.final && !o.concrete {
- inst = v.instance()
+ var o options = getOptions(opts)
+ // var inst *Instance
+
+ p := export.Profile{
+ Simplify: !o.raw,
+ ShowOptional: !o.omitOptional && !o.concrete,
+ ShowDefinitions: !o.omitDefinitions && !o.concrete,
+ ShowHidden: !o.omitHidden && !o.concrete,
+ ShowAttributes: !o.omitAttrs,
+ ShowDocs: o.docs,
}
- if o.raw {
- n, _ := export(ctx, inst, v.v.v, o)
- return n
+
+ // var expr ast.Expr
+ var err error
+ var f *ast.File
+ if o.concrete || o.final {
+ // inst = v.instance()
+ var expr ast.Expr
+ expr, err = p.Value(v.idx.Runtime, v.v)
+ if err != nil {
+ return nil
+ }
+
+ // This introduces gratuitous unshadowing!
+ f, err = astutil.ToFile(expr)
+ if err != nil {
+ return nil
+ }
+ // return expr
+ } else {
+ f, err = p.Def(v.idx.Runtime, v.v)
+ if err != nil {
+ panic(err)
+ }
}
- n, _ := export(ctx, inst, v.v.Value, o)
- return n
+
+ if d := internal.Imports(f); len(d) == 0 {
+ if len(f.Decls) == 1 {
+ if e, ok := f.Decls[0].(*ast.EmbedDecl); ok {
+ return e.Expr
+ }
+ }
+ return &ast.StructLit{
+ Elts: f.Decls,
+ }
+ }
+
+ return f
}
// Decode initializes x with Value v. If x is a struct, it will validate the
@@ -928,7 +965,7 @@
if v.v == nil {
return nil
}
- return v.v.docs.appendDocs(nil)
+ return export.ExtractDoc(v.v)
}
// Split returns a list of values from which v originated such that
@@ -942,27 +979,9 @@
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)...)
+ for _, x := range v.v.Conjuncts {
+ a = append(a, remakeValue(v, x.Env, x.Expr()))
}
return a
}
@@ -975,7 +994,10 @@
if v.v == nil {
return nil
}
- return v.v.v.Source()
+ if len(v.v.Conjuncts) == 1 {
+ return v.v.Conjuncts[0].Source()
+ }
+ return v.v.Value.Source()
}
// Err returns the error represented by v or nil v is not an error.
@@ -1000,19 +1022,10 @@
// 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)
- }
- }
+ if v.v == nil {
+ return false
}
- return false
+ return v.v.IsClosed(v.ctx().opCtx)
}
// IsConcrete reports whether the current value is a concrete scalar value
@@ -1023,35 +1036,32 @@
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) {
+ if b, ok := v.v.Value.(*adt.Bottom); ok {
+ return !b.IsIncomplete()
+ }
+ if !adt.IsConcrete(v.v) {
return false
}
- // Other errors are considered ground.
- return x.Kind().isConcrete()
+ if v.IncompleteKind() == adt.ListKind && !v.IsClosed() {
+ return false
+ }
+ return true
}
-// 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)
-}
+// // Deprecated: IsIncomplete
+// //
+// // It indicates that the value cannot be fully evaluated due to
+// // insufficient information.
+// func (v Value) IsIncomplete() bool {
+// panic("deprecated")
+// }
// 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()))
+ return exists(v.v.Value)
}
func (v Value) checkKind(ctx *context, want kind) *bottom {
@@ -1063,22 +1073,23 @@
if b, ok := x.(*bottom); ok {
return b
}
- got := x.Kind()
+ k := x.Kind()
if want != bottomKind {
- if got&want&concreteKind == bottomKind {
+ if k&want == bottomKind {
return ctx.mkErr(x, "cannot use value %v (type %s) as %s",
- v.ctx().str(x), got, want)
+ ctx.opCtx.Str(x), k, want)
}
- if !got.isGround() {
- return ctx.mkErr(x, codeIncomplete,
- "non-concrete value %v", got)
+ if !adt.IsConcrete(x) {
+ return ctx.mkErr(x, codeIncomplete, "non-concrete value %v", k)
}
}
return nil
}
func makeInt(v Value, x int64) Value {
- return remakeValue(v, newInt(v.v.v.base(), base10).setInt64(x))
+ n := &adt.Num{K: intKind}
+ n.X.SetInt64(int64(x))
+ return remakeFinal(v, nil, n)
}
// Len returns the number of items of the underlying value.
@@ -1086,17 +1097,35 @@
// 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()))
+ switch x := v.eval(v.ctx()).(type) {
+ case *adt.Vertex:
+ if x.IsList() {
+ ctx := v.ctx()
+ n := &adt.Num{K: intKind}
+ n.X.SetInt64(int64(len(x.Elems())))
+ if x.IsClosed(ctx.opCtx) {
+ return remakeFinal(v, nil, n)
+ }
+ // Note: this HAS to be a Conjunction value and cannot be
+ // an adt.BinaryExpr, as the expressions would be considered
+ // to be self-contained and unresolvable when evaluated
+ // (can never become concrete).
+ c := &adt.Conjunction{Values: []adt.Value{
+ &adt.BasicType{K: adt.IntKind},
+ &adt.BoundValue{Op: adt.GreaterEqualOp, Value: n},
+ }}
+ return remakeFinal(v, nil, c)
+
+ }
case *bytesLit:
- return makeInt(v, int64(x.len()))
+ return makeInt(v, int64(len(x.B)))
case *stringLit:
- return makeInt(v, int64(x.len()))
+ return makeInt(v, int64(len([]rune(x.Str))))
}
}
const msg = "len not supported for type %v"
- return remakeValue(v, v.ctx().mkErr(v.v.v, msg, v.Kind()))
+ return remakeValue(v, nil, v.ctx().mkErr(v.v, msg, v.Kind()))
+
}
// Elem returns the value of undefined element types of lists and structs.
@@ -1104,51 +1133,51 @@
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
+ ctx := v.ctx().opCtx
+ x := &adt.Vertex{
+ Parent: v.v,
+ Label: 0,
}
- return Value{}, false
+ v.v.Finalize(ctx)
+ v.v.MatchAndInsert(ctx, x)
+ if len(x.Conjuncts) == 0 {
+ return Value{}, false
+ }
+ x.Finalize(ctx)
+ return makeValue(v.idx, x), true
}
-// 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)
-}
+// // BulkOptionals returns all bulk optional fields as key-value pairs.
+// // See also Elem and Template.
+// func (v Value) BulkOptionals() [][2]Value {
+// x, ok := v.path.cache.(*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})
+// 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
-}
+// 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.
@@ -1158,8 +1187,13 @@
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
+ arcs := []field{}
+ for _, a := range v.v.Elems() {
+ if a.Label.IsInt() {
+ arcs = append(arcs, field{arc: a})
+ }
+ }
+ return Iterator{ctx: ctx, val: v, arcs: arcs}, nil
}
// Null reports an error if v is not null.
@@ -1243,97 +1277,78 @@
// 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?
+ v, _ = v.Default()
- obj, path, err := v.getStruct()
+ obj, 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()
- }
+ features := export.VertexFeatures(obj)
- 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++
+ k := 0
+ for _, f := range features {
+ if f.IsDef() && (o.omitDefinitions || o.concrete) {
+ continue
}
- arcs = arcs[:k]
- return structValue{ctx, path, obj, arcs}, nil
+ if f.IsHidden() && o.omitHidden {
+ continue
+ }
+ if arc := obj.Lookup(f); arc == nil {
+ if o.omitOptional {
+ continue
+ }
+ // ensure it really exists.
+ v := adt.Vertex{
+ Parent: obj,
+ Label: f,
+ }
+ obj.MatchAndInsert(ctx.opCtx, &v)
+ if len(v.Conjuncts) == 0 {
+ continue
+ }
+ }
+ features[k] = f
+ k++
}
- return structValue{ctx, path, obj, obj.Arcs}, nil
+ features = features[:k]
+ return structValue{ctx, v, obj, features}, 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()
+ ctx := v.ctx()
+ obj, err := v.structValOpts(ctx, options{})
if err != nil {
return nil, v.toErr(err)
}
- return &Struct{Value{v.idx, path}, obj}, nil
+ return &Struct{obj}, nil
}
-func (v Value) getStruct() (*structLit, *valueData, *bottom) {
+func (v Value) getStruct() (*structLit, *bottom) {
ctx := v.ctx()
if err := v.checkKind(ctx, structKind); err != nil {
- return nil, nil, err
+ if !err.HasRecursive ||
+ err.Value == nil ||
+ err.Value.Kind() != StructKind {
+ return 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
+ return v.v, nil
}
// Struct represents a CUE struct value.
type Struct struct {
- v Value
- s *structLit
+ structValue
}
// FieldInfo contains information about a struct field.
type FieldInfo struct {
- Name string
- Pos int
- Value Value
+ Selector string
+ Name string // Deprecated: use Selector
+ Pos int
+ Value Value
IsDefinition bool
IsOptional bool
@@ -1341,31 +1356,18 @@
}
func (s *Struct) Len() int {
- return len(s.s.Arcs)
+ return s.structValue.Len()
}
// field reports information about the ith field, i < o.Len().
func (s *Struct) Field(i int) FieldInfo {
+ a, opt := s.at(i)
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()}
+ v := makeValue(s.v.idx, a)
+ name := ctx.LabelStr(a.Label)
+ str := a.Label.SelectorString(ctx.opCtx)
+ return FieldInfo{str, name, i, v, a.Label.IsDef(), opt, a.Label.IsHidden()}
}
// FieldByName looks up a field for the given name. If isIdent is true, it will
@@ -1373,8 +1375,8 @@
// 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 {
+ for i, a := range s.features {
+ if a == f {
return s.Field(i), nil
}
}
@@ -1397,16 +1399,13 @@
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
+
+ arcs := []field{}
+ for i := range obj.features {
+ arc, isOpt := obj.at(i)
+ arcs = append(arcs, field{arc: arc, isOptional: isOpt})
}
- return &Iterator{ctx: ctx, val: v, iter: n, len: len(n.Arcs)}, nil
+ return &Iterator{ctx: ctx, val: v, arcs: arcs}, nil
}
// Lookup reports the value at a path starting from v. The empty path returns v
@@ -1440,9 +1439,9 @@
}
f := v.ctx().Label(name, true)
- for i, a := range o.Arcs {
- if a.Label == f {
- if f.IsHidden() || !a.definition || a.optional {
+ for i, a := range o.features {
+ if a == f {
+ if f.IsHidden() || !f.IsDef() { // optional not possible for now
break
}
return newChildValue(&o, i)
@@ -1455,8 +1454,7 @@
return alt
}
}
- return newErrValue(v, ctx.mkErr(v.v.v,
- "definition %q not found", name))
+ return newErrValue(v, ctx.mkErr(v.v, "definition %q not found", name))
}
var errNotFound = errors.Newf(token.NoPos, "field not found")
@@ -1516,16 +1514,15 @@
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}}
+ var value = convert.GoValueToExpr(ctx.opCtx, true, x)
+ n := &adt.Vertex{Parent: v.v.Parent}
+ n.AddConjunct(adt.MakeConjunct(nil, value))
+ n.Finalize(ctx.opCtx)
+ w := makeValue(v.idx, n)
+ return v.Unify(w)
}
// Template returns a function that represents the template definition for a
@@ -1536,23 +1533,18 @@
// given its name.
func (v Value) Template() func(label string) Value {
// TODO: rename to optional.
- if v.v == nil {
+ if v.v == nil || v.v.Closed == nil {
return nil
}
- ctx := v.ctx()
- x, ok := v.v.Value.(*structLit)
- if !ok || x.optionals.isEmpty() {
- return nil
- }
-
+ parent := v.v
+ ctx := v.ctx().opCtx
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{}
+ f := ctx.StringLabel(label)
+ arc := &adt.Vertex{Parent: parent, Label: f}
+ v.v.MatchAndInsert(ctx, arc)
+ arc.Finalize(ctx)
+ return makeValue(v.idx, arc)
}
}
@@ -1570,15 +1562,19 @@
// 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
+ p := subsume.CUE
+ switch {
+ case o.final && o.ignoreClosedness:
+ p = subsume.FinalOpen
+ case o.final:
+ p = subsume.Final
+ case o.ignoreClosedness:
+ p = subsume.API
}
- if o.ignoreClosedness {
- mode |= subSchema
- }
- return subsumes(v, w, mode)
+ p.Defaults = true
+ ctx := v.ctx().opCtx
+ return p.Value(ctx, v.v, w.v)
}
// Deprecated: use Subsume.
@@ -1588,11 +1584,12 @@
// Without options, Subsumes checks whether v is a backwards compatbile schema
// of w.
//
-// By default, Subsumes tests whether two values are compatib
+// By default, Subsumes tests whether two values are compatible
// 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
+ p := subsume.Profile{Defaults: true}
+ return p.Check(v.ctx().opCtx, v.v, w.v)
}
// Unify reports the greatest lower bound of v and w.
@@ -1600,29 +1597,20 @@
// 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()
+ // 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
+ n := &adt.Vertex{Parent: v.v.Parent, Label: v.v.Label}
+ n.AddConjunct(adt.MakeConjunct(nil, v.v))
+ n.AddConjunct(adt.MakeConjunct(nil, w.v))
+
+ ctx := v.idx.newContext()
+ n.Finalize(ctx.opCtx)
+ return makeValue(v.idx, n)
}
// Equals reports whether two values are equal, ignoring optional fields.
@@ -1631,9 +1619,8 @@
if v.v == nil || other.v == nil {
return false
}
- x := v.v.val()
- y := other.v.val()
- return equals(v.ctx(), x, y)
+ return eval.Equal(v.ctx().opCtx, v.v, other.v)
+
}
// Format prints a debug version of a value.
@@ -1645,11 +1632,13 @@
}
switch {
case state.Flag('#'):
- _, _ = io.WriteString(state, ctx.str(v.v.v))
+ _, _ = io.WriteString(state, ctx.str(v.v))
case state.Flag('+'):
- _, _ = io.WriteString(state, debugStr(ctx, v.v.v))
+ _, _ = io.WriteString(state, debugStr(ctx, v.v))
default:
- _, _ = io.WriteString(state, ctx.str(v.v.Value))
+ n, _ := export.Raw.Expr(v.idx.Runtime, v.v)
+ b, _ := format.Node(n)
+ _, _ = state.Write(b)
}
}
@@ -1657,7 +1646,7 @@
if v.v == nil {
return nil
}
- return v.ctx().getImportFromNode(v.v.v)
+ return v.ctx().getImportFromNode(v.v)
}
// Reference returns the instance and path referred to by this value such that
@@ -1666,154 +1655,72 @@
// 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 {
+ if v.v == nil || len(v.v.Conjuncts) != 1 {
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)
+ c := v.v.Conjuncts[0]
- case *indexExpr:
- e := sel.Index.evalPartial(ctx)
- s, ok := e.(*stringLit)
- if !ok {
- return nil, nil
- }
- x = sel.X
- feature = s.Str
+ return reference(ctx, c.Env, c.Expr())
+}
- default:
+func reference(c *context, env *adt.Environment, r adt.Expr) (inst *Instance, path []string) {
+ ctx := c.opCtx
+ defer ctx.PopState(ctx.PushState(env, r.Source()))
+
+ switch x := r.(type) {
+ case *adt.FieldReference:
+ env := ctx.Env(x.UpCount)
+ inst, path = mkPath(c, nil, env.Vertex)
+ path = append(path, x.Label.SelectorString(c.Index))
+
+ case *adt.LabelReference:
+ env := ctx.Env(x.UpCount)
+ return mkPath(c, nil, env.Vertex)
+
+ case *adt.DynamicReference:
+ env := ctx.Env(x.UpCount)
+ inst, path = mkPath(c, nil, env.Vertex)
+ v, _ := ctx.Evaluate(env, x.Label)
+ str := ctx.StringValue(v)
+ path = append(path, str)
+
+ case *adt.ImportReference:
+ imp := x.ImportPath.StringValue(ctx)
+ inst = c.index.getImportFromPath(imp)
+
+ case *adt.SelectorExpr:
+ inst, path = reference(c, env, x.X)
+ path = append(path, x.Sel.SelectorString(ctx))
+
+ case *adt.IndexExpr:
+ inst, path = reference(c, env, x.X)
+ v, _ := ctx.Evaluate(env, x.Index)
+ str := ctx.StringValue(v)
+ path = append(path, str)
+ }
+ if inst == nil {
return nil, nil
}
- imp, a := mkPath(ctx, v.v, x, feature, 0)
- return imp, a
+ return inst, path
}
-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
+func mkPath(ctx *context, a []string, v *adt.Vertex) (inst *Instance, path []string) {
+ if v.Parent == nil {
+ return ctx.index.getImportFromNode(v), a
}
- return imp, append(a, feature)
+ inst, path = mkPath(ctx, a, v.Parent)
+ path = append(path, v.Label.SelectorString(ctx.opCtx))
+ return inst, path
}
-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
-}
+// // 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 {
+// panic("deprecated")
+// }
type options struct {
concrete bool // enforce that values are concrete
@@ -1950,108 +1857,18 @@
// 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
- }
+ cfg := &validate.Config{
+ Concrete: o.concrete,
+ DisallowCycles: o.disallowCycles,
+ AllErrors: true,
}
- 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))
- }
+ b := validate.Validate(v.idx.Runtime, v.v, cfg)
+ if b != nil {
+ return b.Err
}
return nil
}
@@ -2094,15 +1911,18 @@
// 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 {
+ if v.v == nil {
return Attribute{internal.NewNonExisting(key)}
}
- for _, a := range v.v.attrs.attr {
- if a.key() != key {
+ // look up the attributes
+ for _, a := range export.ExtractFieldAttrs(v.v.Conjuncts) {
+ k, body := a.Split()
+ if key != k {
continue
}
- return Attribute{internal.ParseAttrBody(token.NoPos, a.body())}
+ return Attribute{internal.ParseAttrBody(token.NoPos, body)}
}
+
return Attribute{internal.NewNonExisting(key)}
}
@@ -2167,79 +1987,193 @@
if v.v == nil {
return NoOp, nil
}
+
+ var expr adt.Expr
+ var env *adt.Environment
+
+ if v.v.IsData() {
+ switch x := v.v.Value.(type) {
+ case *adt.ListMarker, *adt.StructMarker:
+ expr = v.v
+ default:
+ expr = x
+ }
+
+ } else {
+ switch len(v.v.Conjuncts) {
+ case 0:
+ if v.v.Value == nil {
+ return NoOp, []Value{makeValue(v.idx, v.v)}
+ }
+ expr = v.v.Value
+
+ case 1:
+ // the default case, processed below.
+ c := v.v.Conjuncts[0]
+ env = c.Env
+ expr = c.Expr()
+ if v, ok := expr.(*adt.Vertex); ok {
+ switch x := v.Value.(type) {
+ case *adt.ListMarker, *adt.StructMarker:
+ default:
+ expr = x
+ }
+ }
+
+ default:
+ a := []Value{}
+ ctx := v.ctx().opCtx
+ for _, c := range v.v.Conjuncts {
+ n := &adt.Vertex{
+ Parent: v.v.Parent,
+ Label: v.v.Label,
+ }
+ n.AddConjunct(c)
+ n.Finalize(ctx)
+ a = append(a, makeValue(v.idx, n))
+ }
+ return adt.AndOp, a
+ }
+ }
+
// TODO: replace appends with []Value{}. For not leave.
a := []Value{}
op := NoOp
- switch x := v.v.v.(type) {
+ switch x := expr.(type) {
case *binaryExpr:
- a = append(a, remakeValue(v, x.X))
- a = append(a, remakeValue(v, x.Y))
- op = opToOp[x.Op]
+ a = append(a, remakeValue(v, env, x.X))
+ a = append(a, remakeValue(v, env, x.Y))
+ op = 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:
+ a = append(a, remakeValue(v, env, x.X))
+ op = x.Op
+ case *boundExpr:
+ a = append(a, remakeValue(v, env, x.Expr))
+ op = x.Op
+ case *boundValue:
+ a = append(a, remakeValue(v, env, x.Value))
+ op = x.Op
+ case *adt.Conjunction:
// pre-expanded unification
for _, conjunct := range x.Values {
- a = append(a, remakeValue(v, conjunct))
+ a = append(a, remakeValue(v, env, conjunct))
}
op = AndOp
- case *disjunction:
+ case *adt.Disjunction:
+ for _, disjunct := range x.Values {
+ a = append(a, makeValue(v.idx, disjunct))
+ }
+ op = OrOp
+
+ case *adt.DisjunctionExpr:
// Filter defaults that are subsumed by another value.
count := 0
- outer:
+ // 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
- }
- }
- }
+ // if disjunct.marked {
+ // for _, n := range x.Values {
+ // s := subsumer{ctx: v.ctx()}
+ // if !n.marked && s.subsumes(n.val, disjunct.val) {
+ // continue outer
+ // }
+ // }
+ // }
count++
- a = append(a, remakeValue(v, disjunct.Val))
+ a = append(a, remakeValue(v, env, disjunct.Val))
}
if count > 1 {
- op = OrOp
+ op = adt.OrOp
}
case *interpolation:
for _, p := range x.Parts {
- a = append(a, remakeValue(v, p))
+ a = append(a, remakeValue(v, env, p))
}
op = InterpolationOp
+
+ case *adt.FieldReference:
+ // TODO: allow hard link
+ ctx := v.ctx().opCtx
+ f := ctx.PushState(env, x.Src)
+ env := ctx.Env(x.UpCount)
+ a = append(a, remakeValue(v, nil, &adt.NodeLink{Node: env.Vertex}))
+ a = append(a, remakeValue(v, nil, ctx.NewString(x.Label.SelectorString(ctx))))
+ _ = ctx.PopState(f)
+ op = SelectorOp
+
case *selectorExpr:
- a = append(a, remakeValue(v, x.X))
- a = append(a, remakeValue(v, &stringLit{
- x.baseValue,
- v.ctx().LabelStr(x.Sel),
- nil,
+ a = append(a, remakeValue(v, env, x.X))
+ // A string selector is quoted.
+ a = append(a, remakeValue(v, env, &adt.String{
+ Str: x.Sel.SelectorString(v.idx.Index),
}))
op = SelectorOp
+
case *indexExpr:
- a = append(a, remakeValue(v, x.X))
- a = append(a, remakeValue(v, x.Index))
+ a = append(a, remakeValue(v, env, x.X))
+ a = append(a, remakeValue(v, env, 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))
+ a = append(a, remakeValue(v, env, x.X))
+ a = append(a, remakeValue(v, env, x.Lo))
+ a = append(a, remakeValue(v, env, x.Hi))
op = SliceOp
case *callExpr:
- a = append(a, remakeValue(v, x.Fun))
+ a = append(a, remakeValue(v, env, x.Fun))
for _, arg := range x.Args {
- a = append(a, remakeValue(v, arg))
+ a = append(a, remakeValue(v, env, arg))
}
op = CallOp
case *customValidator:
- a = append(a, remakeValue(v, x.Builtin))
+ a = append(a, remakeValue(v, env, x.Builtin))
for _, arg := range x.Args {
- a = append(a, remakeValue(v, arg))
+ a = append(a, remakeValue(v, env, arg))
}
op = CallOp
+
+ case *adt.StructLit:
+ // Simulate old embeddings.
+ envEmbed := &adt.Environment{
+ Up: env,
+ Vertex: v.v,
+ }
+ fields := []adt.Decl{}
+ ctx := v.ctx().opCtx
+ for _, d := range x.Decls {
+ switch x := d.(type) {
+ case adt.Expr:
+ // embedding
+ n := &adt.Vertex{
+ Parent: v.v.Parent,
+ Label: v.v.Label}
+ c := adt.MakeConjunct(envEmbed, x)
+ n.AddConjunct(c)
+ n.Finalize(ctx)
+ a = append(a, makeValue(v.idx, n))
+
+ default:
+ fields = append(fields, d)
+ }
+ }
+ if len(a) == 0 {
+ a = append(a, v)
+ break
+ }
+
+ if len(fields) > 0 {
+ n := &adt.Vertex{
+ Parent: v.v.Parent,
+ Label: v.v.Label,
+ }
+ c := adt.MakeConjunct(env, &adt.StructLit{
+ Decls: fields,
+ })
+ n.AddConjunct(c)
+ n.Finalize(ctx)
+ a = append(a, makeValue(v.idx, n))
+ }
+
+ op = adt.AndOp
+
default:
a = append(a, v)
}
diff --git a/internal/legacy/cue/types_test.go b/internal/legacy/cue/types_test.go
index cea8a14..5ba255b 100644
--- a/internal/legacy/cue/types_test.go
+++ b/internal/legacy/cue/types_test.go
@@ -30,6 +30,8 @@
"cuelang.org/go/cue/ast"
"cuelang.org/go/cue/errors"
"cuelang.org/go/internal"
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/debug"
)
func getInstance(t *testing.T, body ...string) *Instance {
@@ -175,6 +177,12 @@
concrete: false,
}, {
value: `import "time"
+ v: time.Time`,
+ kind: BottomKind,
+ incompleteKind: StringKind,
+ concrete: false,
+ }, {
+ value: `import "time"
v: {a: time.Time}.a`,
kind: BottomKind,
incompleteKind: StringKind,
@@ -567,7 +575,7 @@
res: "[1,2,3,]",
}, {
value: `>=5*[1,2,3, ...int]`,
- err: "incomplete",
+ err: "non-concrete value >=5 in operand to *",
}, {
value: `[for x in #y if x > 1 { x }]
#y: [1,2,3]`,
@@ -602,6 +610,9 @@
res string
err string
}{{
+ value: `{ #def: 1, _hidden: 2, opt?: 3, reg: 4 }`,
+ res: "{reg:4,}",
+ }, {
value: `_|_`,
err: "from source",
}, {
@@ -680,6 +691,9 @@
}, {
value: `{_a:"a"}`,
res: `{_a:"a",}`,
+ }, {
+ value: `{_a:"a", b?: "b", #c: 3}`,
+ res: `{_a:"a",b?:"b",#c:3,}`,
}}
for _, tc := range testCases {
t.Run(tc.value, func(t *testing.T) {
@@ -692,6 +706,9 @@
buf := []byte{'{'}
for iter.Next() {
buf = append(buf, iter.Label()...)
+ if iter.IsOptional() {
+ buf = append(buf, '?')
+ }
buf = append(buf, ':')
b, err := iter.Value().MarshalJSON()
checkFatal(t, err, tc.err, "Obj.At")
@@ -731,7 +748,7 @@
eval string
}{{
ref: []string{"v", "x"},
- raw: "(int & <=9223372036854775807 & int & >=-9223372036854775808)",
+ raw: ">=-9223372036854775808 & <=9223372036854775807 & int",
eval: "int64",
}}
for _, tc := range testCases {
@@ -788,6 +805,7 @@
return x
}
+// TODO: Exporting of Vertex as Conjunct
func TestFill(t *testing.T) {
r := &Runtime{}
@@ -838,10 +856,13 @@
path = strings.Split(tc.path, ",")
}
- v := compileT(t, r, tc.in).Value().Fill(tc.x, path...)
+ v := compileT(t, r, tc.in).Value()
+ v = v.Fill(tc.x, path...)
+
w := compileT(t, r, tc.out).Value()
- if !reflect.DeepEqual(goValue(v), goValue(w)) {
+ if !cmp.Equal(goValue(v), goValue(w)) {
+ t.Error(cmp.Diff(goValue(v), goValue(w)))
t.Errorf("\ngot: %s\nwant: %s", v, w)
}
}
@@ -854,6 +875,8 @@
#Provider: {
ID: string
notConcrete: bool
+ a: int
+ b: int
}
`)
@@ -869,9 +892,24 @@
}
got := fmt.Sprint(root.Value())
-
- if got != `{#Provider: C{ID: string, notConcrete: bool}, providers: {myprovider: C{ID: (string & "12345"), notConcrete: bool}}}` {
- t.Error(got)
+ want := `{
+ #Provider: {
+ ID: string
+ notConcrete: bool
+ a: int
+ b: int
+ }
+ providers: {
+ myprovider: {
+ ID: "12345"
+ notConcrete: bool
+ a: int
+ b: int
+ }
+ }
+}`
+ if got != want {
+ t.Errorf("got: %s\nwant: %s", got, want)
}
}
@@ -890,11 +928,11 @@
}, {
in: `_foo: 3`,
def: "_foo",
- out: `_|_(definition "_foo" not found)`,
+ out: `_|_ // definition "_foo" not found`,
}, {
in: `_#foo: 3`,
def: "_#foo",
- out: `_|_(definition "_#foo" not found)`,
+ out: `_|_ // definition "_#foo" not found`,
}}
for _, tc := range testCases {
@@ -910,6 +948,7 @@
}
}
+// TODO: trim down to individual defaults?
func TestDefaults(t *testing.T) {
testCases := []struct {
value string
@@ -928,12 +967,12 @@
ok: true,
}, {
value: `*{a:1,b:2}|{a:1}|{b:2}`,
- def: "{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}`,
+ def: `({a:1} & {b:2})`,
val: ``,
ok: false,
}}
@@ -946,11 +985,11 @@
t.Errorf("hasDefault: got %v; want %v", ok, tc.ok)
}
- if got := fmt.Sprint(d); got != tc.def {
+ if got := compactRawStr(d); got != tc.def {
t.Errorf("default: got %v; want %v", got, tc.def)
}
- op, val := v.Expr()
+ op, val := d.Expr()
if op != OrOp {
return
}
@@ -987,7 +1026,7 @@
// length: "2",
}, {
input: "3",
- length: "_|_(len not supported for type int)",
+ length: "_|_ // len not supported for type int",
}}
for _, tc := range testCases {
t.Run(tc.input, func(t *testing.T) {
@@ -1036,7 +1075,7 @@
a: foo: b: [Bar=string]: { d: Bar }
`,
path: []string{"a", "foo", "b", ""},
- want: `{"c":"foolabel","d":"label"}`,
+ want: `{"d":"label","c":"foolabel"}`,
}}
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
@@ -1059,6 +1098,67 @@
}
}
+func TestElem(t *testing.T) {
+ testCases := []struct {
+ value string
+ path []string
+ want string
+ }{{
+ value: `
+ a: [...int]
+ `,
+ path: []string{"a", ""},
+ want: `int`,
+ }, {
+ value: `
+ [Name=string]: { a: Name }
+ `,
+ path: []string{"", "a"},
+ want: `string`,
+ }, {
+ value: `
+ [Name=string]: { a: Name }
+ `,
+ path: []string{""},
+ want: "{\n\ta: string\n}",
+ }, {
+ value: `
+ a: [Foo=string]: [Bar=string]: { b: Foo+Bar }
+ `,
+ path: []string{"a", "", ""},
+ want: "{\n\tb: string + string\n}",
+ }, {
+ value: `
+ a: [Foo=string]: b: [Bar=string]: { c: Foo+Bar }
+ a: foo: b: [Bar=string]: { d: Bar }
+ `,
+ path: []string{"a", "foo", "b", ""},
+ want: "{\n\td: string\n\tc: string + string\n}",
+ }}
+ for _, tc := range testCases {
+ t.Run("", func(t *testing.T) {
+ v := getInstance(t, tc.value).Value()
+ v.v.Finalize(v.ctx().opCtx) // TODO: do in instance.
+ for _, p := range tc.path {
+ if p == "" {
+ var ok bool
+ v, ok = v.Elem()
+ if !ok {
+ t.Fatal("expected element")
+ }
+ } else {
+ v = v.Lookup(p)
+ }
+ }
+ got := fmt.Sprint(v)
+ // got := debug.NodeString(v.ctx().opCtx, v.v, &debug.Config{Compact: true})
+ if got != tc.want {
+ t.Errorf("\n got: %q\nwant: %q", got, tc.want)
+ }
+ })
+ }
+}
+
func TestSubsumes(t *testing.T) {
a := []string{"a"}
b := []string{"b"}
@@ -1281,6 +1381,7 @@
}
}
+// TODO: options: disallow cycles.
func TestValidate(t *testing.T) {
testCases := []struct {
desc string
@@ -1475,7 +1576,7 @@
v = v.Lookup(e)
}
}
- got, _ := v.v.appendPath(nil, v.idx)
+ got := v.appendPath(nil)
if !reflect.DeepEqual(got, tc) {
t.Errorf("got %v; want %v", got, tc)
}
@@ -1514,7 +1615,7 @@
}, {
config: config,
path: strList(),
- str: "{a: {a: 0, b: 1, c: 2}, b: {d: a.a, e: int}",
+ str: "{a:{a:0,b:1,c:2},b:{d:0,e:int}",
}, {
config: config,
path: strList("a", "a"),
@@ -1522,7 +1623,7 @@
}, {
config: config,
path: strList("a"),
- str: "{a: 0, b: 1, c: 2}",
+ str: "{a:0,b:1,c:2}",
}, {
config: config,
path: strList("b", "d"),
@@ -1544,7 +1645,7 @@
t.Errorf("exists: got %v; want %v", got, tc.notExists)
}
- got := fmt.Sprint(v)
+ got := v.ctx().opCtx.Str(v.v)
if tc.str == "" {
t.Fatalf("str empty, got %q", got)
}
@@ -1843,6 +1944,7 @@
}
}
+// TODO: duplicate docs.
func TestValueDoc(t *testing.T) {
const config = `
// foobar defines at least foo.
@@ -1923,21 +2025,19 @@
}, {
val: v1,
path: "foos MyFoo field1",
- doc: `field1 is an int.
+ doc: `local field comment.
-local field comment.
+field1 is an int.
`,
}, {
val: v1,
path: "foos MyFoo field2",
doc: "other field comment.\n",
}, {
+ // Duplicates are now removed.
val: v1,
path: "foos MyFoo dup3",
- doc: `duplicate field comment
-
-duplicate field comment
-`,
+ doc: "duplicate field comment\n",
}, {
val: v1,
path: "bar field1",
@@ -1945,9 +2045,9 @@
}, {
val: v1,
path: "baz field1",
- doc: `comment from baz on field 1
+ doc: `comment from bar on field 1
-comment from bar on field 1
+comment from baz on field 1
`,
}, {
val: v1,
@@ -1961,9 +2061,9 @@
}, {
val: both,
path: "Foo",
- doc: `Another Foo.
+ doc: `A Foo fooses stuff.
-A Foo fooses stuff.
+Another Foo.
`,
}}
for _, tc := range testCases {
@@ -1992,6 +2092,8 @@
return doc
}
+// TODO: unwrap marshal error
+// TODO: improve error messages
func TestMarshalJSON(t *testing.T) {
testCases := []struct {
value string
@@ -2048,7 +2150,7 @@
err: `0: cannot convert incomplete value`,
}, {
value: `(>=3 * [1, 2])`,
- err: "incomplete error", // TODO: improve error
+ err: "cue: marshal error: non-concrete value >=3 in operand to *",
}, {
value: `{}`,
json: `{}`,
@@ -2117,11 +2219,11 @@
}, {
// Issue #326
value: `x: "\(string)": "v"`,
- err: `x: incomplete value 'string' in interpolation`,
+ err: `x: invalid interpolation`,
}, {
// Issue #326
value: `x: "\(bool)": "v"`,
- err: `x: expression in interpolation must evaluate to a number kind or string (found bool)`,
+ err: `invalid interpolation`,
}, {
// Issue #326
value: `
@@ -2173,8 +2275,8 @@
out: "_|_(from source)",
}, {
value: `(a.b)
- a: {}`,
- out: `_|_(undefined field "b")`,
+ a: {}`,
+ out: `_|_(undefined field b)`,
}, {
value: `true`,
out: `true`,
@@ -2190,15 +2292,18 @@
}, {
value: `12_000`,
out: `12000`,
+ // out: `12_000`,
}, {
value: `12.000`,
out: `12.000`,
}, {
value: `12M`,
out: `12000000`,
+ // out: `12M`,
}, {
value: `3.0e100`,
out: `3.0e+100`,
+ // out: `3.0e100`,
}, {
value: `[]`,
out: `[]`,
@@ -2228,8 +2333,11 @@
}
}
inst.Value().Walk(func(v Value) bool {
- if k, ok := v.Label(); ok {
- buf = append(buf, k+":"...)
+ v = v.Eval()
+ if !v.v.Label.IsInt() {
+ if k, ok := v.Label(); ok {
+ buf = append(buf, k+":"...)
+ }
}
switch v.Kind() {
case StructKind:
@@ -2237,6 +2345,11 @@
case ListKind:
buf = append(buf, '[')
default:
+ if b, _ := v.v.Value.(*adt.Bottom); b != nil {
+ s := debugStr(v.ctx(), b)
+ buf = append(buf, fmt.Sprint(s, ",")...)
+ return true
+ }
buf = append(buf, fmt.Sprint(v, ",")...)
}
return true
@@ -2283,6 +2396,7 @@
testCases := []struct {
input string
want string
+ alt string
}{{
input: "v: w: x: _|_",
want: "",
@@ -2327,6 +2441,14 @@
a: 1
`,
want: "a",
+ }, {
+ input: `
+ import "math"
+
+ v: w: x: math.Pi
+ `,
+ want: "Pi",
+ alt: "3.14159265358979323846264338327950288419716939937510582097494459",
}}
for _, tc := range testCases {
t.Run("", func(t *testing.T) {
@@ -2339,15 +2461,20 @@
}
if tc.want != "" {
- v := inst.Lookup(a...)
- if x, _ := v.Int64(); x != 1 {
- t.Errorf("path resolved to %s; want 1", v)
+ want := "1"
+ if tc.alt != "" {
+ want = tc.alt
+ }
+ v := fmt.Sprint(inst.Lookup(a...))
+ if v != want {
+ t.Errorf("path resolved to %s; want %s", v, want)
}
}
})
}
}
+// TODO: stack overflow
func TestPathCorrection(t *testing.T) {
testCases := []struct {
input string
@@ -2355,34 +2482,39 @@
want string
skip bool
}{{
+ // // TODO: structural cycle.
+ // 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",
+ // }, {
+
+ // TODO: embedding: have field operators.
+ // input: `
+ // a: {
+ // c: 3
+ // {x: c}
+ // }
+ // `,
+ // lookup: func(i *Instance) Value {
+ // _, a := i.Lookup("a").Expr()
+ // return a[1].Lookup("x")
+ // },
+ // want: "a.c",
+ // }, {
+
+ // TODO: implement proper Elem()
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
- `,
+ a: b: [...T]
+ a: b: [...T]
+ T: int
+ `,
lookup: func(i *Instance) Value {
v, _ := i.Lookup("a", "b").Elem()
_, a := v.Expr()
@@ -2391,12 +2523,12 @@
want: "T",
}, {
input: `
- #S: {
- b?: [...#T]
- b?: [...#T]
- }
- #T: int
- `,
+ #S: {
+ b?: [...#T]
+ b?: [...#T]
+ }
+ #T: int
+ `,
lookup: func(i *Instance) Value {
v := i.LookupDef("#S")
f, _ := v.LookupField("b")
@@ -2407,43 +2539,65 @@
want: "#T",
}, {
input: `
- #a: {
- #T: {b: 3}
- close({}) | close({c: #T}) | close({d: string})
- }
- `,
+ #S: {
+ a?: [...#T]
+ b?: [...#T]
+ }
+ #T: int
+ `,
lookup: func(i *Instance) Value {
- f, _ := i.LookupField("#a")
- _, a := f.Value.Expr() // &
- _, a = a[1].Expr() // |
- return a[1].Lookup("c")
+ v := i.LookupDef("#S")
+ f, _ := v.LookupField("a")
+ x := f.Value
+ f, _ = v.LookupField("b")
+ y := f.Value
+ u := x.Unify(y)
+ v, _ = u.Elem()
+ _, a := v.Expr()
+ return a[0]
},
- want: "#a.#T",
+ 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
+ // TODO: iterate over Definitions
+ // input: `
+ // package foo
- #Struct: {
- #T: int
+ // #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
- },
- }, {
+ // {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
@@ -2463,75 +2617,80 @@
v = v.Lookup("a")
return v
},
- }, {
- input: `
- package foo
+ // }, {
- #A: #B: #T
+ // TODO: record additionalItems in list
+ // input: `
+ // package foo
- #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
- }
+ // #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 }
+ // #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
+ // },
+ // }, {
- 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
- },
+ // YAY: works.
+ // 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 {
@@ -2556,64 +2715,64 @@
}
}
-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"},
+// 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)
- }
- })
- }
-}
+// {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()
@@ -2659,13 +2818,16 @@
input: "v: 3 + 4",
want: "+(3 4)",
}, {
- input: "v: !a, a: 3",
- want: `!(.(<0> "a"))`,
+ input: "v: !a, a: bool",
+ want: `!(.(〈〉 "a"))`,
+ }, {
+ input: "v: !a, a: 3", // TODO: Should still look up.
+ want: `!(.(〈〉 "a"))`,
}, {
input: "v: 1 | 2 | 3 | *4",
want: "|(1 2 3 4)",
}, {
- input: "v: 2 & 5",
+ input: "v: 2 & 5", // Allow even with error.
want: "&(2 5)",
}, {
input: "v: 2 | 5",
@@ -2681,7 +2843,7 @@
want: "==(2 5)",
}, {
input: "v: !b, b: true",
- want: `!(.(<0> "b"))`,
+ want: `!(.(〈〉 "b"))`,
}, {
input: "v: 2 != 5",
want: "!=(2 5)",
@@ -2729,31 +2891,31 @@
want: "mod(2 5)",
}, {
input: "v: a.b, a: b: 4",
- want: `.(.(<0> "a") "b")`,
+ want: `.(.(〈〉 "a") "b")`,
}, {
input: `v: a["b"], a: b: 3 `,
- want: `[](.(<0> "a") "b")`,
+ want: `[](.(〈〉 "a") "b")`,
}, {
input: "v: a[2:5], a: [1, 2, 3, 4, 5]",
- want: `[:](.(<0> "a") 2 5)`,
+ want: `[:](.(〈〉 "a") 2 5)`,
}, {
input: "v: len([])",
want: "()(len [])",
}, {
input: "v: a.b, a: { b: string }",
- want: `.(.(<0> "a") "b")`,
+ want: `.(.(〈〉 "a") "b")`,
}, {
input: `v: "Hello, \(x)! Welcome to \(place)", place: string, x: string`,
- want: `\()("Hello, " .(<0> "x") "! Welcome to " .(<0> "place") "")`,
+ want: `\()("Hello, " .(〈〉 "x") "! Welcome to " .(〈〉 "place") "")`,
}, {
input: `v: { a, b: 1 }, a: 2`,
- want: `&(<0>{b: 1} .(<0> "a"))`,
+ want: `&(.(〈〉 "a") {b:1})`,
}, {
input: `v: { {c: a}, b: a }, a: int`,
- want: `&(<0>{b: <1>.a} <0>{c: <1>.a})`,
+ want: `&({c:a} {b:a})`,
}, {
input: `v: [...number] | *[1, 2, 3]`,
- want: `([, ...number] | *[1,2,3])`,
+ want: `|([...number] [1,2,3])`,
}}
for _, tc := range testCases {
t.Run(tc.input, func(t *testing.T) {
@@ -2765,10 +2927,11 @@
})
}
}
+
func exprStr(v Value) string {
op, operands := v.Expr()
if op == NoOp {
- return debugStr(v.ctx(), v.v.v)
+ return compactRawStr(v)
}
s := op.String()
s += "("
@@ -2781,3 +2944,15 @@
s += ")"
return s
}
+
+func compactRawStr(v Value) string {
+ ctx := v.ctx()
+ cfg := &debug.Config{Compact: true, Raw: true}
+ return debug.NodeString(ctx.opCtx, v.v, cfg)
+}
+
+func compactValueStr(v Value) string {
+ ctx := v.ctx()
+ cfg := &debug.Config{Compact: true}
+ return debug.NodeString(ctx.opCtx, v.v, cfg)
+}
