Code coverage report for 6to5/lib/6to5/transformation/transformers/es6-for-of.js

Statements: 97.56% (40 / 41)      Branches: 94.44% (17 / 18)      Functions: 100% (3 / 3)      Lines: 97.5% (39 / 40)      Ignored: none     

All files » 6to5/lib/6to5/transformation/transformers/ » es6-for-of.js
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 961 1   1 27 27   27 26 26 26     26     26     26 25 4   21         26   26     1 5 5   5   1 4   4 4             5               5             1 22 22   22 22   22   1 21   20       1     21           21          
var util = require("../../util");
var t    = require("../../types");
 
exports.ForOfStatement = function (node, parent, file, scope) {
  var callback = spec;
  if (file.isFast("forOf")) callback = fast;
 
  var build  = callback(node, parent, file, scope);
  var declar = build.declar;
  var loop   = build.loop;
  var block  = loop.body;
 
  // inherit comments from the original loop
  t.inheritsComments(loop, node);
 
  // ensure that it's a block so we can take all it's statemetns
  t.ensureBlock(node);
 
  // add the value declaration to the new loop body
  if (declar){
    if (build.shouldUnshift) {
      block.body.unshift(declar);
    } else {
      block.body.push(declar);
    }
  }
 
  // push the rest of the original loop body onto our new body
  block.body = block.body.concat(node.body.body);
 
  return loop;
};
 
var fast = function (node, parent, file, scope) {
  var left = node.left;
  var declar, id;
 
  if (t.isIdentifier(left) || t.isPattern(left)) {
    // for (i of test), for ({ i } of test)
    id = left;
  } else Eif (t.isVariableDeclaration(left)) {
    // for (var i of test)
    id = left.declarations[0].id;
    declar = t.variableDeclaration(left.kind, [
      t.variableDeclarator(id)
    ]);
  } else {
    throw file.errorWithNode(left, "Unknown node type " + left.type + " in ForOfStatement");
  }
 
  var loop = util.template("for-of-fast", {
    LOOP_OBJECT:  file.generateUidIdentifier("iterator", scope),
    IS_ARRAY:     file.generateUidIdentifier("isArray", scope),
    OBJECT:       node.right,
    INDEX:        file.generateUidIdentifier("i", scope),
    ID:           id
  });
 
  return {
    shouldUnshift: true,
    declar:        declar,
    loop:          loop
  };
};
 
var spec = function (node, parent, file, scope) {
  var left = node.left;
  var declar;
 
  var stepKey   = file.generateUidIdentifier("step", scope);
  var stepValue = t.memberExpression(stepKey, t.identifier("value"));
 
  if (t.isIdentifier(left) || t.isPattern(left)) {
    // for (i of test), for ({ i } of test)
    declar = t.expressionStatement(t.assignmentExpression("=", left, stepValue));
  } else if (t.isVariableDeclaration(left)) {
    // for (var i of test)
    declar = t.variableDeclaration(left.kind, [
      t.variableDeclarator(left.declarations[0].id, stepValue)
    ]);
  } else {
    throw file.errorWithNode(left, "Unknown node type " + left.type + " in ForOfStatement");
  }
 
  var loop = util.template("for-of", {
    ITERATOR_KEY: file.generateUidIdentifier("iterator", scope),
    STEP_KEY:     stepKey,
    OBJECT:       node.right
  });
 
  return {
    declar: declar,
    loop:   loop
  };
};