From c9e6ee6fb30d3b75ee901f68fffb3afe388c86de Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Thu, 27 Dec 2018 17:36:08 +1100 Subject: [PATCH] Fold Expr statements into Assign statements --- cmd/wuffs-c/internal/cgen/resume.go | 4 ++++ cmd/wuffs-c/internal/cgen/statement.go | 14 +---------- lang/ast/ast.go | 5 ++-- lang/check/bounds.go | 32 +++++++++++++++----------- lang/check/type.go | 12 +++++----- lang/parse/parse.go | 5 ++-- 6 files changed, 34 insertions(+), 38 deletions(-) diff --git a/cmd/wuffs-c/internal/cgen/resume.go b/cmd/wuffs-c/internal/cgen/resume.go index 8ce80f0f..544b9cd3 100644 --- a/cmd/wuffs-c/internal/cgen/resume.go +++ b/cmd/wuffs-c/internal/cgen/resume.go @@ -240,6 +240,10 @@ func (h *resumabilityHelper) doAssign(r resumabilities, n *a.Assign, depth uint3 return err } + if n.LHS() == nil { + return nil + } + // If the LHS is not a local variable (e.g. "this.foo[bar] = etc", or if // the LHS is implicitly also on the RHS (e.g. for a += or *= operator), // walk the LHS Expr. diff --git a/cmd/wuffs-c/internal/cgen/statement.go b/cmd/wuffs-c/internal/cgen/statement.go index f3ebfb9e..13dc2b44 100644 --- a/cmd/wuffs-c/internal/cgen/statement.go +++ b/cmd/wuffs-c/internal/cgen/statement.go @@ -39,15 +39,7 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error { return nil } - mightIntroduceTemporaries := false - switch n.Kind() { - case a.KAssign: - n := n.AsAssign() - mightIntroduceTemporaries = n.RHS().Effect().Coroutine() - case a.KExpr: - // TODO. - } - if mightIntroduceTemporaries { + if (n.Kind() == a.KAssign) && (n.AsAssign().LHS() != nil) && n.AsAssign().RHS().Effect().Coroutine() { // Put n's code into its own block, to restrict the scope of the // tPrefix temporary variables. This helps avoid "jump bypasses // variable initialization" compiler warnings with the coroutine @@ -71,8 +63,6 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error { case a.KAssign: n := n.AsAssign() return g.writeStatementAssign(b, n.Operator(), n.LHS(), n.RHS(), depth) - case a.KExpr: - return g.writeStatementAssign(b, 0, nil, n.AsExpr(), depth) case a.KIOBind: return g.writeStatementIOBind(b, n.AsIOBind(), depth) case a.KIf: @@ -92,8 +82,6 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error { } func (g *gen) writeStatementAssign(b *buffer, op t.ID, lhs *a.Expr, rhs *a.Expr, depth uint32) error { - // TODO: clean this method body up. - if depth > a.MaxExprDepth { return fmt.Errorf("expression recursion depth too large") } diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 8c83d9f0..19c2cd29 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -414,9 +414,9 @@ func NewArg(name t.ID, value *Expr) *Arg { } } -// Assign is "LHS = RHS" or "LHS op= RHS": +// Assign is "LHS = RHS" or "LHS op= RHS" or "RHS": // - ID0: operator -// - LHS: +// - LHS: // - RHS: type Assign Node @@ -791,7 +791,6 @@ const MaxBodyDepth = 255 // Statement means one of: // - Assert // - Assign -// - Expr // - IOBind // - If // - Iterate diff --git a/lang/check/bounds.go b/lang/check/bounds.go index d718d659..da96a319 100644 --- a/lang/check/bounds.go +++ b/lang/check/bounds.go @@ -230,12 +230,6 @@ func (q *checker) bcheckStatement(n *a.Node) error { return err } - case a.KExpr: - n := n.AsExpr() - if _, err := q.bcheckExpr(n, 0); err != nil { - return err - } - case a.KIOBind: n := n.AsIOBind() if _, err := q.bcheckExpr(n.IO(), 0); err != nil { @@ -372,14 +366,23 @@ func (q *checker) bcheckAssert(n *a.Assert) error { } func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error { - if _, err := q.bcheckExpr(lhs, 0); err != nil { - return err + lTyp := (*a.TypeExpr)(nil) + if lhs != nil { + if _, err := q.bcheckExpr(lhs, 0); err != nil { + return err + } + lTyp = lhs.MType() } - nb, err := q.bcheckAssignment1(lhs, lhs.MType(), op, rhs) + + nb, err := q.bcheckAssignment1(lhs, lTyp, op, rhs) if err != nil { return err } + if lhs == nil { + return nil + } + if op == t.IDEq { // Drop any facts involving lhs. if err := q.facts.update(func(x *a.Expr) (*a.Expr, error) { @@ -457,9 +460,12 @@ func (q *checker) bcheckAssignment1(lhs *a.Expr, lTyp *a.TypeExpr, op t.ID, rhs return bounds{}, fmt.Errorf("check: internal error: missing LHS for op key 0x%02X", op) } - lb, err := q.bcheckTypeExpr(lTyp) - if err != nil { - return bounds{}, err + lb, err := bounds{}, (error)(nil) + if lTyp != nil { + lb, err = q.bcheckTypeExpr(lTyp) + if err != nil { + return bounds{}, err + } } rb := bounds{} @@ -472,7 +478,7 @@ func (q *checker) bcheckAssignment1(lhs *a.Expr, lTyp *a.TypeExpr, op t.ID, rhs return bounds{}, err } - if (rb[0].Cmp(lb[0]) < 0) || (rb[1].Cmp(lb[1]) > 0) { + if (lTyp != nil) && ((rb[0].Cmp(lb[0]) < 0) || (rb[1].Cmp(lb[1]) > 0)) { if op == t.IDEq { return bounds{}, fmt.Errorf("check: expression %q bounds %v is not within bounds %v", rhs.Str(q.tm), rb, lb) diff --git a/lang/check/type.go b/lang/check/type.go index 512ba0ba..3b4dfc1f 100644 --- a/lang/check/type.go +++ b/lang/check/type.go @@ -57,9 +57,6 @@ func (q *checker) tcheckStatement(n *a.Node) error { return err } - case a.KExpr: - return q.tcheckExpr(n.AsExpr(), 0) - case a.KIf: for n := n.AsIf(); n != nil; n = n.ElseIf() { cond := n.Condition() @@ -256,12 +253,15 @@ func (q *checker) tcheckEq(lID t.ID, lhs *a.Expr, lTyp *a.TypeExpr, rhs *a.Expr, } func (q *checker) tcheckAssign(n *a.Assign) error { - lhs := n.LHS() rhs := n.RHS() - if err := q.tcheckExpr(lhs, 0); err != nil { + if err := q.tcheckExpr(rhs, 0); err != nil { return err } - if err := q.tcheckExpr(rhs, 0); err != nil { + lhs := n.LHS() + if lhs == nil { + return nil + } + if err := q.tcheckExpr(lhs, 0); err != nil { return err } lTyp := lhs.MType() diff --git a/lang/parse/parse.go b/lang/parse/parse.go index 038026c7..d666e4a7 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -701,6 +701,8 @@ func (p *parser) parseAssignNode() (*a.Node, error) { rhs.Str(p.tm), p.filename, p.line()) } } + } else { + op = t.IDEq } if p.funcEffect.WeakerThan(rhs.Effect()) { @@ -708,9 +710,6 @@ func (p *parser) parseAssignNode() (*a.Node, error) { rhs.Str(p.tm), rhs.Effect(), p.funcEffect, p.filename, p.line()) } - if lhs == nil { - return rhs.AsNode(), nil - } return a.NewAssign(op, lhs, rhs).AsNode(), nil }