@mfjs/compiler/graph.js

// Generated by CoffeeScript 1.10.0
(function() {
  var BindNode, BlockNode, BranchedNode, BreakNode, ControlNode, DynNode, EffValNode, EffectfulNode, EmptyNode, JumpNode, LoopNode, Node, PlaceholderNode, PureExprNode, PureNode, ReifyNode, RepeatNode, Scope, SharedNode, ThrowNode, TryCatchNode, VarUsage, WrapNode, YieldNode, assert, builder, config, getBuilderFun, id, isSimpleExpr, kit, lookupPlaceholderTarget, regNodeType, root, simpleExpressions,
    slice = [].slice,
    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
    hasProp = {}.hasOwnProperty;

  kit = require("./kit");

  Scope = require("./scope").Scope;

  builder = require("./builder");

  assert = require("assert");

  config = require("./config");

  VarUsage = builder.VarUsage;

  module.exports = root = {};

  root.regNodeType = regNodeType = function(n, ctr) {
    root["" + (n[0].toUpperCase()) + (n.substr(1))] = ctr;
    return Scope.prototype[n] = function() {
      var args, nctr, res;
      args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
      args.unshift(null);
      nctr = Function.prototype.bind.apply(ctr, args);
      nctr.name = ctr.name;
      res = (new nctr()).init(this);
      return res;
    };
  };

  id = 0;

  Node = (function() {
    function Node() {
      this.unwindBy = {};
      this.id = id++;
      this.vdeps = new VarUsage();
    }

    Node.prototype.morphInit = function(other) {
      this.setOrig(other.orig);
      this.vdeps = other.vdeps;
      return this;
    };

    Node.prototype.init = function(ctx) {
      this.opts = kit.merge({}, ctx.policy.opts);
      this.ctx = ctx;
      this.vdeps.vars = ctx.vars;
      this.vdeps.refs = ctx.refs;
      return this;
    };

    Node.prototype.setOrig = function(orig) {
      if (this.orig == null) {
        this.orig = orig;
      }
      return this;
    };

    Node.prototype.setParent = function(parent) {
      this.parent = parent;
      return this;
    };

    Node.prototype.getFullBlock = function(eff) {
      eff = eff && this.opts.coerce === "none";
      return this.getBuilder().toBlock(eff);
    };

    Node.prototype.getFullExpr = function(eff) {
      eff = eff && this.opts.coerce === "none";
      return this.getBuilder().toExpr(eff);
    };

    Node.prototype.fwdPass = function(use) {
      if (!this._fwdPassDone) {
        this._fwdPassDone = true;
        this.vdeps.setBefore(use);
        this._fwdPass(use);
        kit.extend(use, this.vdeps.uses);
      }
      if (this.parent != null) {
        this.parent.vdeps.addInner(this.vdeps);
      }
      return this;
    };

    Node.prototype._fwdPass = function(use) {};

    Node.prototype.backPass = function(use) {
      if (this.eff) {
        this.propagateEff();
      }
      kit.extend(this.vdeps.after, use);
      this._backPass(use);
      kit.extend(use, this.vdeps.uses);
      return this;
    };

    Node.prototype._backPass = function() {};

    Node.prototype.propagateEff = function() {
      if (this._propagateEffDone) {
        return this;
      }
      return this._propagateEff();
    };

    Node.prototype._propagateEff = function() {
      this._propagateEffDone = true;
      this.eff = true;
      this.ctx.eff = true;
      return this;
    };

    Node.prototype.getBuilder = function() {
      var b;
      b = (function(_this) {
        return function() {
          if (_this.isEmpty()) {
            return builder.empty();
          }
          if (!_this.eff) {
            if (_this.orig) {
              return builder.pure(kit.blockStmts(_this.orig));
            }
          }
          return _this._getBuilder();
        };
      })(this)();
      return b.setOpts(this.opts).mergeEnv(this.vdeps);
    };

    Node.prototype.ignoreResult = function() {
      this.ignoreResult = true;
      return this;
    };

    return Node;

  })();

  root.Node = Node;

  EffectfulNode = (function(superClass) {
    extend(EffectfulNode, superClass);

    function EffectfulNode() {
      EffectfulNode.__super__.constructor.call(this);
    }

    EffectfulNode.prototype.eff = true;

    return EffectfulNode;

  })(Node);

  PureNode = (function(superClass) {
    extend(PureNode, superClass);

    function PureNode(block1) {
      this.block = block1;
      PureNode.__super__.constructor.call(this);
      if (this.block == null) {
        this.block = [];
      }
    }

    PureNode.prototype.eff = false;

    PureNode.prototype._getBuilder = function() {
      return builder.pure(this.block);
    };

    PureNode.prototype.pureBlock = function() {
      return this.block;
    };

    return PureNode;

  })(Node);

  PureExprNode = (function(superClass) {
    extend(PureExprNode, superClass);

    function PureExprNode(pureExpr) {
      this.pureExpr = pureExpr;
      PureExprNode.__super__.constructor.call(this, [kit.ret(this.pureExpr)]);
    }

    PureExprNode.prototype.setExpr = function(pureExpr) {
      this.pureExpr = pureExpr;
      this.block = [kit.ret(this.pureExpr)];
      return this;
    };

    PureExprNode.prototype._getBuilder = function() {
      return builder.exprPure(this.pureExpr);
    };

    PureExprNode.prototype.ignoreResult = function() {
      return this.ctx.pureNode([kit.exprStmt(this.pureExpr)]).morphInit(this);
    };

    return PureExprNode;

  })(PureNode);

  regNodeType("pureNode", PureNode);

  regNodeType("pureExprNode", PureExprNode);

  Scope.prototype.exprNode = function(e) {
    return (this.policy.opts.bind ? new EffValNode(e) : new PureExprNode(e)).init(this);
  };

  Scope.prototype.pureExprNode = function(e) {
    return new PureExprNode(e).init(this);
  };

  EmptyNode = (function(superClass) {
    extend(EmptyNode, superClass);

    function EmptyNode() {
      EmptyNode.__super__.constructor.call(this, []);
      this.orig = {
        type: "EmptyStatement"
      };
    }

    EmptyNode.prototype.setOrig = function() {
      return this;
    };

    EmptyNode.prototype.getBuilder = function() {
      return builder.empty().setOpts(this.opts).mergeEnv(this.vdeps);
    };

    return EmptyNode;

  })(PureNode);

  regNodeType("emptyNode", EmptyNode);

  DynNode = (function(superClass) {
    extend(DynNode, superClass);

    function DynNode() {
      DynNode.__super__.constructor.call(this);
    }

    DynNode.prototype._propagateEff = function() {
      DynNode.__super__._propagateEff.call(this);
      if (this.parent != null) {
        this.parent.propagateEff();
      }
      return this;
    };

    return DynNode;

  })(Node);

  ReifyNode = (function(superClass) {
    extend(ReifyNode, superClass);

    function ReifyNode() {
      ReifyNode.__super__.constructor.call(this);
    }

    ReifyNode.prototype.eff = false;

    ReifyNode.prototype.setBody = function(body1) {
      this.body = body1;
      this.body.setParent(this);
      return this;
    };

    ReifyNode.prototype.setIsThunk = function(isThunk) {
      this.isThunk = isThunk;
      return this;
    };

    ReifyNode.prototype.setVar = function(_var) {
      this["var"] = _var;
      return this;
    };

    ReifyNode.prototype._backPass = function(use) {
      return this.body.backPass(use);
    };

    ReifyNode.prototype._fwdPass = function(use) {
      return this.body.fwdPass(use);
    };

    ReifyNode.prototype._propagateEff = function() {
      return this;
    };

    ReifyNode.prototype.getBuilder = function() {
      var e, expr;
      e = this.isThunk ? this.body.getBuilder().toExpr(true) : kit.fun([], this.body.getBuilder().toBlock(true));
      expr = kit.call(kit.packId("reify"), [e]);
      if (this["var"]) {
        return builder.pure([kit.varDecl(this["var"], expr)]).mergeEnv(this.vdeps);
      }
      return builder.exprPure(expr).mergeEnv(this.vdeps);
    };

    return ReifyNode;

  })(Node);

  regNodeType("reifyNode", ReifyNode);

  BlockNode = (function(superClass) {
    extend(BlockNode, superClass);

    function BlockNode() {
      BlockNode.__super__.constructor.call(this);
      this.block = [];
      this.placeholders = [];
    }

    BlockNode.prototype.append = function() {
      var c, i, len, m, x;
      c = 1 <= arguments.length ? slice.call(arguments, 0) : [];
      for (x = m = 0, len = c.length; m < len; x = ++m) {
        i = c[x];
        if (!((i != null) && !i.isEmpty())) {
          continue;
        }
        i.setParent(this);
        if (i.eff) {
          this.eff = true;
        }
        this.block.push(i);
      }
      return this;
    };

    BlockNode.prototype._getBuilder = function() {
      var block, cur, i, len, m, x;
      cur = builder.empty();
      block = this.block;
      for (x = m = 0, len = block.length; m < len; x = ++m) {
        i = block[x];
        cur = cur.append(i.getBuilder());
      }
      return cur;
    };

    BlockNode.prototype.addPlaceholder = function(e, p) {
      var base, x;
      x = this.block.indexOf(e);
      assert.ok(x >= 0);
      return ((base = this.placeholders)[x] != null ? base[x] : base[x] = []).push(p);
    };

    BlockNode.prototype._fwdPass = function(use) {
      var b, c, i, j, len, len1, m, n, nb, o, ouse, q, ref, ref1, s, x;
      this.placeholders = [];
      ouse = kit.extend({}, use);
      ref = this.block;
      for (x = m = 0, len = ref.length; m < len; x = ++m) {
        i = ref[x];
        i.fwdPass(use);
      }
      if (this.placeholders.length) {
        c = this;
        ref1 = this.placeholders;
        for (x = o = ref1.length - 1; o >= 0; x = o += -1) {
          i = ref1[x];
          if (!(i)) {
            continue;
          }
          b = c.block;
          n = b.splice(0, x);
          nb = (function() {
            var ref2;
            switch (n.length) {
              case 0:
                return this.ctx.emptyNode();
              case 1:
                return n[0];
              default:
                return c = (ref2 = this.ctx.blockNode()).append.apply(ref2, n).fwdPass(ouse);
            }
          }).call(this);
          s = {};
          for (q = 0, len1 = i.length; q < len1; q++) {
            j = i[q];
            j.setBlock(nb, b, s);
          }
        }
      }
      return delete this.placeholders;
    };

    BlockNode.prototype._backPass = function(use) {
      var eff, f, i, len, m, o, ref, ref1;
      eff = this.eff;
      if (!eff) {
        ref = this.block;
        for (m = 0, len = ref.length; m < len; m++) {
          f = ref[m];
          if (f.eff) {
            eff = true;
            break;
          }
        }
      }
      ref1 = this.block;
      for (o = ref1.length - 1; o >= 0; o += -1) {
        i = ref1[o];
        i.backPass(use);
      }
      if (eff) {
        this._propagateEff();
      }
      return this;
    };

    BlockNode.prototype.last = function() {
      return this.block[this.block.length - 1];
    };

    return BlockNode;

  })(DynNode);

  regNodeType("blockNode", BlockNode);

  Node.prototype.getTail = function() {
    return this;
  };

  Scope.prototype.nodes = function() {
    var arr, i, len, m, ref, res, walk;
    arr = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    if (arr.length === 1) {
      return arr[0];
    }
    res = [];
    walk = function(n) {
      var i, len, m, ref, results;
      if (n instanceof BlockNode) {
        ref = n.block;
        results = [];
        for (m = 0, len = ref.length; m < len; m++) {
          i = ref[m];
          results.push(walk(i));
        }
        return results;
      } else {
        return res.push(n);
      }
    };
    for (m = 0, len = arr.length; m < len; m++) {
      i = arr[m];
      walk(i);
    }
    if (!res.length) {
      return this.emptyNode();
    }
    if (res.length === 1) {
      return res[0];
    }
    return (ref = this.blockNode()).append.apply(ref, arr);
  };

  Node.prototype.append = function() {
    var args, ref;
    args = 1 <= arguments.length ? slice.call(arguments, 0) : [];
    return (ref = this.ctx).nodes.apply(ref, [this].concat(slice.call(args)));
  };

  EmptyNode.prototype.append = function() {
    var f, nxt;
    f = arguments[0], nxt = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    if (nxt.length) {
      return f.append.apply(f, nxt);
    }
    return f;
  };

  PureNode.prototype.append = function() {
    var f, nxt, ref;
    f = arguments[0], nxt = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    if (f.pureBlock != null) {
      (ref = this.block).push.apply(ref, f.pureBlock());
      if (nxt.length) {
        return this.append.apply(this, nxt);
      }
      return this;
    }
    return PureNode.__super__.append.apply(this, [f].concat(slice.call(nxt)));
  };

  Node.prototype.fullDeps = function() {};

  Node.prototype.setPosition = function(exprPos) {
    this.exprPos = exprPos;
    return this;
  };

  Node.prototype.fullDeps = function(pos, deps) {
    if (this.exprPos) {
      pos.push(this.exprPos);
      return deps.push(this);
    }
  };

  PureNode.prototype.fullDeps = function() {
    var p, px, ref;
    if (this.exprPos) {
      ref = this.exprPos, p = ref[0], px = ref[1];
      return p[px] = kit.lit(null);
    }
  };

  PureExprNode.prototype.fullDeps = function(pos, deps) {
    var p, px, ref;
    if (this.exprPos) {
      if (this.vdeps.mod) {
        pos.push(this.exprPos);
        return deps.push(this);
      } else {
        ref = this.exprPos, p = ref[0], px = ref[1];
        return p[px] = this.pureExpr;
      }
    }
  };

  EffValNode = (function(superClass) {
    extend(EffValNode, superClass);

    function EffValNode(val1) {
      this.val = val1;
      EffValNode.__super__.constructor.call(this);
    }

    EffValNode.prototype.ignoreResult = function() {
      this.noRes = true;
      return this;
    };

    EffValNode.prototype._getBuilder = function() {
      return builder.exprEffCoerce(this.val);
    };

    return EffValNode;

  })(EffectfulNode);

  regNodeType("effValNode", EffValNode);

  lookupPlaceholderTarget = function() {
    var i, p;
    i = this;
    while (true) {
      p = i.parent;
      if (p == null) {
        break;
      }
      if (p.addPlaceholder != null) {
        p.addPlaceholder(i, this);
        break;
      }
      i = p;
    }
    return this;
  };

  PlaceholderNode = (function(superClass) {
    extend(PlaceholderNode, superClass);

    function PlaceholderNode(arg) {
      this.arg = arg;
      PlaceholderNode.__super__.constructor.call(this);
    }

    PlaceholderNode.prototype.setExpr = function(expr) {
      if (!this.arg) {
        return PlaceholderNode.__super__.setExpr.call(this, expr);
      }
      return PlaceholderNode.__super__.setExpr.call(this, kit.mapply([expr], kit.fun([], [kit.ret(this.arg)])));
    };

    PlaceholderNode.prototype.setBlock = function(n, b, s) {
      var i, vn;
      vn = s.vn;
      this.depBlock = n;
      if (s.vn == null) {
        this.prim = true;
        s.vn = vn = this.ctx.uniqId("n");
        b.unshift(this.ctx.reifyNode().setBody(n).setVar(vn).setParent(this));
        for (i in n.vdeps.mods) {
          this.ctx.refs[i] = true;
        }
      }
      return this.setExpr(vn);
    };

    PlaceholderNode.prototype._fwdPass = function(use) {
      return lookupPlaceholderTarget.call(this);
    };

    return PlaceholderNode;

  })(PureExprNode);

  Node.prototype.fillPlaceholder = function(p) {
    return this.parent.fillPlaceholder(p, this);
  };

  BlockNode.prototype.fillPlaceholder = function(p) {
    var block, x;
    block = this.block;
    x = block.indexOf(n);
    return assert.ok(x >= 0);
  };

  regNodeType("placeholderNode", PlaceholderNode);

  Node.prototype.setExprPos = function(exprPos) {
    this.exprPos = exprPos;
    return this;
  };

  BindNode = (function(superClass) {
    extend(BindNode, superClass);

    function BindNode(body, deps) {
      BindNode.__super__.constructor.call(this);
      this.setDeps(deps);
      this.setBody(body);
    }

    BindNode.prototype.bindNode = true;

    BindNode.prototype.setBody = function(body) {
      if (body != null) {
        body.setParent(this);
      }
      this.body = body;
      return this;
    };

    BindNode.prototype.setDeps = function(deps) {
      var i, len, m;
      for (m = 0, len = deps.length; m < len; m++) {
        i = deps[m];
        i.setParent(this);
      }
      this.deps = deps;
      return this;
    };

    BindNode.prototype._fullDeps = function(pos, deps) {
      var i, len, m, ref, x;
      this.body.fullDeps(pos, deps);
      ref = this.deps;
      for (x = m = 0, len = ref.length; m < len; x = ++m) {
        i = ref[x];
        i.fullDeps(pos, deps);
      }
    };

    BindNode.prototype.fullDeps = function(pos, deps) {
      if (this.body.eff) {
        return BindNode.__super__.fullDeps.call(this, pos, deps);
      } else {
        return this._fullDeps(pos, deps);
      }
    };

    BindNode.prototype.assemblePar = function(deps, cur) {
      return builder.par(deps, cur);
    };

    BindNode.prototype._getBuilder = function() {
      var b, commit, cur, deps, e, eargs, eb, m, nxt, p, pos, px, ref, shallow, x;
      pos = [];
      eargs = [];
      this._fullDeps(pos, eargs);
      deps = [];
      cur = this.body.getBuilder();
      shallow = true;
      commit = (function(_this) {
        return function() {
          switch (deps.length) {
            case 0:
              return cur;
            case 1:
              cur = deps[0].append(cur);
              break;
            default:
              cur = _this.assemblePar(deps, cur);
          }
          deps = [];
          return cur;
        };
      })(this);
      for (x = m = pos.length - 1; m >= 0; x = m += -1) {
        ref = pos[x], p = ref[0], px = ref[1];
        e = eargs[x];
        if (!e.eff) {
          if (!e.vdeps.mod) {
            eb = e.getBuilder().toExprBuilder();
            cur.pushEnv(eb.env);
            p[px] = eb.expr;
            continue;
          }
          if (shallow) {
            eb = e.getBuilder().toExprBuilder();
            p[px] = eb.expr;
            nxt = commit();
            cur = builder.pure([]).pushEnv(eb.env).setOpts(this.opts).append(nxt);
            continue;
          }
        }
        b = e.getBuilder().setBindVar(p[px] = this.ctx.uniqId("b"));
        if (e.vdeps.mod) {
          cur = b.append(commit());
        } else {
          deps.unshift(b);
        }
        shallow = false;
      }
      return commit();
    };

    BindNode.prototype.ignoreResult = function() {
      BindNode.__super__.ignoreResult.call(this);
      this.setBody(this.body.ignoreResult());
      return this;
    };

    BindNode.prototype._backPass = function(use) {
      var eff, i, len, m, o, ref, ref1;
      this.body.backPass(use);
      ref = this.deps;
      for (m = ref.length - 1; m >= 0; m += -1) {
        i = ref[m];
        i.backPass(use);
      }
      ref1 = this.deps;
      for (o = 0, len = ref1.length; o < len; o++) {
        i = ref1[o];
        eff = eff || i.eff;
      }
      eff || (eff = this.eff || this.body.eff);
      if (eff) {
        this.propagateEff();
      }
      return this;
    };

    BindNode.prototype._fwdPass = function(use) {
      var block, i, len, m, ref;
      block = this.block;
      ref = this.deps;
      for (m = 0, len = ref.length; m < len; m++) {
        i = ref[m];
        i.fwdPass(use);
      }
      return this.body.fwdPass(use);
    };

    return BindNode;

  })(DynNode);

  regNodeType("bindNode", BindNode);

  simpleExpressions = {
    Literal: true,
    Identifier: true
  };

  isSimpleExpr = function(e) {
    return simpleExpressions[e.type];
  };

  SharedNode = (function(superClass) {
    extend(SharedNode, superClass);

    function SharedNode(def, body) {
      SharedNode.__super__.constructor.call(this);
      this.setDef(def);
      this.setBody(body);
      this.refs = [];
    }

    SharedNode.prototype.setDef = function(def1) {
      this.def = def1;
      if (this.def) {
        this.def.setParent(this);
        if (this.def.eff) {
          this.eff = true;
        }
      }
      return this;
    };

    SharedNode.prototype.setBody = function(body1) {
      this.body = body1;
      if (this.body) {
        this.body.setParent(this);
        if (this.body.eff) {
          this.eff = true;
        }
      }
      return this;
    };

    SharedNode.prototype.init = function(ctx) {
      if (this.def.pureExpr && isSimpleExpr(this.def.pureExpr)) {
        this._ref = this.def.pureExpr;
        this._simplExpr = true;
      } else {
        this._ref = this.name = ctx.uniqId("s");
      }
      return SharedNode.__super__.init.call(this, ctx);
    };

    SharedNode.prototype._getBuilder = function() {
      if (this._simplExpr) {
        return this.body.getBuilder();
      }
      if (this.def.pureExpr != null) {
        return builder.pure([kit.varDecl(this.name, this.def.pureExpr)]).mergeEnv(this.def.vdeps).append(this.body.getBuilder());
      } else {
        return builder.par([this.def.getBuilder().setBindVar(this.name)], this.body.getBuilder());
      }
    };

    SharedNode.prototype.ignoreResult = function() {
      SharedNode.__super__.ignoreResult.call(this);
      this.setBody(this.body.ignoreResult());
      return this;
    };

    SharedNode.prototype._backPass = function(use) {
      var eff;
      this.body.backPass(use);
      this.def.backPass(use);
      eff = this.eff || this.body.eff || this.def.eff;
      if (eff) {
        this.propagateEff();
      }
      return this;
    };

    SharedNode.prototype._fwdPass = function(use) {
      var block;
      block = this.block;
      this.def.fwdPass(use);
      return this.body.fwdPass(use);
    };

    return SharedNode;

  })(DynNode);

  regNodeType("sharedNode", SharedNode);

  JumpNode = (function(superClass) {
    extend(JumpNode, superClass);

    function JumpNode(dst1, kind) {
      this.dst = dst1;
      this.kind = kind;
      JumpNode.__super__.constructor.call(this);
      this.vdeps.skipMods();
    }

    JumpNode.prototype.setDst = function(dst1) {
      this.dst = dst1;
      return this;
    };

    JumpNode.prototype._fwdPass = function(use) {
      var i;
      if (this.val) {
        this.val.fwdPass(use);
      }
      i = this;
      while (true) {
        i = i.parent;
        if ((i == null) || i === this.dst) {
          break;
        }
        i.unwindBy[this.id] = this;
      }
    };

    return JumpNode;

  })(DynNode);

  BreakNode = (function(superClass) {
    extend(BreakNode, superClass);

    function BreakNode(dst, val, name) {
      BreakNode.__super__.constructor.call(this, dst, name != null ? name : "brk");
      this.setVal(val);
    }

    BreakNode.prototype.setVal = function(val1) {
      this.val = val1;
      if (this.val) {
        this.val.setParent(this);
      }
      return this;
    };

    BreakNode.prototype._getBuilder = function() {
      var expr, lab, thread, vexpr;
      if (this.ret) {
        if (this.val) {
          return this.val.getBuilder();
        }
        return builder.empty();
      }
      lab = this.dst.getLabel();
      if (this.val) {
        if (this.val != null) {
          vexpr = this.val.getBuilder().coerceObj().toExpr();
        }
        expr = this.val.eff ? kit.mbind([vexpr], lab) : kit.call(lab, [vexpr]);
      } else {
        thread = this.dst.thread;
        if (thread.length > 1) {
          thread = [kit.arr(thread)];
        }
        expr = kit.call(lab, thread);
      }
      return builder.exprEff(expr).noCapture().setBrk(true);
    };

    BreakNode.prototype._backPass = function(use) {
      var eff;
      eff = this.eff;
      if (this.val) {
        this.val.backPass(use);
        eff || (eff = this.val.eff);
      }
      if (eff) {
        this.propagateEff();
      }
      return this;
    };

    return BreakNode;

  })(JumpNode);

  YieldNode = (function(superClass) {
    extend(YieldNode, superClass);

    function YieldNode(dst, val) {
      YieldNode.__super__.constructor.call(this, dst, val);
      this.eff = true;
    }

    YieldNode.prototype.ignoreResult = function() {
      return this;
    };

    YieldNode.prototype.setBlock = function(block1) {
      this.block = block1;
      return this;
    };

    YieldNode.prototype._getBuilder = function() {
      var b;
      b = this.block.getBuilder().append(YieldNode.__super__._getBuilder.call(this)).setOpts(this.opts).mergeEnv(this.vdeps).toExprBuilder();
      return builder.exprEff(kit.call(kit.mem(b.expr, kit.id("mopt")), [])).morph(b);
    };

    YieldNode.prototype._fwdPass = function(use) {
      this.dst.opts.keepScope = true;
      return lookupPlaceholderTarget.call(this);
    };

    YieldNode.prototype._backPass = function(use) {
      this.propagateEff();
      return this.block.backPass(use);
    };

    return YieldNode;

  })(BreakNode);

  regNodeType("breakNode", BreakNode);

  regNodeType("yieldNode", YieldNode);

  BranchedNode = (function(superClass) {
    extend(BranchedNode, superClass);

    function BranchedNode(fun1, template) {
      this.fun = fun1;
      this.template = template;
      BranchedNode.__super__.constructor.call(this);
      this.deps = [];
    }

    BranchedNode.prototype.setDeps = function() {
      var cur, deps, i, len, m;
      deps = 1 <= arguments.length ? slice.call(arguments, 0) : [];
      cur = this.deps;
      cur.length = 0;
      if (deps != null) {
        for (m = 0, len = deps.length; m < len; m++) {
          i = deps[m];
          i.setParent(this);
          cur.push(i);
        }
      }
      return this;
    };

    BranchedNode.prototype._getItemBuilder = function(i) {
      return i.getBuilder();
    };

    BranchedNode.prototype._getBuilder = function() {
      var block, blocks, bn, cb, eff, i, j, len, len1, m, needCoerce, nenv, o, ref, ref1, ref2, threadOut, v, w;
      eff = this.eff;
      threadOut = {};
      nenv = {};
      ref = this.deps;
      for (m = 0, len = ref.length; m < len; m++) {
        i = ref[m];
        i.vdeps.threadOutMap(threadOut);
      }
      blocks = [];
      needCoerce = false;
      ref1 = this.deps;
      for (o = 0, len1 = ref1.length; o < len1; o++) {
        i = ref1[o];
        cb = this._getItemBuilder(i);
        cb = cb.addThread(threadOut);
        bn = cb.capture().toBlockBuilder(eff);
        needCoerce || (needCoerce = bn._needCoerce === true);
        ref2 = bn.env;
        for (j in ref2) {
          v = ref2[j];
          w = nenv[j] != null ? nenv[j] : nenv[j] = {};
          if (v.use) {
            w.use = true;
          }
          if (v.set) {
            w.set = true;
          }
          if (v.mod) {
            w.mod = true;
          }
          if (threadOut[j]) {
            w.thread = true;
          }
        }
        blocks.push(kit.flatBlock(bn.block));
      }
      block = builder.block(eff, [this.fun.apply(this, blocks)]).pushEnv(nenv).noCapture().needCoerce(needCoerce != null ? needCoerce : false);
      return block;
    };

    BranchedNode.prototype._propagateEff = function() {
      var deps, i, len, m, x;
      BranchedNode.__super__._propagateEff.call(this);
      deps = this.deps;
      for (x = m = 0, len = deps.length; m < len; x = ++m) {
        i = deps[x];
        deps[x] = i.propagateEff();
      }
      return this;
    };

    BranchedNode.prototype._backPass = function(use) {
      var i, len, len1, len2, m, o, q, ref, ref1, ref2;
      if (!this.eff) {
        ref = this.deps;
        for (m = 0, len = ref.length; m < len; m++) {
          i = ref[m];
          if (!i.eff) {
            continue;
          }
          this.eff = true;
          break;
        }
      }
      if (this.eff) {
        this._propagateEff();
      }
      ref1 = this.deps;
      for (o = 0, len1 = ref1.length; o < len1; o++) {
        i = ref1[o];
        i.backPass(kit.extend({}, use));
      }
      ref2 = this.deps;
      for (q = 0, len2 = ref2.length; q < len2; q++) {
        i = ref2[q];
        kit.extend(use, i.vdeps.uses);
      }
      return this;
    };

    BranchedNode.prototype._fwdPass = function(use) {
      var i, len, m, ref;
      ref = this.deps;
      for (m = 0, len = ref.length; m < len; m++) {
        i = ref[m];
        i.fwdPass(kit.extend({}, use));
      }
    };

    return BranchedNode;

  })(DynNode);

  regNodeType("branchedNode", BranchedNode);

  WrapNode = (function(superClass) {
    extend(WrapNode, superClass);

    function WrapNode(body) {
      WrapNode.__super__.constructor.call(this);
      this.setBody(body);
    }

    WrapNode.prototype.setBody = function(body1) {
      this.body = body1;
      if (this.body != null) {
        this.body.setParent(this);
      }
      return this;
    };

    WrapNode.prototype._backPass = function(use) {
      if (this.eff || this.body.eff) {
        this._propagateEff();
      }
      this.body.backPass(use);
      return this;
    };

    WrapNode.prototype._fwdPass = function(use) {
      return this.body.fwdPass(use);
    };

    return WrapNode;

  })(DynNode);

  getBuilderFun = function(node, ctx) {
    var b, fun, i, thread, vars;
    thread = node.vdeps.threadOutMap();
    b = node.getBuilder();
    if (thread != null) {
      b.addThread(thread);
    }
    b = b.capture().toBlockBuilder();
    for (i in b.env) {
      if (i.thread) {
        thread[i] = true;
      }
    }
    vars = ((function() {
      var results;
      results = [];
      for (i in thread) {
        results.push(i);
      }
      return results;
    })()).sort().map(kit.id);
    fun = kit.spreadFun(vars, kit.fun(vars, b.block));
    return [fun, vars, b, thread];
  };

  RepeatNode = (function(superClass) {
    extend(RepeatNode, superClass);

    function RepeatNode(body) {
      RepeatNode.__super__.constructor.call(this, body);
    }

    RepeatNode.prototype._getBuilder = function() {
      var b, expr, fun, ref, vars;
      ref = getBuilderFun(this.body, this.ctx), fun = ref[0], vars = ref[1], b = ref[2];
      if (vars.length > 1) {
        vars = [kit.arr(vars)];
      }
      expr = kit.call(kit.packId("repeat"), [fun].concat(slice.call(vars)));
      return builder.exprEff(expr).morph(b).mergeEnv(this.vdeps).noCapture();
    };

    RepeatNode.prototype._fwdPass = function(use) {
      return this.body.fwdPass({});
    };

    RepeatNode.prototype._backPass = function(use) {
      var i;
      for (i in this.body.vdeps.uses) {
        use[i] = true;
      }
      return RepeatNode.__super__._backPass.call(this, use);
    };

    return RepeatNode;

  })(WrapNode);

  regNodeType("repeatNode", RepeatNode);

  ControlNode = (function(superClass) {
    extend(ControlNode, superClass);

    function ControlNode(kind) {
      this.kind = kind;
      this.exits = [];
      if (this.kind == null) {
        this.kind = "block";
      }
      this.labCount = 0;
      this.thread = [];
      ControlNode.__super__.constructor.call(this);
    }

    ControlNode.prototype.setLabel = function(lab) {
      if (lab == null) {
        lab = "l";
      }
      this.label = this.ctx.uniqId(lab);
      return this;
    };

    ControlNode.prototype.getLabel = function() {
      if (this.label != null) {
        return this.label;
      }
      return this.label = this.ctx.uniqId("l");
    };

    ControlNode.prototype.breakNode = function(v) {
      var res;
      res = this.ctx.breakNode(this, v);
      this.exits.push(res);
      return res;
    };

    ControlNode.prototype.yieldNode = function(v) {
      var res;
      res = this.ctx.yieldNode(this, v);
      this.exits.push(res);
      return res;
    };

    ControlNode.prototype.trimExits = function(loopBody) {
      var i, j, k, x;
      if (!this.opts.keepScope) {
        if (this.exits.length === 1) {
          i = j = this.exits[0];
          while (true) {
            k = i;
            i = i.parent;
            if (i === this || i === loopBody) {
              j.ret = true;
              this.exits.length = 0;
              break;
            }
            if (i instanceof BlockNode) {
              x = i.block.indexOf(k);
              if (x < 0) {
                return this;
              }
              i.block.splice(x + 1, i.block.length);
              continue;
            }
            if (!(i instanceof BindNode)) {
              return;
            }
          }
        }
      }
    };

    ControlNode.prototype._getBuilder = function() {
      var b, bodyBlock, i, thread;
      this.trimExits();
      if (!(this.exits.length && this.eff)) {
        return this.body.getBuilder();
      }
      if (this.kind !== "scope") {
        thread = this.body.vdeps.threadOutMap();
        this.thread = ((function() {
          var results;
          results = [];
          for (i in thread) {
            results.push(i);
          }
          return results;
        })()).sort().map(kit.id);
      } else {
        this.thread = [];
      }
      b = this.body.getBuilder();
      b = b.capture().toBlockBuilder();
      bodyBlock = b.block;
      return builder.exprEff(kit.call(kit.packId(this.kind), [kit.fun([this.getLabel()], bodyBlock)])).morph(b).mergeEnv(this.vdeps).noCapture();
    };

    ControlNode.prototype._propagateEff = function() {
      var i, len, m, ref;
      ControlNode.__super__._propagateEff.call(this);
      ref = this.exits;
      for (m = 0, len = ref.length; m < len; m++) {
        i = ref[m];
        i.propagateEff();
      }
      return this;
    };

    ControlNode.prototype._backPass = function(use) {
      var i, j, len, m, ref, ref1, v;
      this.body.backPass(use);
      if (this.kind !== "scope") {
        ref = this.exits;
        for (m = 0, len = ref.length; m < len; m++) {
          i = ref[m];
          ref1 = this.vdeps.after;
          for (j in ref1) {
            v = ref1[j];
            if (v) {
              i.vdeps.after[j] = true;
            }
          }
        }
      }
    };

    return ControlNode;

  })(WrapNode);

  regNodeType("controlNode", ControlNode);

  LoopNode = (function(superClass) {
    extend(LoopNode, superClass);

    function LoopNode() {
      LoopNode.__super__.constructor.call(this);
    }

    LoopNode.prototype.simpleLoop = function() {
      var b, bb, body, i, ref, ref1, ref2, tb, test, thread, updVars, update, v;
      if (!this.pre) {
        return;
      }
      if (this.opts.loop === "seq") {
        return;
      }
      this.cont.trimExits();
      if (this.cont.exits.length) {
        return;
      }
      if ((this.update != null) && this.update.eff) {
        return;
      }
      if (this.test.eff || this.test.vdeps.upd) {
        return;
      }
      if (this.inner.vdeps.upd) {
        return;
      }
      ref = this.inner.unwindBy;
      for (i in ref) {
        v = ref[i];
        if (v.dst !== this && v.dst !== this.cont) {
          return;
        }
      }
      this.trimExits(this.inner.parent);
      if (this.exits.length) {
        return;
      }
      ref1 = getBuilderFun(this.update, this.ctx), update = ref1[0], updVars = ref1[1], b = ref1[2], thread = ref1[3];
      tb = this.test.getBuilder().toBlockBuilder().capture();
      test = kit.spreadFun(updVars, kit.fun(updVars, tb.block));
      bb = this.inner.getBuilder();
      bb = bb.capture().toBlockBuilder();
      body = kit.spreadFun(updVars, kit.fun(updVars, bb.block));
      ref2 = b.env;
      for (i in ref2) {
        v = ref2[i];
        if (v.mod) {
          v.mod = false;
        }
      }
      if (updVars.length > 1) {
        updVars = [kit.arr(updVars)];
      }
      return builder.exprEff(kit.call(kit.packId("forPar"), [test, body, update].concat(slice.call(updVars)))).morph(b).mergeEnv(this.vdeps).noCapture();
    };

    LoopNode.prototype._getBuilder = function() {
      var res;
      res = this.simpleLoop();
      if (res != null) {
        return res;
      }
      return LoopNode.__super__._getBuilder.call(this);
    };

    return LoopNode;

  })(ControlNode);

  regNodeType("loopNode", LoopNode);

  TryCatchNode = (function(superClass) {
    extend(TryCatchNode, superClass);

    function TryCatchNode() {
      TryCatchNode.__super__.constructor.call(this);
      this.throws = [];
    }

    TryCatchNode.prototype.setBody = function(b) {
      this.body = b;
      if (b != null) {
        b.setParent(this);
      }
      return this;
    };

    TryCatchNode.prototype.setHandler = function(hvar, h) {
      this.hvar = hvar;
      this.handler = h;
      if (h != null) {
        h.setParent(this);
      }
      return this;
    };

    TryCatchNode.prototype.setFin = function(f) {
      this.fin = f;
      if (f != null) {
        f.setParent(this);
      }
      return this;
    };

    TryCatchNode.prototype._getBuilder = function() {
      var bb, e, fb, hb, res;
      if (!((this.handler != null) || (this.fin != null))) {
        return this.body.getBuilder();
      }
      bb = this.body.getBuilder().coerceTry().toExprBuilder(true);
      e = bb.expr;
      if (this.handler != null) {
        hb = this.handler.getBuilder().toBlockBuilder(true);
        e = kit["catch"](bb.expr, this.hvar, hb.block);
      }
      if (this.fin != null) {
        fb = this.fin.getBuilder().toBlockBuilder(true);
        e = kit["finally"](e, fb.block);
      }
      res = builder.exprEff(e).pushEnv(bb.env);
      if (hb != null) {
        res.pushEnv(hb.env);
      }
      if (fb != null) {
        res.pushEnv(fb.env);
      }
      return res;
    };

    TryCatchNode.prototype._fwdPass = function(use) {
      var fdeps, hdeps, i;
      this.body.fwdPass(use);
      if (this.handler) {
        this.handler.fwdPass(use);
        hdeps = this.handler.vdeps.uses;
      } else {
        hdeps = {};
      }
      if (this.fin) {
        this.fin.fwdPass(use);
        fdeps = this.fin.vdeps.uses;
      } else {
        fdeps = {};
      }
      for (i in this.body.vdeps.mods) {
        if (fdeps[i] || hdeps[i]) {
          this.ctx.refs[i] = true;
        }
      }
    };

    TryCatchNode.prototype._propagateEff = function() {
      var i, len, m, ref;
      TryCatchNode.__super__._propagateEff.call(this);
      ref = this.throws;
      for (m = 0, len = ref.length; m < len; m++) {
        i = ref[m];
        i.propagateEff();
      }
      return this;
    };

    TryCatchNode.prototype._backPass = function(use) {
      if (!this.eff) {
        this.eff = this.body.eff || (this.handler != null) && this.handler.eff || this.fin && this.fin.eff;
      }
      if (this.eff) {
        this._propagateEff();
      }
      if (this.fin != null) {
        this.fin.backPass(use);
      }
      if (this.handler != null) {
        this.handler.backPass(use);
      }
      return this.body.backPass(use);
    };

    return TryCatchNode;

  })(DynNode);

  regNodeType("tryCatchNode", TryCatchNode);

  ThrowNode = (function(superClass) {
    extend(ThrowNode, superClass);

    function ThrowNode(val) {
      ThrowNode.__super__.constructor.call(this);
      this.setVal(val);
    }

    ThrowNode.prototype.setVal = function(val) {
      this.val = val.setParent(this);
      return this;
    };

    ThrowNode.prototype._backPass = function(use) {
      ThrowNode.__super__._backPass.call(this);
      if (!this.eff) {
        this.eff = this.val.eff;
      }
      if (this.eff) {
        this._propagateEff();
      }
      this.val.backPass(use);
      return this;
    };

    ThrowNode.prototype._fwdPass = function(use) {
      var l, p;
      p = this.parent;
      l = this;
      while (true) {
        if ((p.throws != null) && p.body === l) {
          this.dst = p;
          break;
        }
        l = p;
        p = p.parent;
      }
      this.dst.throws.push(this);
      this.val.fwdPass(use);
      return this;
    };

    ThrowNode.prototype._getBuilder = function() {
      var v;
      assert.ok(this.eff);
      v = this.ctx.uniqId("e");
      if (this.val.pureExpr) {
        return builder.exprEff(kit.call(kit.packId("raise"), [this.val.pureExpr]));
      }
      return this.val.getBuilder().setBindVar(v).setOpts(this.opts).append(builder.exprEff(kit.call(kit.packId("raise"), [v])).setOpts(this.opts));
    };

    return ThrowNode;

  })(DynNode);

  regNodeType("throwNode", ThrowNode);

  Node.prototype.tryCatch = function(hv, h, f) {
    return this.ctx.tryCatchNode().setBody(this).setHandler(hv, h).setFin(f);
  };

  Scope.prototype.stmtNode = function(s) {
    var sv;
    if (s == null) {
      return EmptyNode();
    }
    sv = this.stmt(s);
    if (sv != null) {
      return sv;
    }
    return PureNode([s]);
  };

  Node.prototype.isEmpty = function() {
    return false;
  };

  BlockNode.prototype.isEmpty = function() {
    return !this.block.length;
  };

  EmptyNode.prototype.isEmpty = function() {
    return true;
  };

}).call(this);