Files
wuffs/lang/check/assert.go
T

197 lines
4.1 KiB
Go

// Use of this source code is governed by a BSD-style license that can be found
// in the LICENSE file.
package check
import (
"errors"
"fmt"
"math/big"
a "github.com/google/puffs/lang/ast"
t "github.com/google/puffs/lang/token"
)
type facts []*a.Expr
func (z *facts) appendFact(x *a.Expr) {
// TODO: make this faster than O(N) by keeping facts sorted somehow?
for _, f := range *z {
if f.Eq(x) {
return
}
}
*z = append(*z, x)
}
func (z facts) refine(n *a.Expr, nMin *big.Int, nMax *big.Int) (*big.Int, *big.Int) {
if n.ID0() != 0 || !n.ID1().IsIdent() {
// TODO.
return nMin, nMax
}
for _, f := range z {
fMin, fMax := refine(f, n.ID1())
if fMin != nil && nMin.Cmp(fMin) < 0 {
nMin = fMin
}
if fMax != nil && nMax.Cmp(fMax) > 0 {
nMax = fMax
}
}
return nMin, nMax
}
// refine returns fact's lower or upper bound for id.
func refine(fact *a.Expr, id t.ID) (*big.Int, *big.Int) {
op := fact.ID0()
if !op.IsBinaryOp() || op.Key() == t.KeyAs {
return nil, nil
}
lhs := fact.LHS().Expr()
rhs := fact.RHS().Expr()
cv := (*big.Int)(nil)
idLeft := lhs.ID0() == 0 && lhs.ID1() == id
if idLeft {
cv = rhs.ConstValue()
} else {
if rhs.ID0() != 0 || rhs.ID1() != id {
return nil, nil
}
cv = lhs.ConstValue()
}
if cv == nil {
return nil, nil
}
switch op.Key() {
case t.KeyXBinaryLessThan:
if idLeft {
return nil, sub1(cv)
} else {
return add1(cv), nil
}
case t.KeyXBinaryLessEq:
if idLeft {
return nil, cv
} else {
return cv, nil
}
case t.KeyXBinaryGreaterEq:
if idLeft {
return cv, nil
} else {
return nil, cv
}
case t.KeyXBinaryGreaterThan:
if idLeft {
return add1(cv), nil
} else {
return nil, sub1(cv)
}
}
return nil, nil
}
func argValue(m *t.IDMap, args []*a.Node, name string) *a.Expr {
if x := m.ByName(name); x != 0 {
for _, a := range args {
if a.Arg().Name() == x {
return a.Arg().Value()
}
}
}
return nil
}
// parseBinaryOp parses n as "lhs op rhs".
func parseBinaryOp(n *a.Expr) (op t.Key, lhs *a.Expr, rhs *a.Expr) {
if !n.ID0().IsBinaryOp() {
return 0, nil, nil
}
op = n.ID0().Key()
if op == t.KeyAs {
return 0, nil, nil
}
return op, n.LHS().Expr(), n.RHS().Expr()
}
func proveBinaryOpConstValues(op t.Key, lMin *big.Int, lMax *big.Int, rMin *big.Int, rMax *big.Int) (ok bool) {
switch op {
case t.KeyXBinaryNotEq:
return lMax.Cmp(rMin) < 0 || lMin.Cmp(rMax) > 0
case t.KeyXBinaryLessThan:
return lMax.Cmp(rMin) < 0
case t.KeyXBinaryLessEq:
return lMax.Cmp(rMin) <= 0
case t.KeyXBinaryEqEq:
return lMin.Cmp(rMax) == 0 && lMax.Cmp(rMin) == 0
case t.KeyXBinaryGreaterEq:
return lMin.Cmp(rMax) >= 0
case t.KeyXBinaryGreaterThan:
return lMin.Cmp(rMax) > 0
}
return false
}
func (q *checker) proveBinaryOp(op t.Key, lhs *a.Expr, rhs *a.Expr) (ok bool) {
if cv := lhs.ConstValue(); cv != nil {
rMin, rMax, err := q.bcheckExpr(rhs, 0)
if err != nil {
// TODO: should this function return the error?
return false
}
if proveBinaryOpConstValues(op, cv, cv, rMin, rMax) {
return true
}
}
if cv := rhs.ConstValue(); cv != nil {
lMin, lMax, err := q.bcheckExpr(lhs, 0)
if err != nil {
// TODO: should this function return the error?
return false
}
if proveBinaryOpConstValues(op, lMin, lMax, cv, cv) {
return true
}
}
for _, f := range q.facts {
if f.ID0().Key() == op && f.LHS().Expr().Eq(lhs) && f.RHS().Expr().Eq(rhs) {
return true
}
}
return false
}
var errFailed = errors.New("failed")
type reason func(q *checker, n *a.Assert) error
type reasonMap map[t.Key]reason
var reasons = [...]struct {
s string
r reason
}{
{`"a < b: a < c <= b"`, func(q *checker, n *a.Assert) error {
c := argValue(q.idMap, n.Args(), "c")
if c == nil {
return errFailed
}
op, a, b := parseBinaryOp(n.Condition())
if op != t.KeyXBinaryLessThan {
return errFailed
}
if !q.proveBinaryOp(t.KeyXBinaryLessThan, a, c) {
return fmt.Errorf("cannot prove \"%s < %s\"", a.String(q.idMap), c.String(q.idMap))
}
if !q.proveBinaryOp(t.KeyXBinaryLessEq, c, b) {
return fmt.Errorf("cannot prove \"%s <= %s\"", c.String(q.idMap), b.String(q.idMap))
}
return nil
}},
}