internal/cgen/resume.go - third_party/wuffs - Git at Google

 // Copyright 2018 The Wuffs Authors.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //    https://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package cgen

 // This file deals with determining whether local variables need to be kept:
 // saved / loaded when suspending / resuming a coroutine. For simplicity, this
 // is a boolean property of each local variable. The analysis does not
 // determine that a local variable needs saving at some CSPs (coroutine
 // suspension points) but not others.
 //
 // Fexample, in this code:
 //
 //   i = etc
 //   yield foo  // The first CSP.
 //   j = 0
 //   while j < i {
 //     a[j] = 42
 //     j += 1
 //   }
 //   c = 100 + args.src.read_u8!??()  // The second CSP.
 //   k = a[c]
 //
 // There are two CSPs. The i local variable will need to be kept, as it is
 // written to before the first CSP and read from after the first CSP.
 // Similarly, the a local variable (an array) will need to be kept, as its use
 // crosses the second CSP. The j local variable need not be kept, as all of its
 // uses happens between two consecutive CSPs. To be precise, for every possible
 // code path (including if branches and while loops), each read from j is
 // preceded by a write to j without an intervening CSP. The c and k local
 // variables also need not be kept, as their uses are all after the last CSP.
 //
 // Algorithmically, we walk through a function's statements in two passes. The
 // first pass finds all of the local variables, and assigns an integer index to
 // each one. The second tracks (in a slice indexed by that integer index) each
 // local variable's resumability, one of three possible states: none, weak and
 // strong. Strong means that the local variable definitely needs to be kept.
 // Weak means that we have (in the worst case, for branches' and loops'
 // multiple paths) seen a CSP without a write afterwards, so that seeing a read
 // would change the resumability to strong. None means that we have not seen a
 // CSP since the last write.
 //
 // Essentially, the state transitions are: strong is sticky, weak to strong
 // happens on a read, weak to none happens on a write, and none to weak happens
 // on a CSP. When reconciling multiple code paths, the strongest wins, where
 // strong > weak and weak > none. Loops are repeated until the reconciliations
 // between the N'th and N+1'th iteration are all no-ops. There can be multiple
 // reconciliations per iteration, due to break and continue statements.
 //
 // Care is taken with a coroutine call in a statement or expression. Arguments
 // to the coroutine are 'inside' and are before the CSP. The rest of the
 // expression is 'outside' and are after the CSP.

 import (
 	"fmt"

 	a "github.com/google/wuffs/lang/ast"
 	t "github.com/google/wuffs/lang/token"
 )

 // subExprFilter is used, when analyzing an expression containing a coroutine
 // call, for multiple analysis passes: before, during and after that call.
 type subExprFilter uint32

 const (
 	subExprFilterNone            = subExprFilter(0)
 	subExprFilterBeforeCoroutine = subExprFilter(1)
 	subExprFilterDuringCoroutine = subExprFilter(2)
 	subExprFilterAfterCoroutine  = subExprFilter(3)
 )

 // resumability tracks whether a local variable's value will need to be kept
 // across CSPs (coroutine suspension points).
 type resumability uint32

 const (
 	resumabilityNone   = resumability(0)
 	resumabilityWeak   = resumability(1)
 	resumabilityStrong = resumability(2)
 )

 // resumabilities is a slice of resumability values, one per local variable.
 type resumabilities []resumability

 func (r resumabilities) clone() resumabilities {
 	return append(resumabilities(nil), r...)
 }

 func (r resumabilities) reconcile(s resumabilities) (changed bool) {
 	if len(r) != len(s) {
 		panic("resumabilities have different length")
 	}
 	for i := range r {
 		if r[i] < s[i] {
 			r[i] = s[i]
 			changed = true
 		}
 	}
 	return changed
 }

 func (r resumabilities) lowerWeakToNone(i int) {
 	if r[i] == resumabilityWeak {
 		r[i] = resumabilityNone
 	}
 }

 func (r resumabilities) raiseWeakToStrong(i int) {
 	if r[i] == resumabilityWeak {
 		r[i] = resumabilityStrong
 	}
 }

 func (r resumabilities) raiseNoneToWeak() {
 	for i, x := range r {
 		if x == resumabilityNone {
 			r[i] = resumabilityWeak
 		}
 	}
 }

 type loopResumable struct {
 	before  resumabilities
 	after   resumabilities
 	changed bool
 }

 type resumabilityHelper struct {
 	tm    *t.Map
 	vars  map[t.ID]int // Maps from local variable name to resumabilities index.
 	loops map[a.Loop]*loopResumable
 }

 func (g *gen) findVars() error {
 	h := resumabilityHelper{
 		tm:    g.tm,
 		vars:  map[t.ID]int{},
 		loops: map[a.Loop]*loopResumable{},
 	}

 	f := g.currFunk.astFunc
 	for _, n := range f.Body() {
 		if n.Kind() != a.KVar {
 			break
 		}
 		g.currFunk.varList = append(g.currFunk.varList, n.AsVar())
 		h.vars[n.AsVar().Name()] = len(h.vars)
 	}

 	if f.Effect().Coroutine() {
 		r := make(resumabilities, len(h.vars))
 		if err := h.doBlock(r, f.Body(), 0); err != nil {
 			return err
 		}

 		g.currFunk.varResumables = map[t.ID]bool{}
 		for i, v := range g.currFunk.varList {
 			g.currFunk.varResumables[v.Name()] = r[i] == resumabilityStrong
 		}
 	}

 	return nil
 }

 func (h *resumabilityHelper) doBlock(r resumabilities, block []*a.Node, depth uint32) error {
 	if depth > a.MaxBodyDepth {
 		return fmt.Errorf("body recursion depth too large")
 	}
 	depth++

 loop:
 	for _, o := range block {
 		switch o.Kind() {
 		case a.KAssign:
 			if err := h.doAssign(r, o.AsAssign(), depth); err != nil {
 				return err
 			}

 		case a.KExpr:
 			if err := h.doExpr(r, o.AsExpr()); err != nil {
 				return err
 			}

 		case a.KIOBind:
 			if err := h.doIOBind(r, o.AsIOBind(), depth); err != nil {
 				return err
 			}

 		case a.KIf:
 			if err := h.doIf(r, o.AsIf(), depth); err != nil {
 				return err
 			}

 		case a.KIterate:
 			if err := h.doIterate(r, o.AsIterate(), depth); err != nil {
 				return err
 			}

 		case a.KJump:
 			if err := h.doJump(r, o.AsJump(), depth); err != nil {
 				return err
 			}
 			break loop

 		case a.KRet:
 			if err := h.doRet(r, o.AsRet(), depth); err != nil {
 				return err
 			}
 			if o.AsRet().Keyword() == t.IDReturn {
 				break loop
 			}

 		case a.KVar:
 			if err := h.doVar(r, o.AsVar(), depth); err != nil {
 				return err
 			}

 		case a.KWhile:
 			if err := h.doWhile(r, o.AsWhile(), depth); err != nil {
 				return err
 			}
 		}
 	}
 	return nil
 }

 func (h *resumabilityHelper) doAssign(r resumabilities, n *a.Assign, depth uint32) error {
 	if n.Operator() == t.IDEqQuestion {
 		if err := h.doExpr1(r, n.RHS(), subExprFilterNone, 0); err != nil {
 			return err
 		}
 	} else {
 		if err := h.doExpr(r, n.RHS()); err != nil {
 			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.
 	if n.LHS().Operator() != 0 || (n.Operator() != t.IDEq && n.Operator() != t.IDEqQuestion) {
 		if err := h.doExpr(r, n.LHS()); err != nil {
 			return err
 		}
 	}

 	// If the LHS is just a local variable, then call lowerWeakToNone.
 	if lhs := n.LHS(); lhs.Operator() == 0 {
 		if i, ok := h.vars[lhs.Ident()]; !ok {
 			return fmt.Errorf("unrecognized variable %q", lhs.Ident().Str(h.tm))
 		} else {
 			r.lowerWeakToNone(i)
 		}
 	}
 	return nil
 }

 func (h *resumabilityHelper) doExpr(r resumabilities, n *a.Expr) error {
 	if !n.Effect().Coroutine() {
 		return h.doExpr1(r, n, subExprFilterNone, 0)
 	}
 	for sef := subExprFilterBeforeCoroutine; sef <= subExprFilterAfterCoroutine; sef++ {
 		if err := h.doExpr1(r, n, sef, 0); err != nil {
 			return err
 		}
 	}
 	return nil
 }

 func (h *resumabilityHelper) doExpr1(r resumabilities, n *a.Expr, sef subExprFilter, depth uint32) error {
 	if depth > a.MaxBodyDepth {
 		return fmt.Errorf("body recursion depth too large")
 	}
 	depth++

 	processOnlySubExprs := false
 	if sef != subExprFilterNone {
 		switch sef {
 		case subExprFilterBeforeCoroutine:
 			if !n.Effect().Coroutine() {
 				return nil
 			}
 			sef = subExprFilterNone
 			processOnlySubExprs = true

 		case subExprFilterDuringCoroutine:
 			if n.Effect().Coroutine() {
 				switch n.Operator() {
 				case t.IDOpenParen:
 					r.raiseNoneToWeak()
 				default:
 					return fmt.Errorf("unrecognized ast.Expr coroutine operator")
 				}
 				return nil
 			}
 			panic("TODO: unreachable; delete")
 			processOnlySubExprs = true

 		case subExprFilterAfterCoroutine:
 			if n.Effect().Coroutine() {
 				return nil
 			}
 			panic("TODO: unreachable; delete")
 		}
 	}

 	for _, o := range n.AsNode().AsRaw().SubNodes() {
 		if o != nil && o.Kind() == a.KExpr {
 			if err := h.doExpr1(r, o.AsExpr(), sef, depth); err != nil {
 				return err
 			}
 		}
 	}
 	for _, o := range n.Args() {
 		e := (*a.Expr)(nil)
 		switch o.Kind() {
 		case a.KArg:
 			e = o.AsArg().Value()
 		case a.KExpr:
 			e = o.AsExpr()
 		default:
 			return fmt.Errorf("unrecognized arg kind")
 		}
 		if err := h.doExpr1(r, e, sef, depth); err != nil {
 			return err
 		}
 	}

 	if !processOnlySubExprs && n.Operator() == 0 {
 		if i, ok := h.vars[n.Ident()]; ok {
 			r.raiseWeakToStrong(i)
 		}
 	}

 	return nil
 }

 func (h *resumabilityHelper) doIOBind(r resumabilities, n *a.IOBind, depth uint32) error {
 	if err := h.doExpr(r, n.IO()); err != nil {
 		return err
 	}
 	if err := h.doExpr(r, n.Arg1()); err != nil {
 		return err
 	}
 	return h.doBlock(r, n.Body(), depth)
 }

 func (h *resumabilityHelper) doIf(r resumabilities, n *a.If, depth uint32) error {
 	scratch := make(resumabilities, len(r))
 	result := make(resumabilities, len(r))
 	for ; n != nil; n = n.ElseIf() {
 		if err := h.doExpr(r, n.Condition()); err != nil {
 			return err
 		}

 		copy(scratch, r)
 		if err := h.doBlock(scratch, n.BodyIfTrue(), depth); err != nil {
 			return err
 		}
 		result.reconcile(scratch)

 		copy(scratch, r)
 		if err := h.doBlock(scratch, n.BodyIfFalse(), depth); err != nil {
 			return err
 		}
 		result.reconcile(scratch)
 	}
 	copy(r, result)
 	return nil
 }

 func (h *resumabilityHelper) doIterate(r resumabilities, n *a.Iterate, depth uint32) error {
 	// TODO: ban jumps, rets and coroutine calls inside an iterate. Also ensure
 	// that the iterate variable values are all pure expressions.
 	for _, o := range n.Assigns() {
 		o := o.AsAssign()
 		if err := h.doExpr(r, o.RHS()); err != nil {
 			return err
 		}
 		name := o.LHS().Ident()
 		if i, ok := h.vars[name]; !ok {
 			return fmt.Errorf("unrecognized variable %q", name.Str(h.tm))
 		} else {
 			r.lowerWeakToNone(i)
 		}
 	}
 	return h.doBlock(r, n.Body(), depth)
 }

 func (h *resumabilityHelper) doJump(r resumabilities, n *a.Jump, depth uint32) error {
 	l := h.loops[n.JumpTarget()]
 	switch n.Keyword() {
 	case t.IDBreak:
 		l.changed = l.before.reconcile(r) || l.changed
 	case t.IDContinue:
 		l.changed = l.after.reconcile(r) || l.changed
 	default:
 		return fmt.Errorf("unrecognized ast.Jump keyword")
 	}
 	return nil
 }

 func (h *resumabilityHelper) doRet(r resumabilities, n *a.Ret, depth uint32) error {
 	if err := h.doExpr(r, n.Value()); err != nil {
 		return err
 	}

 	switch n.Keyword() {
 	case t.IDReturn:
 		// No-op.
 	case t.IDYield:
 		r.raiseNoneToWeak()
 	default:
 		return fmt.Errorf("unrecognized ast.Ret keyword")
 	}
 	return nil
 }

 func (h *resumabilityHelper) doVar(r resumabilities, n *a.Var, depth uint32) error {
 	name := n.Name()
 	if i, ok := h.vars[name]; !ok {
 		return fmt.Errorf("unrecognized variable %q", name.Str(h.tm))
 	} else {
 		r.lowerWeakToNone(i)
 	}
 	return nil
 }

 func (h *resumabilityHelper) doWhile(r resumabilities, n *a.While, depth uint32) error {
 	l := &loopResumable{
 		before:  make(resumabilities, len(r)),
 		after:   make(resumabilities, len(r)),
 		changed: false,
 	}
 	h.loops[n] = l

 	copy(l.before, r)
 	if err := h.doExpr(r, n.Condition()); err != nil {
 		return err
 	}
 	copy(l.after, r)

 	for {
 		copy(r, l.after)
 		if err := h.doBlock(r, n.Body(), depth); err != nil {
 			return err
 		}
 		l.changed = l.before.reconcile(r) || l.changed

 		copy(r, l.before)
 		if err := h.doExpr(r, n.Condition()); err != nil {
 			return err
 		}
 		l.changed = l.after.reconcile(r) || l.changed

 		if !l.changed {
 			break
 		}
 		l.changed = false
 	}

 	copy(r, l.after)
 	return nil
 }
	// Copyright 2018 The Wuffs Authors.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// https://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package cgen

	// This file deals with determining whether local variables need to be kept:
	// saved / loaded when suspending / resuming a coroutine. For simplicity, this
	// is a boolean property of each local variable. The analysis does not
	// determine that a local variable needs saving at some CSPs (coroutine
	// suspension points) but not others.
	//
	// Fexample, in this code:
	//
	// i = etc
	// yield foo // The first CSP.
	// j = 0
	// while j < i {
	// a[j] = 42
	// j += 1
	// }
	// c = 100 + args.src.read_u8!??() // The second CSP.
	// k = a[c]
	//
	// There are two CSPs. The i local variable will need to be kept, as it is
	// written to before the first CSP and read from after the first CSP.
	// Similarly, the a local variable (an array) will need to be kept, as its use
	// crosses the second CSP. The j local variable need not be kept, as all of its
	// uses happens between two consecutive CSPs. To be precise, for every possible
	// code path (including if branches and while loops), each read from j is
	// preceded by a write to j without an intervening CSP. The c and k local
	// variables also need not be kept, as their uses are all after the last CSP.
	//
	// Algorithmically, we walk through a function's statements in two passes. The
	// first pass finds all of the local variables, and assigns an integer index to
	// each one. The second tracks (in a slice indexed by that integer index) each
	// local variable's resumability, one of three possible states: none, weak and
	// strong. Strong means that the local variable definitely needs to be kept.
	// Weak means that we have (in the worst case, for branches' and loops'
	// multiple paths) seen a CSP without a write afterwards, so that seeing a read
	// would change the resumability to strong. None means that we have not seen a
	// CSP since the last write.
	//
	// Essentially, the state transitions are: strong is sticky, weak to strong
	// happens on a read, weak to none happens on a write, and none to weak happens
	// on a CSP. When reconciling multiple code paths, the strongest wins, where
	// strong > weak and weak > none. Loops are repeated until the reconciliations
	// between the N'th and N+1'th iteration are all no-ops. There can be multiple
	// reconciliations per iteration, due to break and continue statements.
	//
	// Care is taken with a coroutine call in a statement or expression. Arguments
	// to the coroutine are 'inside' and are before the CSP. The rest of the
	// expression is 'outside' and are after the CSP.

	import (
	"fmt"

	a "github.com/google/wuffs/lang/ast"
	t "github.com/google/wuffs/lang/token"
	)

	// subExprFilter is used, when analyzing an expression containing a coroutine
	// call, for multiple analysis passes: before, during and after that call.
	type subExprFilter uint32

	const (
	subExprFilterNone = subExprFilter(0)
	subExprFilterBeforeCoroutine = subExprFilter(1)
	subExprFilterDuringCoroutine = subExprFilter(2)
	subExprFilterAfterCoroutine = subExprFilter(3)
	)

	// resumability tracks whether a local variable's value will need to be kept
	// across CSPs (coroutine suspension points).
	type resumability uint32

	const (
	resumabilityNone = resumability(0)
	resumabilityWeak = resumability(1)
	resumabilityStrong = resumability(2)
	)

	// resumabilities is a slice of resumability values, one per local variable.
	type resumabilities []resumability

	func (r resumabilities) clone() resumabilities {
	return append(resumabilities(nil), r...)
	}

	func (r resumabilities) reconcile(s resumabilities) (changed bool) {
	if len(r) != len(s) {
	panic("resumabilities have different length")
	}
	for i := range r {
	if r[i] < s[i] {
	r[i] = s[i]
	changed = true
	}
	}
	return changed
	}

	func (r resumabilities) lowerWeakToNone(i int) {
	if r[i] == resumabilityWeak {
	r[i] = resumabilityNone
	}
	}

	func (r resumabilities) raiseWeakToStrong(i int) {
	if r[i] == resumabilityWeak {
	r[i] = resumabilityStrong
	}
	}

	func (r resumabilities) raiseNoneToWeak() {
	for i, x := range r {
	if x == resumabilityNone {
	r[i] = resumabilityWeak
	}
	}
	}

	type loopResumable struct {
	before resumabilities
	after resumabilities
	changed bool
	}

	type resumabilityHelper struct {
	tm *t.Map
	vars map[t.ID]int // Maps from local variable name to resumabilities index.
	loops map[a.Loop]*loopResumable
	}

	func (g *gen) findVars() error {
	h := resumabilityHelper{
	tm: g.tm,
	vars: map[t.ID]int{},
	loops: map[a.Loop]*loopResumable{},
	}

	f := g.currFunk.astFunc
	for _, n := range f.Body() {
	if n.Kind() != a.KVar {
	break
	}
	g.currFunk.varList = append(g.currFunk.varList, n.AsVar())
	h.vars[n.AsVar().Name()] = len(h.vars)
	}

	if f.Effect().Coroutine() {
	r := make(resumabilities, len(h.vars))
	if err := h.doBlock(r, f.Body(), 0); err != nil {
	return err
	}

	g.currFunk.varResumables = map[t.ID]bool{}
	for i, v := range g.currFunk.varList {
	g.currFunk.varResumables[v.Name()] = r[i] == resumabilityStrong
	}
	}

	return nil
	}

	func (h resumabilityHelper) doBlock(r resumabilities, block []a.Node, depth uint32) error {
	if depth > a.MaxBodyDepth {
	return fmt.Errorf("body recursion depth too large")
	}
	depth++

	loop:
	for _, o := range block {
	switch o.Kind() {
	case a.KAssign:
	if err := h.doAssign(r, o.AsAssign(), depth); err != nil {
	return err
	}

	case a.KExpr:
	if err := h.doExpr(r, o.AsExpr()); err != nil {
	return err
	}

	case a.KIOBind:
	if err := h.doIOBind(r, o.AsIOBind(), depth); err != nil {
	return err
	}

	case a.KIf:
	if err := h.doIf(r, o.AsIf(), depth); err != nil {
	return err
	}

	case a.KIterate:
	if err := h.doIterate(r, o.AsIterate(), depth); err != nil {
	return err
	}

	case a.KJump:
	if err := h.doJump(r, o.AsJump(), depth); err != nil {
	return err
	}
	break loop

	case a.KRet:
	if err := h.doRet(r, o.AsRet(), depth); err != nil {
	return err
	}
	if o.AsRet().Keyword() == t.IDReturn {
	break loop
	}

	case a.KVar:
	if err := h.doVar(r, o.AsVar(), depth); err != nil {
	return err
	}

	case a.KWhile:
	if err := h.doWhile(r, o.AsWhile(), depth); err != nil {
	return err
	}
	}
	}
	return nil
	}

	func (h resumabilityHelper) doAssign(r resumabilities, n a.Assign, depth uint32) error {
	if n.Operator() == t.IDEqQuestion {
	if err := h.doExpr1(r, n.RHS(), subExprFilterNone, 0); err != nil {
	return err
	}
	} else {
	if err := h.doExpr(r, n.RHS()); err != nil {
	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.
	if n.LHS().Operator() != 0 \|\| (n.Operator() != t.IDEq && n.Operator() != t.IDEqQuestion) {
	if err := h.doExpr(r, n.LHS()); err != nil {
	return err
	}
	}

	// If the LHS is just a local variable, then call lowerWeakToNone.
	if lhs := n.LHS(); lhs.Operator() == 0 {
	if i, ok := h.vars[lhs.Ident()]; !ok {
	return fmt.Errorf("unrecognized variable %q", lhs.Ident().Str(h.tm))
	} else {
	r.lowerWeakToNone(i)
	}
	}
	return nil
	}

	func (h resumabilityHelper) doExpr(r resumabilities, n a.Expr) error {
	if !n.Effect().Coroutine() {
	return h.doExpr1(r, n, subExprFilterNone, 0)
	}
	for sef := subExprFilterBeforeCoroutine; sef <= subExprFilterAfterCoroutine; sef++ {
	if err := h.doExpr1(r, n, sef, 0); err != nil {
	return err
	}
	}
	return nil
	}

	func (h resumabilityHelper) doExpr1(r resumabilities, n a.Expr, sef subExprFilter, depth uint32) error {
	if depth > a.MaxBodyDepth {
	return fmt.Errorf("body recursion depth too large")
	}
	depth++

	processOnlySubExprs := false
	if sef != subExprFilterNone {
	switch sef {
	case subExprFilterBeforeCoroutine:
	if !n.Effect().Coroutine() {
	return nil
	}
	sef = subExprFilterNone
	processOnlySubExprs = true

	case subExprFilterDuringCoroutine:
	if n.Effect().Coroutine() {
	switch n.Operator() {
	case t.IDOpenParen:
	r.raiseNoneToWeak()
	default:
	return fmt.Errorf("unrecognized ast.Expr coroutine operator")
	}
	return nil
	}
	panic("TODO: unreachable; delete")
	processOnlySubExprs = true

	case subExprFilterAfterCoroutine:
	if n.Effect().Coroutine() {
	return nil
	}
	panic("TODO: unreachable; delete")
	}
	}

	for _, o := range n.AsNode().AsRaw().SubNodes() {
	if o != nil && o.Kind() == a.KExpr {
	if err := h.doExpr1(r, o.AsExpr(), sef, depth); err != nil {
	return err
	}
	}
	}
	for _, o := range n.Args() {
	e := (*a.Expr)(nil)
	switch o.Kind() {
	case a.KArg:
	e = o.AsArg().Value()
	case a.KExpr:
	e = o.AsExpr()
	default:
	return fmt.Errorf("unrecognized arg kind")
	}
	if err := h.doExpr1(r, e, sef, depth); err != nil {
	return err
	}
	}

	if !processOnlySubExprs && n.Operator() == 0 {
	if i, ok := h.vars[n.Ident()]; ok {
	r.raiseWeakToStrong(i)
	}
	}

	return nil
	}

	func (h resumabilityHelper) doIOBind(r resumabilities, n a.IOBind, depth uint32) error {
	if err := h.doExpr(r, n.IO()); err != nil {
	return err
	}
	if err := h.doExpr(r, n.Arg1()); err != nil {
	return err
	}
	return h.doBlock(r, n.Body(), depth)
	}

	func (h resumabilityHelper) doIf(r resumabilities, n a.If, depth uint32) error {
	scratch := make(resumabilities, len(r))
	result := make(resumabilities, len(r))
	for ; n != nil; n = n.ElseIf() {
	if err := h.doExpr(r, n.Condition()); err != nil {
	return err
	}

	copy(scratch, r)
	if err := h.doBlock(scratch, n.BodyIfTrue(), depth); err != nil {
	return err
	}
	result.reconcile(scratch)

	copy(scratch, r)
	if err := h.doBlock(scratch, n.BodyIfFalse(), depth); err != nil {
	return err
	}
	result.reconcile(scratch)
	}
	copy(r, result)
	return nil
	}

	func (h resumabilityHelper) doIterate(r resumabilities, n a.Iterate, depth uint32) error {
	// TODO: ban jumps, rets and coroutine calls inside an iterate. Also ensure
	// that the iterate variable values are all pure expressions.
	for _, o := range n.Assigns() {
	o := o.AsAssign()
	if err := h.doExpr(r, o.RHS()); err != nil {
	return err
	}
	name := o.LHS().Ident()
	if i, ok := h.vars[name]; !ok {
	return fmt.Errorf("unrecognized variable %q", name.Str(h.tm))
	} else {
	r.lowerWeakToNone(i)
	}
	}
	return h.doBlock(r, n.Body(), depth)
	}

	func (h resumabilityHelper) doJump(r resumabilities, n a.Jump, depth uint32) error {
	l := h.loops[n.JumpTarget()]
	switch n.Keyword() {
	case t.IDBreak:
	l.changed = l.before.reconcile(r) \|\| l.changed
	case t.IDContinue:
	l.changed = l.after.reconcile(r) \|\| l.changed
	default:
	return fmt.Errorf("unrecognized ast.Jump keyword")
	}
	return nil
	}

	func (h resumabilityHelper) doRet(r resumabilities, n a.Ret, depth uint32) error {
	if err := h.doExpr(r, n.Value()); err != nil {
	return err
	}

	switch n.Keyword() {
	case t.IDReturn:
	// No-op.
	case t.IDYield:
	r.raiseNoneToWeak()
	default:
	return fmt.Errorf("unrecognized ast.Ret keyword")
	}
	return nil
	}

	func (h resumabilityHelper) doVar(r resumabilities, n a.Var, depth uint32) error {
	name := n.Name()
	if i, ok := h.vars[name]; !ok {
	return fmt.Errorf("unrecognized variable %q", name.Str(h.tm))
	} else {
	r.lowerWeakToNone(i)
	}
	return nil
	}

	func (h resumabilityHelper) doWhile(r resumabilities, n a.While, depth uint32) error {
	l := &loopResumable{
	before: make(resumabilities, len(r)),
	after: make(resumabilities, len(r)),
	changed: false,
	}
	h.loops[n] = l

	copy(l.before, r)
	if err := h.doExpr(r, n.Condition()); err != nil {
	return err
	}
	copy(l.after, r)

	for {
	copy(r, l.after)
	if err := h.doBlock(r, n.Body(), depth); err != nil {
	return err
	}
	l.changed = l.before.reconcile(r) \|\| l.changed

	copy(r, l.before)
	if err := h.doExpr(r, n.Condition()); err != nil {
	return err
	}
	l.changed = l.after.reconcile(r) \|\| l.changed

	if !l.changed {
	break
	}
	l.changed = false
	}

	copy(r, l.after)
	return nil
	}