@mfjs/compiler/expr.js

// Generated by CoffeeScript 1.10.0
(function() {
  var ActiveVisitor, DisabledVisitor, DummyBuilder, ExprBuilder, Scope, VarUsage, Visitor, config, directive, kit, policy, ref,
    slice = [].slice;

  config = require("./config");

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

  ref = require("./visitor"), Visitor = ref.Visitor, ActiveVisitor = ref.ActiveVisitor, DisabledVisitor = ref.DisabledVisitor;

  kit = require("./kit");

  policy = require("./policy");

  directive = require("./directives");

  VarUsage = require("./builder").VarUsage;

  require("./graph");

  require("./expr");

  ExprBuilder = (function() {
    function ExprBuilder(expr1, ctx1) {
      this.expr = expr1;
      this.ctx = ctx1;
      this.init();
      this.cur = this.ctx.policy.opts.bind ? this.ctx.effValNode(this.expr) : this.ctx.exprNode(this.expr);
    }

    ExprBuilder.prototype.init = function() {
      return this.deps = [];
    };

    ExprBuilder.prototype.add = function(s, par, x, opts) {
      var r;
      r = this.ctx.expr(s, opts);
      if ((r.pureExpr != null) && !r.vdeps.mod) {
        par[x] = r.pureExpr;
        this.cur.vdeps.addInnerDeep(r.vdeps);
        return;
      }
      r.setPosition([par, x]);
      this.deps.push(r);
    };

    ExprBuilder.prototype.result = function() {
      var res, vdeps;
      res = this.cur;
      vdeps = res.vdeps;
      if (this.deps.length) {
        res = this.ctx.bindNode(res, this.deps);
      }
      if (this.orig === false) {
        res.origExpr = false;
      }
      this.init();
      return this.cur = res;
    };

    return ExprBuilder;

  })();

  DummyBuilder = (function() {
    function DummyBuilder(expr1, ctx1) {
      this.expr = expr1;
      this.ctx = ctx1;
    }

    DummyBuilder.prototype.add = function(s, par, x, opts) {
      var r;
      r = this.ctx.expr(s, opts);
      if (r.pureExpr != null) {
        par[x] = r.pureExpr;
        return;
      }
      throw new Error("INTERNAL: not expected effectful expression");
    };

    DummyBuilder.prototype.result = function() {
      return this.ctx.pureExprNode(this.expr);
    };

    return DummyBuilder;

  })();

  Visitor.prototype.CallExpression = function(e) {
    var a, args, builder, callee, dir, i, idn, j, len, n, opts, res, x;
    opts = this.policy.opts;
    callee = e.callee, args = e["arguments"];
    if (callee.type === "Identifier") {
      n = callee.name;
      if (n === "require" && args.length === 1) {
        a = args[0];
        if (a.type === "Literal" && a.value === config.packageName) {
          this.ctx.policy._libRequire();
          return this.ctx.pureExprNode(e);
        }
      }
    }
    dir = (function() {
      var dn, obj, prop;
      if (n === config.packageVar) {
        return directive.$packVar;
      }
      if (callee.type !== "MemberExpression") {
        return;
      }
      obj = callee.object;
      if (!(obj.type === "Identifier" && obj.name === config.packageVar)) {
        return;
      }
      prop = callee.property;
      if (prop.type === "Identifier") {
        dn = prop.name;
      } else if (callee.computed && prop.type === "Literal" && prop.value.substr) {
        dn = prop.value;
      } else {
        return;
      }
      return directive[dn];
    })();
    if (dir != null) {
      res = kit.errorPos(e, (function(_this) {
        return function() {
          return dir.call.apply(dir, [_this.ctx, e].concat(slice.call(e["arguments"])));
        };
      })(this));
      if (res == null) {
        return this.ctx.emptyNode();
      }
      return res;
    }
    idn = opts.identity;
    if ((idn != null) && idn !== false) {
      if (idn === true) {
        idn = 0;
      }
      return this.ctx.expr(e["arguments"][idn]);
    }
    builder = this.getExprBuilder(e);
    callee = e.callee, args = e["arguments"];
    builder.add(callee, e, "callee");
    if (opts.subScope !== false && callee.$dm$eff === true) {
      opts.bind = true;
    }
    for (x = j = 0, len = args.length; j < len; x = ++j) {
      i = args[x];
      builder.add(i, args, x);
    }
    return builder.result();
  };

  directive.$packVar = function(e, arg) {
    var bnd;
    bnd = this.policy.opts.bind;
    e = this.expr(arg);
    if (bnd && e.pureExpr) {
      return this.effValNode(e.pureExpr).morphInit(e);
    }
    return e;
  };

  directive.reflect = function(e, arg) {
    var bnd, expr;
    bnd = this.policy.opts.bind;
    expr = kit.call(kit.packId("reflect"), [arg]);
    return this.bindNode(this.effValNode(expr), [this.expr(arg).setPosition([expr["arguments"], 0])]);
  };

  directive.reify = function(e, arg) {
    return this.reifyNode().setBody(this.expr(arg)).setIsThunk(arg.type === "FunctionExpression");
  };

  directive.p = directive.p = function(e, arg) {
    return this.pureExprNode(arg);
  };

  Visitor.prototype.FunctionExpression = function(e) {
    var ctx, i, j, len, ref1, ref2, res, v, vars;
    ctx = this.ctx.subScope(e);
    if (e.params != null) {
      ref1 = e.params;
      for (j = 0, len = ref1.length; j < len; j++) {
        i = ref1[j];
        if (i.name) {
          ctx.vars[i.name] = true;
        }
      }
    }
    if (ctx == null) {
      return this.ctx.pureExprNode(e);
    }
    e.body = ctx.prog(e.body);
    if (ctx.eff) {
      e.$dm$eff = true;
    }
    res = this.ctx.exprNode(e);
    vars = ctx.vars;
    ref2 = ctx.upds;
    for (i in ref2) {
      v = ref2[i];
      if (v && !ctx.vars[i]) {
        this.ctx.refs[i] = true;
      }
    }
    if (e.generator) {
      e.generator = false;
    }
    return res;
  };

  ActiveVisitor.prototype.ThisExpression = function(e) {
    var base;
    if ((base = this.ctx).thisVar == null) {
      base.thisVar = this.ctx.uniqId("_this");
    }
    return this.ctx.exprNode(this.ctx.thisVar);
  };

  Visitor.prototype.AssignmentExpression = function(e) {
    var deps, left, lv, res, right, rv;
    left = e.left, right = e.right;
    deps = [];
    res = this.ctx.exprNode(e);
    this.policy.nameDetails(left, e.operator);
    if (left.type === "Identifier") {
      if (e.operator === "=") {
        res.vdeps.addAssign(left.name);
      } else {
        res.vdeps.addUpd(left.name);
      }
      if (!this.ctx.vars[left.name]) {
        this.ctx.upds[left.name] = true;
      }
    } else {
      lv = this.ctx.expr(left);
      if (lv.pureExpr != null) {
        res.vdeps.addInnerDeep(lv.vdeps);
        e.left = lv.pureExpr;
      } else {
        deps.push(lv.setPosition([e, "left"]));
      }
    }
    rv = this.ctx.expr(right);
    if (rv.pureExpr != null) {
      res.vdeps.addInnerDeep(rv.vdeps);
      e.right = rv.pureExpr;
    } else {
      deps.push(rv.setPosition([e, "right"]));
    }
    if (deps.length) {
      res = this.ctx.bindNode(res, deps);
    }
    return res;
  };

  ActiveVisitor.prototype.UpdateExpression = function(e) {
    var a, av, res;
    res = this.ctx.exprNode(e);
    a = e.argument;
    if (a.type === "Identifier") {
      if (!this.ctx.vars[a.name]) {
        this.ctx.upds[a.name] = true;
      }
      res.vdeps.addUpd(a.name);
    } else {
      av = this.ctx.expr(a);
      if (av.pureExpr) {
        e.argument = av.pureExpr;
      } else {
        res = this.ctx.bindNode(res, [av.setPosition([e, "argument"])]);
      }
    }
    return res;
  };

  directive.$ = function(e, arg) {
    return this.placeholderNode(arg);
  };

  ActiveVisitor.prototype.MemberExpression = function(e) {
    var builder, object, property;
    object = e.object, property = e.property;
    if (object.type === "Identifier" && object.name === config.packageVar && property.type === "Identifier" && property.name === "$") {
      return this.ctx.placeholderNode();
    }
    builder = this.getExprBuilder(e);
    builder.add(object, e, "object");
    if (e.computed) {
      builder.add(property, e, "property");
    }
    return builder.result();
  };

  ActiveVisitor.prototype.Identifier = function(e) {
    var res;
    res = this.ctx.exprNode(e);
    res.vdeps.uses[e.name] = true;
    if (!e.$dm$orig) {
      this.ctx.ids[e.name] = true;
    }
    return res;
  };

  Visitor.prototype.getExprBuilder = function(e) {
    return new DummyBuilder(e, this.ctx);
  };

  ActiveVisitor.prototype.getExprBuilder = function(e) {
    return new ExprBuilder(e, this.ctx);
  };

  ActiveVisitor.prototype.LogicalExpression = function(e) {
    var b, builder, cexpr, l, lexpr, r, res, rexpr;
    if (this.policy.opts.expr === "par") {
      builder = this.getExprBuilder(e);
      builder.add(e.left, e, "left");
      builder.add(e.right, e, "right");
      return builder.result();
    }
    cexpr = {
      type: "ConditionalExpression"
    };
    l = this.ctx.expr(e.left);
    r = this.ctx.expr(e.right);
    if (!(l.eff || r.eff)) {
      return this.ctx.exprNode(e);
    }
    rexpr = r.getBuilder().setOpts(this.policy.opts).toExpr();
    b = r.eff ? this.ctx.effValNode(cexpr) : this.ctx.pureExprNode(cexpr);
    res = this.ctx.sharedNode(l, b);
    lexpr = cexpr.test = res._ref;
    if (this.policy.opts.coerce === "none" && r.eff) {
      lexpr = kit.pure(lexpr);
    }
    if (e.operator === "||") {
      cexpr.consequent = lexpr;
      cexpr.alternate = rexpr;
    } else {
      cexpr.consequent = rexpr;
      cexpr.alternate = lexpr;
    }
    return res;
  };

  ActiveVisitor.prototype.ConditionalExpression = function(e) {
    var a, builder, c, n;
    if (this.policy.opts.expr === "par") {
      builder = this.getExprBuilder(e);
      builder.add(e.test, e, "test");
      builder.add(e.consequent, e, "consequent");
      builder.add(e.alternate, e, "alternate");
      return builder.result();
    }
    c = this.ctx.expr(e.consequent);
    a = this.ctx.expr(e.alternate);
    if (c.eff || a.eff) {
      e.consequent = c.getFullExpr(true);
      e.alternate = a.getFullExpr(true);
      n = this.ctx.effValNode(e);
    } else {
      n = this.ctx.pureExprNode(e);
    }
    return this.ctx.bindNode(n, [this.ctx.expr(e.test).setPosition([e, "test"])]);
  };

  directive.answer = directive["yield"] = function(s, arg) {
    var e;
    if (arg != null) {
      e = this.expr(arg);
    }
    return this.root.yieldNode(e);
  };

  ActiveVisitor.prototype.YieldExpression = function(e) {
    if (this.ctx.policy.opts.mopt === false) {
      if (e.delegate) {
        return directive.$packVar.call(this.ctx, e, e.argument);
      }
      return directive.reflect.call(this.ctx, e, e.argument);
    }
    return this.ctx.root.yieldNode(this.ctx.expr(e.argument));
  };

  ActiveVisitor.prototype.BinaryExpression = function(e) {
    var builder;
    builder = this.getExprBuilder(e);
    builder.add(e.left, e, "left");
    builder.add(e.right, e, "right");
    return builder.result();
  };

  ActiveVisitor.prototype.UnaryExpression = function(e) {
    var builder;
    builder = this.getExprBuilder(e);
    builder.add(e.argument, e, "argument");
    return builder.result();
  };

  ActiveVisitor.prototype.NewExpression = function(e) {
    var args, builder, i, j, len, x;
    builder = this.getExprBuilder(e);
    args = e["arguments"];
    for (x = j = 0, len = args.length; j < len; x = ++j) {
      i = args[x];
      builder.add(i, args, x);
    }
    return builder.result();
  };

  ActiveVisitor.prototype.SequenceExpression = function(e) {
    var args, builder, i, j, len, x;
    builder = this.getExprBuilder(e);
    args = e.expressions;
    for (x = j = 0, len = args.length; j < len; x = ++j) {
      i = args[x];
      builder.add(i, args, x);
    }
    return builder.result();
  };

  ActiveVisitor.prototype.ArrayExpression = function(e) {
    var args, builder, i, j, len, x;
    builder = this.getExprBuilder(e);
    args = e.elements;
    for (x = j = 0, len = args.length; j < len; x = ++j) {
      i = args[x];
      if (i) {
        builder.add(i, args, x);
      }
    }
    return builder.result();
  };

  ActiveVisitor.prototype.ObjectExpression = function(e) {
    var builder, i, j, len, ref1;
    builder = this.getExprBuilder(e);
    ref1 = e.properties;
    for (j = 0, len = ref1.length; j < len; j++) {
      i = ref1[j];
      builder.add(i.value, i, "value");
    }
    return builder.result();
  };

  module.exports = {};

}).call(this);