diff --git a/internal/cgen/expr.go b/internal/cgen/expr.go index fa5ad27e..566ca9f0 100644 --- a/internal/cgen/expr.go +++ b/internal/cgen/expr.go @@ -77,13 +77,13 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, depth uint32) error { } } 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 65304aff..95e20a1e 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -160,7 +160,7 @@ type Node struct { // 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 @@ const MaxExprDepth = 255 // 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: // - MHS: @@ -331,8 +330,7 @@ const MaxExprDepth = 255 // - List0: 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) ConstValue() *big.Int { return n.constValue } 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) SetGlobalIdent() { n.flags |= FlagsGlobalIdent } 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 @@ func NewExpr(flags Flags, operator t.ID, statusPkg t.ID, ident t.ID, lhs *Node, 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 8456d908..675f701a 100644 --- a/lang/check/assert.go +++ b/lang/check/assert.go @@ -58,7 +58,7 @@ func otherHandSide(n *a.Expr, thisHS *a.Expr) (op t.ID, thatHS *a.Expr) { 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 @@ func simplify(tm *t.Map, n *a.Expr) (*a.Expr, error) { 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 @@ func proveReasonRequirement(q *checker, op t.ID, lhs *a.Expr, rhs *a.Expr) error "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 0ce1f32d..776b89fd 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -68,7 +68,7 @@ var ( 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 @@ func invert(tm *t.Map, n *a.Expr) (*a.Expr, error) { 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 @@ func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error { } 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 @@ func (q *checker) bcheckVar(n *a.Var) error { 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 @@ func makeConstValueExpr(tm *t.Map, cv *big.Int) (*a.Expr, error) { 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 @@ func makeConstValueExpr(tm *t.Map, cv *big.Int) (*a.Expr, error) { // 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 @@ func makeSliceLength(slice *a.Expr) *a.Expr { // // 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 @@ func makeSliceLengthEqEq(x t.ID, xTyp *a.TypeExpr, n t.ID) *a.Expr { } 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 @@ func (q *checker) bcheckExprAssociativeOp(n *a.Expr, depth uint32) (bounds, erro 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 414941a0..9a40cb72 100644 --- a/lang/check/check.go +++ b/lang/check/check.go @@ -140,7 +140,7 @@ func Check(tm *t.Map, files []*a.File, resolveUse func(usePath string) ([]byte, 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 345a833a..b1cc71d9 100644 --- a/lang/check/data.go +++ b/lang/check/data.go @@ -307,7 +307,7 @@ var reasons = [...]struct { 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 @@ var reasons = [...]struct { 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 712f9ac1..275d96ae 100644 --- a/lang/check/gen.go +++ b/lang/check/gen.go @@ -230,7 +230,7 @@ func genProveReasonRequirement(n *node, name string) error { 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 c9893794..7cd56df8 100644 --- a/lang/check/optimize.go +++ b/lang/check/optimize.go @@ -109,7 +109,7 @@ func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, up } 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 09cfcfae..c09629cb 100644 --- a/lang/check/resolve.go +++ b/lang/check/resolve.go @@ -24,9 +24,9 @@ import ( ) 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 648b622f..01d243b7 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -359,8 +359,8 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error { 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 52a9b23b..298ad498 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -1228,7 +1228,7 @@ func (p *parser) parsePossibleListExpr() (*a.Expr, error) { 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 @@ func (p *parser) parseExpr1() (*a.Expr, error) { 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 @@ func (p *parser) parseExpr1() (*a.Expr, error) { 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 @@ func (p *parser) parseOperand() (*a.Expr, error) { 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 @@ func (p *parser) parseOperand() (*a.Expr, error) { 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 @@ func (p *parser) parseOperand() (*a.Expr, error) { 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 @@ func (p *parser) parseOperand() (*a.Expr, error) { 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) } } }