Remove ast.NewExpr statusPkg arg
diff --git a/internal/cgen/expr.go b/internal/cgen/expr.go
index fa5ad27..566ca9f 100644
--- a/internal/cgen/expr.go
+++ b/internal/cgen/expr.go
@@ -77,13 +77,13 @@
}
} else if ident.IsDQStrLiteral(g.tm) {
- if z := g.statusMap[n.StatusQID()]; z.cName != "" {
+ if z := g.statusMap[t.QID{0, n.Ident()}]; z.cName != "" {
b.writes("wuffs_base__make_status(")
b.writes(z.cName)
b.writes(")")
return nil
}
- return fmt.Errorf("unrecognized status %s", n.StatusQID().Str(g.tm))
+ return fmt.Errorf("unrecognized status %s", n.Str(g.tm))
} else if c, ok := g.scalarConstsMap[t.QID{0, n.Ident()}]; ok {
b.writes(c.Value().ConstValue().String())
diff --git a/lang/ast/ast.go b/lang/ast/ast.go
index 65304af..95e20a1 100644
--- a/lang/ast/ast.go
+++ b/lang/ast/ast.go
@@ -160,7 +160,7 @@
// Assert keyword . lit(reason) Assert
// Assign operator . . Assign
// Const . pkg name Const
- // Expr operator pkg literal/ident Expr
+ // Expr operator . literal/ident Expr
// Field . . name Field
// File . . . File
// Func funcName receiverPkg receiverName Func
@@ -323,7 +323,6 @@
// Expr is an expression, such as "i", "+j" or "k + l[m(n, o)].p":
// - ID0: <0|operator|IDOpenParen|IDOpenBracket|IDDotDot|IDDot>
-// - ID1: <0|pkg> (for statuses)
// - ID2: <0|literal|ident>
// - LHS: <nil|Expr>
// - MHS: <nil|Expr>
@@ -331,8 +330,7 @@
// - List0: <Arg|Expr> function call args, assoc. op args or list members.
//
// A zero ID0 means an identifier or literal in ID2, like `foo`, `42` or a
-// status literal like `"#foo"` or `pkg."$bar"`. For status literals, ID1 is
-// the package.
+// status literal like `"#foo"`.
//
// For unary operators, ID0 is the operator and RHS is the operand.
//
@@ -362,7 +360,6 @@
func (n *Expr) MBounds() interval.IntRange { return n.mBounds }
func (n *Expr) MType() *TypeExpr { return n.mType }
func (n *Expr) Operator() t.ID { return n.id0 }
-func (n *Expr) StatusQID() t.QID { return t.QID{n.id1, n.id2} }
func (n *Expr) Ident() t.ID { return n.id2 }
func (n *Expr) LHS() *Node { return n.lhs }
func (n *Expr) MHS() *Node { return n.mhs }
@@ -374,7 +371,7 @@
func (n *Expr) SetMBounds(x interval.IntRange) { n.mBounds = x }
func (n *Expr) SetMType(x *TypeExpr) { n.mType = x }
-func NewExpr(flags Flags, operator t.ID, statusPkg t.ID, ident t.ID, lhs *Node, mhs *Node, rhs *Node, args []*Node) *Expr {
+func NewExpr(flags Flags, operator t.ID, ident t.ID, lhs *Node, mhs *Node, rhs *Node, args []*Node) *Expr {
subExprEffect := Flags(0)
if lhs != nil {
subExprEffect |= lhs.flags & Flags(effectMask)
@@ -396,7 +393,6 @@
kind: KExpr,
flags: flags,
id0: operator,
- id1: statusPkg,
id2: ident,
lhs: lhs,
mhs: mhs,
diff --git a/lang/check/assert.go b/lang/check/assert.go
index 8456d90..675f701 100644
--- a/lang/check/assert.go
+++ b/lang/check/assert.go
@@ -58,7 +58,7 @@
type facts []*a.Expr
func (z *facts) appendBinaryOpFact(op t.ID, lhs *a.Expr, rhs *a.Expr) {
- o := a.NewExpr(0, op, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
+ o := a.NewExpr(0, op, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
o.SetMBounds(bounds{zero, one})
o.SetMType(typeExprBool)
z.appendFact(o)
@@ -210,7 +210,7 @@
return nil, err
}
if l != lhs || r != rhs {
- o := a.NewExpr(0, op, 0, 0, l.AsNode(), nil, r.AsNode(), nil)
+ o := a.NewExpr(0, op, 0, l.AsNode(), nil, r.AsNode(), nil)
o.SetConstValue(n.ConstValue())
o.SetMType(n.MType())
return o, nil
@@ -343,7 +343,7 @@
"check: internal error: proveReasonRequirement token (0x%X) is not an XBinaryOp", op)
}
if err := q.proveBinaryOp(op, lhs, rhs); err != nil {
- n := a.NewExpr(0, op, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
+ n := a.NewExpr(0, op, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
return fmt.Errorf("cannot prove %q: %v", n.Str(q.tm), err)
}
return nil
diff --git a/lang/check/bounds.go b/lang/check/bounds.go
index 0ce1f32..776b89f 100644
--- a/lang/check/bounds.go
+++ b/lang/check/bounds.go
@@ -68,7 +68,7 @@
maxIntBits = big.NewInt(t.MaxIntBits)
- zeroExpr = a.NewExpr(0, 0, 0, t.ID0, nil, nil, nil, nil)
+ zeroExpr = a.NewExpr(0, 0, t.ID0, nil, nil, nil, nil)
)
func init() {
@@ -190,7 +190,7 @@
default:
op, lhs, rhs = t.IDXUnaryNot, nil, n
}
- o := a.NewExpr(n.AsNode().AsRaw().Flags(), op, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), args)
+ o := a.NewExpr(n.AsNode().AsRaw().Flags(), op, 0, lhs.AsNode(), nil, rhs.AsNode(), args)
o.SetMType(n.MType())
return o, nil
}
@@ -457,14 +457,14 @@
}
switch op {
case t.IDPlusEq, t.IDMinusEq:
- oRHS := a.NewExpr(0, op.BinaryForm(), 0, 0, xRHS.AsNode(), nil, rhs.AsNode(), nil)
+ oRHS := a.NewExpr(0, op.BinaryForm(), 0, xRHS.AsNode(), nil, rhs.AsNode(), nil)
// TODO: call SetMBounds?
oRHS.SetMType(typeExprIdeal)
oRHS, err := simplify(q.tm, oRHS)
if err != nil {
return nil, err
}
- o := a.NewExpr(0, xOp, 0, 0, xLHS.AsNode(), nil, oRHS.AsNode(), nil)
+ o := a.NewExpr(0, xOp, 0, xLHS.AsNode(), nil, oRHS.AsNode(), nil)
o.SetMBounds(bounds{zero, one})
o.SetMType(typeExprBool)
return o, nil
@@ -712,7 +712,7 @@
return err
}
- lhs := a.NewExpr(0, 0, 0, n.Name(), nil, nil, nil, nil)
+ lhs := a.NewExpr(0, 0, n.Name(), nil, nil, nil, nil)
lhs.SetMType(n.XType())
// "var x T" has an implicit "= 0".
//
@@ -1265,7 +1265,7 @@
if err != nil {
return nil, err
}
- o := a.NewExpr(0, 0, 0, id, nil, nil, nil, nil)
+ o := a.NewExpr(0, 0, id, nil, nil, nil, nil)
o.SetConstValue(cv)
o.SetMBounds(bounds{cv, cv})
o.SetMType(typeExprIdeal)
@@ -1274,10 +1274,10 @@
// makeSliceLength returns "x.length()".
func makeSliceLength(slice *a.Expr) *a.Expr {
- x := a.NewExpr(0, t.IDDot, 0, t.IDLength, slice.AsNode(), nil, nil, nil)
+ x := a.NewExpr(0, t.IDDot, t.IDLength, slice.AsNode(), nil, nil, nil)
x.SetMBounds(bounds{one, one})
x.SetMType(a.NewTypeExpr(t.IDFunc, 0, t.IDLength, slice.MType().AsNode(), nil, nil))
- x = a.NewExpr(0, t.IDOpenParen, 0, 0, x.AsNode(), nil, nil, nil)
+ x = a.NewExpr(0, t.IDOpenParen, 0, x.AsNode(), nil, nil, nil)
// TODO: call SetMBounds?
x.SetMType(typeExprU64)
return x
@@ -1287,7 +1287,7 @@
//
// n must be the t.ID of a small power of 2.
func makeSliceLengthEqEq(x t.ID, xTyp *a.TypeExpr, n t.ID) *a.Expr {
- xExpr := a.NewExpr(0, 0, 0, x, nil, nil, nil, nil)
+ xExpr := a.NewExpr(0, 0, x, nil, nil, nil, nil)
xExpr.SetMType(xTyp)
lhs := makeSliceLength(xExpr)
@@ -1298,12 +1298,12 @@
}
cv := big.NewInt(int64(nValue))
- rhs := a.NewExpr(0, 0, 0, n, nil, nil, nil, nil)
+ rhs := a.NewExpr(0, 0, n, nil, nil, nil, nil)
rhs.SetConstValue(cv)
rhs.SetMBounds(bounds{cv, cv})
rhs.SetMType(typeExprIdeal)
- ret := a.NewExpr(0, t.IDXBinaryEqEq, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
+ ret := a.NewExpr(0, t.IDXBinaryEqEq, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
ret.SetMBounds(bounds{zero, one})
ret.SetMType(typeExprBool)
return ret
@@ -1514,7 +1514,7 @@
continue
}
lhs := a.NewExpr(n.AsNode().AsRaw().Flags(),
- n.Operator(), 0, n.Ident(), n.LHS(), n.MHS(), n.RHS(), args[:i])
+ n.Operator(), n.Ident(), n.LHS(), n.MHS(), n.RHS(), args[:i])
lb, err = q.bcheckExprBinaryOp1(op, lhs, lb, o.AsExpr(), depth)
if err != nil {
return bounds{}, err
diff --git a/lang/check/check.go b/lang/check/check.go
index 414941a..9a40cb7 100644
--- a/lang/check/check.go
+++ b/lang/check/check.go
@@ -140,7 +140,7 @@
if err != nil {
return nil, err
}
- cNode := a.NewConst(0, "", 0, name, xType, a.NewExpr(0, 0, 0, value, nil, nil, nil, nil))
+ cNode := a.NewConst(0, "", 0, name, xType, a.NewExpr(0, 0, value, nil, nil, nil, nil))
if err := c.checkConst(cNode.AsNode()); err != nil {
return nil, err
}
diff --git a/lang/check/data.go b/lang/check/data.go
index 345a833..b1cc71d 100644
--- a/lang/check/data.go
+++ b/lang/check/data.go
@@ -307,7 +307,7 @@
if xc0 == nil {
return errFailed
}
- t1 := a.NewExpr(0, t.IDXBinaryPlus, 0, 0, xb0.AsNode(), nil, xc0.AsNode(), nil)
+ t1 := a.NewExpr(0, t.IDXBinaryPlus, 0, xb0.AsNode(), nil, xc0.AsNode(), nil)
if err := proveReasonRequirement(q, t.IDXBinaryLessThan, xa, t1); err != nil {
return err
}
@@ -355,7 +355,7 @@
return errFailed
}
// a <= (c - b)
- t1 := a.NewExpr(0, t.IDXBinaryMinus, 0, 0, xc.AsNode(), nil, xb.AsNode(), nil)
+ t1 := a.NewExpr(0, t.IDXBinaryMinus, 0, xc.AsNode(), nil, xb.AsNode(), nil)
if err := proveReasonRequirement(q, t.IDXBinaryLessEq, xa, t1); err != nil {
return err
}
diff --git a/lang/check/gen.go b/lang/check/gen.go
index 712f9ac..275d96a 100644
--- a/lang/check/gen.go
+++ b/lang/check/gen.go
@@ -230,7 +230,7 @@
fmt.Fprintf(&out, "if err := proveReasonRequirement(q, t.ID%s, %s, %s); err != nil { return err }\n",
key, l, r)
} else {
- fmt.Fprintf(&out, "%s := a.NewExpr(0, t.ID%s, 0, 0, %s.AsNode(), nil, %s.AsNode(), nil)\n",
+ fmt.Fprintf(&out, "%s := a.NewExpr(0, t.ID%s, 0, %s.AsNode(), nil, %s.AsNode(), nil)\n",
name, key, l, r)
}
return nil
diff --git a/lang/check/optimize.go b/lang/check/optimize.go
index c989379..7cd56df 100644
--- a/lang/check/optimize.go
+++ b/lang/check/optimize.go
@@ -109,7 +109,7 @@
}
return a.NewExpr(x.AsNode().AsRaw().Flags(),
- t.IDXBinaryGreaterEq, 0, 0, x.LHS(), nil, o.AsNode(), nil), nil
+ t.IDXBinaryGreaterEq, 0, x.LHS(), nil, o.AsNode(), nil), nil
})
return retOK, retErr
}
diff --git a/lang/check/resolve.go b/lang/check/resolve.go
index 09cfcfa..c09629c 100644
--- a/lang/check/resolve.go
+++ b/lang/check/resolve.go
@@ -24,9 +24,9 @@
)
var (
- exprArgs = a.NewExpr(0, 0, 0, t.IDArgs, nil, nil, nil, nil)
- exprNullptr = a.NewExpr(0, 0, 0, t.IDNullptr, nil, nil, nil, nil)
- exprThis = a.NewExpr(0, 0, 0, t.IDThis, nil, nil, nil, nil)
+ exprArgs = a.NewExpr(0, 0, t.IDArgs, nil, nil, nil, nil)
+ exprNullptr = a.NewExpr(0, 0, t.IDNullptr, nil, nil, nil, nil)
+ exprThis = a.NewExpr(0, 0, t.IDThis, nil, nil, nil, nil)
)
var (
diff --git a/lang/check/type.go b/lang/check/type.go
index 648b622..01d243b 100644
--- a/lang/check/type.go
+++ b/lang/check/type.go
@@ -359,8 +359,8 @@
return nil
} else if id1.IsDQStrLiteral(q.tm) {
- if _, ok := q.c.statuses[n.StatusQID()]; !ok {
- return fmt.Errorf("check: unrecognized status %s", n.StatusQID().Str(q.tm))
+ if _, ok := q.c.statuses[t.QID{0, n.Ident()}]; !ok {
+ return fmt.Errorf("check: unrecognized status %s", n.Ident().Str(q.tm))
}
n.SetMType(typeExprStatus)
return nil
diff --git a/lang/parse/parse.go b/lang/parse/parse.go
index 52a9b23..298ad49 100644
--- a/lang/parse/parse.go
+++ b/lang/parse/parse.go
@@ -1228,7 +1228,7 @@
if err != nil {
return nil, err
}
- return a.NewExpr(0, t.IDComma, 0, 0, nil, nil, nil, args), nil
+ return a.NewExpr(0, t.IDComma, 0, nil, nil, nil, args), nil
}
func (p *parser) parseExpr() (*a.Expr, error) {
@@ -1270,7 +1270,7 @@
if op == 0 {
return nil, fmt.Errorf(`parse: internal error: no binary form for token 0x%02X`, x)
}
- return a.NewExpr(0, op, 0, 0, lhs.AsNode(), nil, rhs, nil), nil
+ return a.NewExpr(0, op, 0, lhs.AsNode(), nil, rhs, nil), nil
}
args := []*a.Node{lhs.AsNode(), rhs}
@@ -1286,7 +1286,7 @@
if op == 0 {
return nil, fmt.Errorf(`parse: internal error: no associative form for token 0x%02X`, x)
}
- return a.NewExpr(0, op, 0, 0, nil, nil, nil, args), nil
+ return a.NewExpr(0, op, 0, nil, nil, nil, args), nil
}
return lhs, nil
}
@@ -1303,11 +1303,11 @@
if op == 0 {
return nil, fmt.Errorf(`parse: internal error: no unary form for token 0x%02X`, x)
}
- return a.NewExpr(0, op, 0, 0, nil, nil, rhs.AsNode(), nil), nil
+ return a.NewExpr(0, op, 0, nil, nil, rhs.AsNode(), nil), nil
case x.IsLiteral(p.tm):
p.src = p.src[1:]
- return a.NewExpr(0, 0, 0, x, nil, nil, nil, nil), nil
+ return a.NewExpr(0, 0, x, nil, nil, nil, nil), nil
case x == t.IDOpenParen:
p.src = p.src[1:]
@@ -1327,7 +1327,7 @@
if err != nil {
return nil, err
}
- lhs := a.NewExpr(0, 0, 0, id, nil, nil, nil, nil)
+ lhs := a.NewExpr(0, 0, id, nil, nil, nil, nil)
for first := true; ; first = false {
flags := a.Flags(0)
@@ -1344,14 +1344,14 @@
if err != nil {
return nil, err
}
- lhs = a.NewExpr(flags, t.IDOpenParen, 0, 0, lhs.AsNode(), nil, nil, args)
+ lhs = a.NewExpr(flags, t.IDOpenParen, 0, lhs.AsNode(), nil, nil, args)
case t.IDOpenBracket:
id0, mhs, rhs, err := p.parseBracket(t.IDDotDot)
if err != nil {
return nil, err
}
- lhs = a.NewExpr(0, id0, 0, 0, lhs.AsNode(), mhs.AsNode(), rhs.AsNode(), nil)
+ lhs = a.NewExpr(0, id0, 0, lhs.AsNode(), mhs.AsNode(), rhs.AsNode(), nil)
case t.IDDot:
p.src = p.src[1:]
@@ -1364,7 +1364,7 @@
return nil, err
}
}
- lhs = a.NewExpr(0, t.IDDot, 0, selector, lhs.AsNode(), nil, nil, nil)
+ lhs = a.NewExpr(0, t.IDDot, selector, lhs.AsNode(), nil, nil, nil)
}
}
}
