cue: changes ahead of unchecked unification

Introducing unchecked unification introduces some
boilerplate-y changes. Changes this ahead of time
to make the actual changes stand out.

- Function to determine whether an operation is
  a unification op or not.
- passing the type of unification to various functions
  where previously it was assumed to be opUnify.

Issue #40

Change-Id: I1136a7341cf41b7a5ac47133996fd469d39a700f
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/2869
Reviewed-by: Marcel van Lohuizen <[email protected]>

Author: mpvl

cue/binop.go

@@ -34,15 +34,16 @@ func binSrc(pos token.Pos, op op, a, b value) baseValue {
 }
 
 func binOp(ctx *context, src source, op op, left, right evaluated) (result evaluated) {
+	_, isUnify := op.unifyType()
 	if b, ok := left.(*bottom); ok {
-		if op == opUnify && b.exprDepth == 0 && cycleError(b) != nil {
+		if isUnify && b.exprDepth == 0 && cycleError(b) != nil {
 			ctx.cycleErr = true
 			return right
 		}
 		return left
 	}
 	if b, ok := right.(*bottom); ok {
-		if op == opUnify && b.exprDepth == 0 && cycleError(b) != nil {
+		if isUnify && b.exprDepth == 0 && cycleError(b) != nil {
 			ctx.cycleErr = true
 			return left
 		}
@@ -82,7 +83,7 @@ func binOp(ctx *context, src source, op op, left, right evaluated) (result evalu
 	if invert {
 		left, right = right, left
 	}
-	if op != opUnify {
+	if !isUnify {
 		// Any operation other than unification or disjunction must be on
 		// concrete types. Disjunction is handled separately.
 		if !leftKind.isGround() || !rightKind.isGround() {
@@ -94,7 +95,7 @@ func binOp(ctx *context, src source, op op, left, right evaluated) (result evalu
 		return v
 	}
 
-	// op == opUnify
+	// isUnify
 
 	// TODO: unify type masks.
 	if left == right {
@@ -108,13 +109,13 @@ func binOp(ctx *context, src source, op op, left, right evaluated) (result evalu
 	}
 
 	if dl, ok := left.(*disjunction); ok {
-		return distribute(ctx, src, dl, right)
+		return distribute(ctx, src, op, dl, right)
 	} else if dr, ok := right.(*disjunction); ok {
-		return distribute(ctx, src, dr, left)
+		return distribute(ctx, src, op, dr, left)
 	}
 
 	if _, ok := right.(*unification); ok {
-		return right.binOp(ctx, src, opUnify, left)
+		return right.binOp(ctx, src, op, left)
 	}
 
 	// TODO: value may be incomplete if there is a cycle. Instead of an error
@@ -141,21 +142,21 @@ type mVal struct {
 // TODO: this is an exponential algorithm. There is no reason to have to
 // resolve this early. Revise this to only do early pruning but not a full
 // evaluation.
-func distribute(ctx *context, src source, x, y evaluated) evaluated {
+func distribute(ctx *context, src source, op op, x, y evaluated) evaluated {
 	dn := &disjunction{baseValue: src.base()}
-	dist(ctx, dn, false, mVal{x, true}, mVal{y, true})
+	dist(ctx, dn, false, op, mVal{x, true}, mVal{y, true})
 	return dn.normalize(ctx, src).val
 }
 
-func dist(ctx *context, d *disjunction, mark bool, x, y mVal) {
+func dist(ctx *context, d *disjunction, mark bool, op op, x, y mVal) {
 	if dx, ok := x.val.(*disjunction); ok {
 		if dx.hasDefaults {
 			mark = true
 			d.hasDefaults = true
 		}
 		for _, dxv := range dx.values {
 			m := dxv.marked || !dx.hasDefaults
-			dist(ctx, d, mark, mVal{dxv.val.evalPartial(ctx), m}, y)
+			dist(ctx, d, mark, op, mVal{dxv.val.evalPartial(ctx), m}, y)
 		}
 		return
 	}
@@ -166,12 +167,12 @@ func dist(ctx *context, d *disjunction, mark bool, x, y mVal) {
 		}
 		for _, dxy := range dy.values {
 			m := dxy.marked || !dy.hasDefaults
-			dist(ctx, d, mark, x, mVal{dxy.val.evalPartial(ctx), m})
+			dist(ctx, d, mark, op, x, mVal{dxy.val.evalPartial(ctx), m})
 		}
 		return
 	}
-	src := binSrc(token.NoPos, opUnify, x.val, y.val)
-	d.add(ctx, binOp(ctx, src, opUnify, x.val, y.val), mark && x.mark && y.mark)
+	src := binSrc(token.NoPos, op, x.val, y.val)
+	d.add(ctx, binOp(ctx, src, op, x.val, y.val), mark && x.mark && y.mark)
 }
 
 func (x *disjunction) binOp(ctx *context, src source, op op, other evaluated) evaluated {
@@ -331,7 +332,6 @@ func (x *bound) binOp(ctx *context, src source, op op, other evaluated) evaluate
 		k, _, msg := matchBinOpKind(opUnify, x.kind(), other.kind())
 		if k == bottomKind {
 			return ctx.mkErr(src, msg, opUnify, ctx.str(x), ctx.str(other), x.kind(), other.kind())
-			break
 		}
 		switch y := other.(type) {
 		case *basicType:
@@ -582,7 +582,8 @@ func evalLambda(ctx *context, a value) (l *lambdaExpr, err evaluated) {
 
 func (x *structLit) binOp(ctx *context, src source, op op, other evaluated) evaluated {
 	y, ok := other.(*structLit)
-	if !ok || op != opUnify {
+	_, isUnify := op.unifyType()
+	if !ok || !isUnify {
 		return ctx.mkIncompatible(src, op, x, other)
 	}
 
@@ -594,7 +595,14 @@ func (x *structLit) binOp(ctx *context, src source, op op, other evaluated) eval
 		return x
 	}
 	arcs := make(arcs, 0, len(x.arcs)+len(y.arcs))
-	obj := &structLit{binSrc(src.Pos(), op, x, other), x.emit, nil, nil, arcs, nil}
+	obj := &structLit{
+		binSrc(src.Pos(), op, x, other), // baseValue
+		x.emit,                          // emit
+		nil,                             // template
+		nil,                             // comprehensions
+		arcs,                            // arcs
+		nil,                             // attributes
+	}
 	defer ctx.pushForwards(x, obj, y, obj).popForwards()
 
 	tx, ex := evalLambda(ctx, x.template)

cue/errors.go

@@ -147,7 +147,7 @@ func (x *bottom) Positions() []token.Pos {
 func appendPositions(pos []token.Pos, src source) []token.Pos {
 	if src != nil {
 		if b, ok := src.(*binaryExpr); ok {
-			if b.op == opUnify {
+			if _, isUnify := b.op.unifyType(); isUnify {
 				pos = appendPositions(pos, b.left)
 				pos = appendPositions(pos, b.right)
 			}

cue/eval.go

@@ -365,7 +365,7 @@ func (x *binaryExpr) evalPartial(ctx *context) (result evaluated) {
 	}
 	var left, right evaluated
 
-	if x.op != opUnify {
+	if _, isUnify := x.op.unifyType(); !isUnify {
 		ctx.incEvalDepth()
 		left = ctx.manifest(x.left)
 		right = ctx.manifest(x.right)

cue/export.go

@@ -352,104 +352,7 @@ func (p *exporter) expr(v value) ast.Expr {
 		return bin
 
 	case *structLit:
-		obj := &ast.StructLit{}
-		if doEval(p.mode) {
-			x = x.expandFields(p.ctx)
-		}
-		for _, a := range x.arcs {
-			p.stack = append(p.stack, remap{
-				key:  x,
-				from: a.feature,
-				to:   nil,
-				syn:  obj,
-			})
-		}
-		if x.emit != nil {
-			obj.Elts = append(obj.Elts, &ast.EmbedDecl{Expr: p.expr(x.emit)})
-		}
-		if !doEval(p.mode) && x.template != nil {
-			l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
-			if ok {
-				obj.Elts = append(obj.Elts, &ast.Field{
-					Label: &ast.TemplateLabel{
-						Ident: p.identifier(l.params.arcs[0].feature),
-					},
-					Value: p.expr(l.value),
-				})
-			} // TODO: else record error
-		}
-		for i, a := range x.arcs {
-			f := &ast.Field{
-				Label: p.label(a.feature),
-			}
-			// TODO: allow the removal of hidden fields. However, hidden fields
-			// that still used in incomplete expressions should not be removed
-			// (unless RequireConcrete is requested).
-			if a.optional {
-				// Optional fields are almost never concrete. We omit them in
-				// concrete mode to allow the user to use the -a option in eval
-				// without getting many errors.
-				if p.mode.omitOptional || p.mode.concrete {
-					continue
-				}
-				f.Optional = token.NoSpace.Pos()
-			}
-			if a.feature&hidden != 0 && p.mode.concrete && p.mode.omitHidden {
-				continue
-			}
-			if !doEval(p.mode) {
-				f.Value = p.expr(a.v)
-			} else {
-				e := x.at(p.ctx, i)
-				if v := p.ctx.manifest(e); isIncomplete(v) && !p.mode.concrete && isBottom(e) {
-					p := &exporter{p.ctx, options{raw: true}, p.stack, p.top, p.imports}
-					f.Value = p.expr(a.v)
-				} else {
-					f.Value = p.expr(e)
-				}
-			}
-			if a.attrs != nil && !p.mode.omitAttrs {
-				for _, at := range a.attrs.attr {
-					f.Attrs = append(f.Attrs, &ast.Attribute{Text: at.text})
-				}
-			}
-			obj.Elts = append(obj.Elts, f)
-		}
-
-		for _, c := range x.comprehensions {
-			var clauses []ast.Clause
-			next := c.clauses
-			for {
-				if yield, ok := next.(*yield); ok {
-					l := p.expr(yield.key)
-					label, ok := l.(ast.Label)
-					if !ok {
-						// TODO: add an invalid field instead?
-						continue
-					}
-					opt := token.NoPos
-					if yield.opt {
-						opt = token.NoSpace.Pos() // anything but token.NoPos
-					}
-					f := &ast.Field{
-						Label:    label,
-						Optional: opt,
-						Value:    p.expr(yield.value),
-					}
-					var decl ast.Decl = f
-					if len(clauses) > 0 {
-						decl = &ast.ComprehensionDecl{Field: f, Clauses: clauses}
-					}
-					obj.Elts = append(obj.Elts, decl)
-					break
-				}
-
-				var y ast.Clause
-				y, next = p.clause(next)
-				clauses = append(clauses, y)
-			}
-		}
-		return obj
+		return p.structure(x)
 
 	case *fieldComprehension:
 		panic("should be handled in structLit")
@@ -607,6 +510,107 @@ func (p *exporter) expr(v value) ast.Expr {
 	}
 }
 
+func (p *exporter) structure(x *structLit) *ast.StructLit {
+	obj := &ast.StructLit{}
+	if doEval(p.mode) {
+		x = x.expandFields(p.ctx)
+	}
+	for _, a := range x.arcs {
+		p.stack = append(p.stack, remap{
+			key:  x,
+			from: a.feature,
+			to:   nil,
+			syn:  obj,
+		})
+	}
+	if x.emit != nil {
+		obj.Elts = append(obj.Elts, &ast.EmbedDecl{Expr: p.expr(x.emit)})
+	}
+	if !doEval(p.mode) && x.template != nil {
+		l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
+		if ok {
+			obj.Elts = append(obj.Elts, &ast.Field{
+				Label: &ast.TemplateLabel{
+					Ident: p.identifier(l.params.arcs[0].feature),
+				},
+				Value: p.expr(l.value),
+			})
+		} // TODO: else record error
+	}
+	for i, a := range x.arcs {
+		f := &ast.Field{
+			Label: p.label(a.feature),
+		}
+		// TODO: allow the removal of hidden fields. However, hidden fields
+		// that still used in incomplete expressions should not be removed
+		// (unless RequireConcrete is requested).
+		if a.optional {
+			// Optional fields are almost never concrete. We omit them in
+			// concrete mode to allow the user to use the -a option in eval
+			// without getting many errors.
+			if p.mode.omitOptional || p.mode.concrete {
+				continue
+			}
+			f.Optional = token.NoSpace.Pos()
+		}
+		if a.feature&hidden != 0 && p.mode.concrete && p.mode.omitHidden {
+			continue
+		}
+		if !doEval(p.mode) {
+			f.Value = p.expr(a.v)
+		} else {
+			e := x.at(p.ctx, i)
+			if v := p.ctx.manifest(e); isIncomplete(v) && !p.mode.concrete && isBottom(e) {
+				p := &exporter{p.ctx, options{raw: true}, p.stack, p.top, p.imports}
+				f.Value = p.expr(a.v)
+			} else {
+				f.Value = p.expr(e)
+			}
+		}
+		if a.attrs != nil && !p.mode.omitAttrs {
+			for _, at := range a.attrs.attr {
+				f.Attrs = append(f.Attrs, &ast.Attribute{Text: at.text})
+			}
+		}
+		obj.Elts = append(obj.Elts, f)
+	}
+
+	for _, c := range x.comprehensions {
+		var clauses []ast.Clause
+		next := c.clauses
+		for {
+			if yield, ok := next.(*yield); ok {
+				l := p.expr(yield.key)
+				label, ok := l.(ast.Label)
+				if !ok {
+					// TODO: add an invalid field instead?
+					continue
+				}
+				opt := token.NoPos
+				if yield.opt {
+					opt = token.NoSpace.Pos() // anything but token.NoPos
+				}
+				f := &ast.Field{
+					Label:    label,
+					Optional: opt,
+					Value:    p.expr(yield.value),
+				}
+				var decl ast.Decl = f
+				if len(clauses) > 0 {
+					decl = &ast.ComprehensionDecl{Field: f, Clauses: clauses}
+				}
+				obj.Elts = append(obj.Elts, decl)
+				break
+			}
+
+			var y ast.Clause
+			y, next = p.clause(next)
+			clauses = append(clauses, y)
+		}
+	}
+	return obj
+}
+
 // quote quotes the given string.
 func quote(str string, quote byte) string {
 	if strings.IndexByte(str, '\n') < 0 {

cue/op.go

@@ -133,6 +133,10 @@ func (op op) isCmp() bool {
 	return opEql <= op && op <= opGeq
 }
 
+func (op op) unifyType() (unchecked, ok bool) {
+	return false, op == opUnify
+}
+
 type op uint16
 
 const (