Pattern-matching parse-time macros for Babel

0 input.js

macro { mul(...$args) sdf } -> { [not_matched, $args] }
macro { mul(...$args) } -> { [matched, $args] }
macro { foo $a x ...$b y } -> { mul($a, $b) + 3 }
lol()
console.log( foo 1 x 2, 3 y, 6 )

1 output.js

//macro { mul(...$args) sdf } -> { [not_matched, $args]
//macro { mul(...$args) } -> { [matched, $args]
//macro { foo $a x ...$b y } -> { mul($a, $b) + 3
lol();
console.log([matched, 1, 2, 3] + 3, 6);

2 test.js

// ... from end of babel-macro.js:
assertParses('foo();'
  , 'foo()');

assertParsesSame('bar();'
  , 'macro foo -> bar; foo()'
  , 'macro foo -> bar\nfoo()'
  , 'macro foo -> bar foo()'
)

assertParseThrows(/Unexpected token.*\(1:10\)/i,
  'macro foo = bar foo()')

assertParsesSame('bar;'
  , 'macro foo() -> bar; foo()'
  , 'macro {foo()} -> bar; foo()'
  , 'macro {foo()} -> {bar}; foo()'
  , 'macro foo() -> {bar}; foo()'
  , 'macro foo($) -> bar; foo(1)'
)

assertParsesSame('bar[1];'
  , 'macro foo($) -> bar[$]; foo(1)'
  , 'macro {foo($)} -> bar[$]; foo(1)'
  , 'macro {foo $} -> bar[$]; foo 1'
)

// BUG fails when flow plugin is enabled, with "Unexpected token" at "*" during expansion:
var src =
  'macro {mul $1 $2} -> ($1 * $2);\n'+
  'mul 3 4';
assertParses('3 * 4;', src, { plugins: { jsx: 1, macro: 1 } } )
assertParses('3 * 4;', src, { plugins: { macro: 1 } } )
assertParseThrows(/Unexpected token.*\(1:25\)/i
  , src, { plugins: { jsx: 1, macro: 1, flow: 1 } } )
assertParseThrows(/Unexpected token.*\(1:25\)/i
  , src, { plugins: { macro: 1, flow: 1 } } )
assertParseThrows(/Unexpected token.*\(1:26\)/i
  , 'macro {mul($1 $2)} -> ($1 * $2)'
  , 'mul(3 4)'
  , { plugins: { macro: 1, flow: 1 } } )

assertParses('r();'
  , 'macro A -> {}; r(A)')


// deep expansion
assertParses('r(d(3,d));'
  , 'macro D -> d'
  , 'macro C -> D'
  , 'macro B -> C(3, D)'
  , 'macro A -> B'
  , 'r(A)')
assertParses('r(d(2,1,d));'
  , 'macro D -> d'
  , 'macro C -> D'
  , 'macro {B $2 $1} -> C($1, $2, D)'
  , 'macro A -> {B 1 2}'
  , 'r(A)')
assertParseThrows(/Cyclic macro expansion/i
  , 'macro B -> C(A)'
  , 'macro A -> B'
  , 'a(A)')
assertParseThrows(/Cyclic macro expansion/i
  , 'macro D -> B'
  , 'macro C -> D'
  , 'macro B -> C(3, D)'
  , 'macro A -> B'
  , 'r(A)')


// rest/spread vars
assertParses('d(1,2,3);'
  , 'macro D(...$) -> { d($) }' // non-greedy, bounded rest
  , 'D(1,2,3)') //< rest terminating at expected token ")"
assertParses('d();'
  , 'macro D(...$) -> { d($) }' // non-greedy, bounded rest
  , 'D()') //< empty rest terminating at expected token ")"
assertParses('d(1,2,3);'
  , 'macro { D ...$ } -> { d($) }' // greedy rest
  , 'D 1,2,3') //< rest terminating at EOF
assertParses('d();'
  , 'macro { D ...$ } -> { d($) }' // greedy rest
  , 'D') //< empty rest terminating at EOF

babel-macro.js

function time(label) {
  console.time(label);
  var t = Date.now();
  time.end = function() {
    process.stdout.write('\x1b[1;35m');
    console.timeEnd(label);
    process.stdout.write('\x1b[0;39m');
  }
};
function timeavg(label, iterations, f) {
  if (typeof iterations === 'function') {
    f = iterations;
    iterations = 1000;
  }
  var n = iterations, t = Date.now();
  do { f(); } while (--n);
  t = Date.now() - t;
  console.log(color('1;35', label + ': ' + (t / iterations).toFixed(0) + 'ms/op')+
              color('0;90', ' ('+t+'ms, ' + iterations + ' iterations)'));
}
//            red, green, yellow, blue, magenta, cyan
var colors = {r:'1;31',g:'1;32',y:'1;33',b:'1;34',m:'1;35',c:'1;36'}
  , colorSeqNext = 0
  , colorSeq = Object.keys(colors)
  , color;
if (process.stdout.isTTY) {
  color = function(c, s) {
    if (s === undefined) {
      s = c;
      c = colors[colorSeq[colorSeqNext++ % colorSeq.length]];
    } else if (c in colors) {
      c = colors[c];
    }
    return '\x1b['+c+'m' + s + '\x1b[0;39m';
  };
} else {
  color = function(c, s) { return s || c; };
}

var srcLineAt = function(source, p) {
  var top, lineno = 1, start = p, end = p;
  while (source[--start] !== '\n' && start !== -1) {}
  top = start;
  while (top !== -1) {
    if (source[top--] === '\n') {
      ++lineno;
    }
  }
  while (end < source.length) {
    if (source[end++] === '\n') {
      --end;
      break;
    }
  }
  if (end > source.length) {
    end = source.length;
  }
  return {
    offs:    p,
    endoffs: end,
    source:  source.substring(start+1, end),
    line:    lineno,
    column:  p - start,
  }
}

function fmtsrcline(source, p, label, noCaret) {
  var nsp = function(n) {
    var s, sp = '                                          ';
    if (n <= sp.length) {
      return sp.substr(0, n);
    } else {
      s = '';
      while (n--) { s += ' ' }
      return s;
    }
  }
  var padL = function(n, s) {
    var s = String(s);
    return nsp(n-s.length) + s;
  }
  var caret = function(column, label) {
    var s = '^';
    if (label) { s += ' ' + label; }
    for (var n = column; --n;) { s = ' ' + s }
    return color('m', s);
  }
  var margin = 7;
  var m = srcLineAt(source, p), ch, endmark;
  if (label) {
    ch = m.source[m.column-1];
    endmark = (m.endoffs >= source.length ? '<EOF>' : '\\n');
    m.source = m.source.substr(0,m.column-1) +
               color('44;1;37', ch || endmark) +
               (m.source.substr(m.column) || (ch ? endmark : ''));
  }
  var s = color('90', padL(margin, m.line + ' | ')) + m.source;
  if (!noCaret) {
    s += '\n' + nsp(margin) + caret(m.column, (label ? (label + ': ' + color('g',m.offs)) : null));
  }
  return s;
}

function assert_fail() {
  var e = new Error();
  e.name = color('r','AssertionError');
  var stack = e.stack.split(/\n/);
  var m = stack[3].match(/\(([^:]+):(\d+):(\d+)\)$/);
  if (m) {
    stack[0] += ' at ' + require('path').basename(m[1]) + ':' + m[2] + ':' + m[3];
    try {
      var line = require('fs').readFileSync(m[1], 'utf8').split(/\n/)[parseInt(m[2])-1];
      stack[1] = color('90', m[2] + ' | ') + line;
      e.stack = stack.slice(0,2).join('\n');
      // require('util').inspect(m) + e.stack;
    } catch (_) { console.error('_', _) }
  }
  console.error(String(e.stack || e));
  process.exit(4);
}
function assert(x) {
  if (!x) {
    assert_fail();
  }
}

Map.prototype.inspect = function(depth, ctx) {
  // console.log(depth, ctx);
  var s = (ctx.colors ? color('m','Map{') : 'Map{');
  var pre = '                                                              '.substr(0,depth);
  pre = '\n' + pre;
  ++ctx.depth;
  for (var e of this) { s += pre + repr(e[0]) + ' -> ' + inspect(e[1],ctx); }
  --ctx.depth;
  if (s !== 'Map{') {
    s += ' ';
  }
  return s+(ctx.colors ? color('m','}') : '}');
}

function fmtcallstack(offs, len, glue, lineprefix) {
  if (!offs) { offs = 2 } else { offs += 2; } // skip this callsite and first "message" line
  if (!len || len < 0) { len = 9000; }
  if (!lineprefix) { lineprefix = '  '; }
  return (new Error).stack.split(/\n/).slice(offs, offs+len).map(function(line, i) {
    var isself, filename, lineno = -1, builtin;
    line = lineprefix + line.trim().replace(/\(([^\)]+):(\d+):(\d+)\)$/, function (s, $1, $2, $3) {
      isself = ($1 === __filename);
      filename = $1;
      builtin = !isself && (!filename || filename.indexOf('/') === -1);
      lineno = parseInt($2);
      if ($1.indexOf(__dirname) === 0) { $1 = $1.substr(__dirname.length+1); }
      if (isself) { $1 = color('37',$1); } else { $1 = color('90',$1); }
      return color('90', '(') + $1 + color('90', ':' + $2 + ':' + $3 + ')');
    }).replace(/(at\s+)(.+)\.([^\.]+)(\s)/, function(m, $1, $2, $3, $4) {
      return 'at ' + color('1;37', $2) + '.' + color(isself ? 'g':builtin?'y':'c', $3) + $4;
    }).replace(/(at\s+)([^\.]+)(\s)/, function(m, $1, $2, $3) {
      return 'at ' + color(isself ? 'g':builtin?'y':'c', $2) + $3;
    });
    if (filename && filename.indexOf('/') !== -1) {
      try {
        line += '\n  ' + lineprefix + 
            color('90', require('fs').readFileSync(filename,'utf8').split(/\n/)[lineno-1].trim());
      } catch (e) {}
    }
    return line;
  }).join(glue || '\n');
}

time('imports');
var babel = require('babel-core');
var fs = require('fs');
var inspect = require('util').inspect;
// var sweet = require('sweet.js');
time.end();

function repr(obj, depth, colors) {
  return inspect(obj, {depth:depth===undefined?4:depth, colors:colors===undefined?true:colors});
}
function fmtit(it) {
  var s;
  for (var v of it) {
    s = (s ? s + ', ' : '') + repr(v);
  }
  return s;
}

time('readfile');
var srcCode = fs.readFileSync('./lab-babel-sweet-sample.js', 'utf8');
time.end();


var res;

var babylon = babel.babylon || babel.acorn;
var tokTypes = babylon.tokTypes;


// var types = [tokTypes.name, tokTypes.at, tokTypes.num];
// var values = [['a','b','c','d'], null, [1,2,3,4] ];
// var iterations = 10000;
// var objectMap;
//
// timeavg('Object build', iterations, function() {
//   var m = {};
//   for (var i = 0; i !== types.length; ++i) {
//     var t = types[i];
//     var v = values[i];
//     var t_om = m[t.label];
//     if (t===tokTypes.name||t===tokTypes.regexp||t===tokTypes.string||t===tokTypes.num) {
//       if (!t_om) {
//         m[t.label] = t_om = {};
//       }
//       for (var x in v) {
//         t_om[v[x]] = true;
//       }
//     } else {
//       m[t.label] = true;
//     }
//   }
//   objectMap = m;
// });
//
// console.log('objectMap:', repr(objectMap))
//
// var mapMap;
// timeavg('Map build', iterations, function() {
//   var m = new Map;
//   for (var i = 0; i !== types.length; ++i) {
//     var t = types[i];
//     var v = values[i];
//     var tm = m.get(t);
//     if (t===tokTypes.name||t===tokTypes.regexp||t===tokTypes.string||t===tokTypes.num) {
//       if (!tm) {
//         m.set(t, tm = new Map);
//       }
//       for (var x in v) {
//         tm.set(v[x], true);
//       }
//     } else {
//       m.set(t, true);
//     }
//   }
//   mapMap = m;
// });
//
// console.log('mapMap:', repr(mapMap))
// return;


function MacroContext() {
  this._defScope = [null, null];
  this._evalSet = null; // Set<Macro> containing all macros currently being expand-eval'd
}
MacroContext.prototype.pushMacroDefScope = function() {
  this._defScope = [this._defScope, null];
}
MacroContext.prototype.popMacroDefScope = function() {
  this._defScope = this._defScope[0];
}

MacroContext.prototype.defineMacro = function(m) {
  // TODO: use a b-tree or trie instead of this hard-coded one-step-deep setup
  var typeMap = this._defScope[1];
  if (!typeMap) {
    typeMap = this._defScope[1] = new Map;
  }
  assert(m.pattern.tokens.length > 0);
  var tok0 = m.pattern.tokens[0];
  // console.log('defineMacro tok0:', fmttok(tok0))
  var t = tok0.type; //:BabylonTokenType
  var node = typeMap.get(t);
  var prev;
  if (t===tokTypes.name || t===tokTypes.regexp || t===tokTypes.string || t===tokTypes.num) {
    // identified by type + value
    if (!node) {
      typeMap.set(t, node = new Map);
      node.set(tok0.value, m);
    } else {
      prev = node.get(tok0.value);
      node.set(tok0.value, m);
    }
  } else {
    if (node) {
      prev = node;
    }
    typeMap.set(t, m);
  }
  return prev;
}

MacroContext.prototype.getMacro = function(type, value) {
  var t = type
    , m
    , scope = this._defScope
    ;
  if (t===tokTypes.name || t===tokTypes.regexp || t===tokTypes.string || t===tokTypes.num) {
    while (1) {
      if ((m = scope[1]) && (m = m.get(t)) && (m = m.get(value))) {
        return m;
      }
      if (!(scope = scope[0])) {
        return null;
      }
    }
  } else {
    while (1) {
      if ((m = scope[1]) && (m = m.get(t))) {
        return m;
      }
      if (!(scope = scope[0])) {
        return null;
      }
    }
  }
}

MacroContext.prototype.isTopLevel = function() {
  return !this._defScope[0];
}

// console.log(babel.types); return;
// console.log(Object.keys(tokTypes).sort().map(function(k) {
//   return k + ':\t' + inspect(tokTypes[k],{depth:9});
// }).join('\n')); return;
// var babylonTypes = require('babel-core/node_modules/babylon/lib/tokenizer/types');
// console.log(babylonTypes.keywords);
// babylonTypes.keywords['macro'] = tokTypes.macro;


var ccDollar = '$'.charCodeAt(0);
var ccGreaterThan = '>'.charCodeAt(0);

var TokenVarTag = Symbol('MacroTokenVarTag');
var TokenVar1 = Symbol('MacroTokenVar1'); // $x
var TokenVarN = Symbol('MacroTokenVarN'); // ...$x
var MatchingToken = Symbol('MatchingToken');
var MemoizedResult = Symbol('MemoizedResult');

var Empty = Symbol('Empty');
var Pattern = Symbol('Pattern');
var Body = Symbol('Body');

function dumpPState(s) {
  var prevtokz = 10;
  console.log('  previous tokens: '+(s.tokens.length > prevtokz ? '... ':'') +
              s.tokens.slice(Math.max(0,s.tokens.length-prevtokz)).map(fmttok).join(' '))
  console.log('  next token: '+fmttok(s))
  console.log(fmtsrcline(s.input, s.start, 's.start'))
  console.log(fmtsrcline(s.input, s.end, 's.end'))
  console.log(fmtsrcline(s.input, s.pos, 's.pos'))
}

function fmttok(t) {
  var tl;
  if (t.type.label) {
    tl = color('y', t.type.label[0].match(/[A-Za-z$]/) ? t.type.label : inspect(t.type.label));
  } else {
    tl = color('b', inspect(t.type));
  }
  return '('+tl + (
    t.value === undefined ? '' :
    ' ' + (
      t[TokenVarTag] ? (t[TokenVarTag] === TokenVarN ? color('90','...') : '') +
        color('b',t.value) :
      repr(t.value)
    )
  ) +')';
}

function fmttoks(tokens) {
  return tokens.map(fmttok).join(', ');
}

// fmtmacropat(p:MacroPattern, behaviour?:Pattern|Body, style?:Function):string
function fmtmacropat(p, behaviour, style) {
  var source = '', toks = p.tokens;
  if (style === undefined) { style = color; } else if (!style){style=function(a,b){return b||a}}
  if (toks.length > 0) {
    source = toks.map(function(t) {
      if (t.value !== undefined) {
        return (
          t[TokenVarTag] ? (
            t[TokenVarTag] === TokenVarN ? style('90','...') : ''
          ) + style('b', t.value) :
          style('g',t.value)
        );
      }
      return t.type.label;
    }).join(' ');
  }
  return source ? style('90','{ ') + style(source) + style('90',' }') : style('90','{}');
}

// fmtmacro(m:MacroDef, style?:Function):string
function fmtmacro(m, style) {
  if (style === undefined) { style = color; } else if (!style){style=function(a,b){return b||a}}
  return fmtmacropat(m.pattern, Pattern, style) +
         style('y',' -> ') + fmtmacropat(m.body, Body, style);
}

function tokeq(t1, t2) {
  return (
    t1.type === t2.type &&
    t1.value === t2.value
  );
}


function MacroParserPlugin(pp) {

  function copytok(t) {
    return {
      type:  t.type,
      value: t.value,
      start: t.start,
      end:   t.end,
      loc:   { start: t.startLoc, end: t.endLoc },
    }
  }

  function rewindPState(s) {
    //
  }

  if (!pp.pushDiagnostic) {
    pp.pushDiagnostic = function(type, pos, message, endPos) {
      var lineBreakG = /\r\n?|\n|\u2028|\u2029/g;
      function getLineInfo(input, offset) {
        for (var line = 1, cur = 0;;) {
          lineBreakG.lastIndex = cur;
          var match = lineBreakG.exec(input);
          if (match && match.index < offset) {
            ++line;
            cur = match.index + match[0].length;
          } else {
            return { line: line, column: offset - cur };
          }
        }
      };
      var loc = getLineInfo(this.input, pos);
      var diag = {
        type: type,
        message: message + " (" + loc.line + ":" + loc.column + ")",
        pos: pos,
        loc: loc,
        endPos: endPos,
      };
      if (!this.state.diagnostics) {
        this.state.diagnostics = [diag];
      } else {
        this.state.diagnostics.push(diag);
      }
    };
  }

  pp.extend("parseTopLevel", function(inner) {
    return function(file, program) {
      this.macroCtx = new MacroContext();
      this.state.diagnostics = null; // Diagnostic[]
      enableMacroExpansionHook();
      var r = inner.apply(this, arguments);
      disableMacroExpansionHook();
      //console.log('after parseTopLevel: macros:', repr(this.macroCtx._defScope, 1))
      file.macros = this.macroCtx._defScope[1]; //Map|null
      file.diagnostics = this.state.diagnostics;
      return r;
    }
  });

  pp.extend("parseBlock", function(inner) {
    return function (allowStrict) {
      // console.log('before parseBlock')
      this.macroCtx.pushMacroDefScope();
      var r = inner.apply(this, arguments);
      this.macroCtx.popMacroDefScope();
      // console.log('after parseBlock',
      //             'macroCtx._defScope:',Object.keys(this.macroCtx._defScope[1]))
      return r;
    }
  });

  pp.extend("parseStatement", function(inner) {
    return function() {
      if (this.state.type === tokTypes.name && this.state.value === "macro") {
        disableMacroExpansionHook();
        var m = this.startNode();
        this.nextToken(); // read next token and ignore "macro"
        var noopNode = this.parseMacroDefinition(m);
        enableMacroExpansionHook();
        return noopNode;
      }
      if (macroExpansionHookCounter > 0) {
        // We look to expand any macro here because the parser does not call nextToken
        // when parsing the top-level (program). See parseTopLevel in babylon/parser/statements.js
        console.log('@ PS call maybeExpandMacro')
        this.maybeExpandMacro();
      }
      return inner.apply(this, arguments);
    };
  });


  // function getCommentsAbove(s) {
  //   var t
  //     , index = s.tokens.length
  //     , comments = []
  //     , line = s.curLine
  //     ;
  //   while (index !== 0) {
  //     t = s.tokens[--index];
  //     if (t.type !== 'CommentLine') {
  //       break;
  //     }
  //     if (t.loc.end.line !== --line) {
  //       // comment is more than one line away. E.g.
  //       //  //foo <--
  //       // 
  //       //  //bar
  //       //  //baz
  //       break;
  //     }
  //     comments.push(t);
  //   }
  //   comments.reverse();
  //   return comments;
  // }


  pp.parseMacroTokens1 = function(behaviour, patternVars) {
    var depth
      , open
      , close
      , s = this.state
      , vars = null  // Map<string,Token>
      , startPos = s.start
      , openFirst = false
      , tokenStartIndex = s.tokens.length
      , tokenStartIndex1 = tokenStartIndex+1
      , needsNewToken = true
      , readToken = this.next.bind(this)
      , nextToken = readToken
      , skipToken = function(){ nextToken = readToken; }
      , parseMacroVar
      ;

    // var readToken2 = readToken;
    // readToken = function() { g_dbg_pstate = s.clone(); readToken2(); }

    parseMacroVar = function() {
      // enters with guarantee: s.value[0] === '$'

      // TODO: in body pattern, allow advanced spread of variables, like:
      //   macro { foo ...$a } -> { <... .bar($a)> }
      //   macro { list ...$a } -> { [<...$a,>] }
      //   foo 1 2 3
      //   list 1 2 3
      // result:
      //   .bar(1).bar(2).bar(3)
      //   [1,2,3]

      // TODO: Allow advanced rest var definitions:
      //   macro { foo(<...$a,>) } -> { <... .bar($a)> }
      //   foo(1,2,3)
      // result:
      //   .bar(1).bar(2).bar(3)
      //

      // TODO: Allow token type-tags in variable definitions:
      //   macro { str $a<:number> } -> { ($a).toString(16) }
      //   macro { str $a<:string> } -> { $a }
      //   macro { str $a } -> { String($a) }
      //   str 23
      //   str "23"
      //   str [2,3]
      // result:
      //   (23).toString(16)
      //   "23"
      //   String([2,3])
      //

      console.log('parseMacroVar s.value='+repr(s.value));
      if (s.value.charCodeAt(1) === ccDollar) {
        // Escaped dollar-sign match
        // E.g. $$x -> {value:"$x", type:name}
        console.log('parseMacroVar rewrite '+repr(s.value)+' to '+repr(s.value.substr(1)));
        s.value = s.value.substr(1);
        return;
      }
      // Macro variable
      // E.g. $x -> {value:"$x", type:name, [TokenVarTag]:TokenVar1|TokenVarN}
      var t, index = s.tokens.length;
      if (behaviour === Pattern) {
        if (vars) {
          if (vars.has(s.value)) {
            this.raise(s.start, 'Duplicate identifier "'+s.value+'" in macro pattern');
          }
        } else {
          vars = new Map;
        }
        nextToken(); nextToken = skipToken;
        t = s.tokens[index];
        if (index !== tokenStartIndex &&
            s.tokens[index-1].type === tokTypes.ellipsis) //< unreliable: ".../*comment*/$a"
        {
          // E.g. ...$x -> {value:"$x", type:name, [TokenVarTag]:TokenVarN}
          t[TokenVarTag] = TokenVarN;
          // Eat previous "..."
          s.tokens.splice(index-1, 1);
        } else {
          // E.g. $x -> {value:"$x", type:name, [TokenVarTag]:TokenVar1}
          t[TokenVarTag] = TokenVar1;
        }
        vars.set(t.value, t);
        //console.log('vars set t', t.value, vars)

      } else { // (behaviour === Body)
        //console.log('parseMacroVar lookup s.value='+repr(s.value));
        var ptok = patternVars.get(s.value)
        if (ptok) {
          nextToken(); nextToken = skipToken;
          t = s.tokens[index];
          ptok[MatchingToken] = t;
          t[TokenVarTag] = TokenVar1;
          // t._MatchingToken = ptok; t._TokenVarTag = 'TokenVar1'; // debug
        }
      }
    }

    // find open & close token types, or parse single token
    console.log('1st:', fmttok(s));
    switch (s.type) {
      case tokTypes.bracketL:     close = tokTypes.bracketR; break;
      case tokTypes.braceL:
      case tokTypes.dollarBraceL: close = tokTypes.braceR; break
      case tokTypes.parenL:       close = tokTypes.parenR; break;
      case tokTypes.eof: {
        if (behaviour === Pattern) {
          this.raise(startPos, 'Missing "->" in macro definition')
        } else {
          this.raise(startPos, 'Missing macro body')
        }
        break;
      }
      case tokTypes.name: if (s.value.charCodeAt(0) === ccDollar) { parseMacroVar(); } break;
    }

    if (close) {
      open = s.type;
      openFirst = true; // I.e. first token is a grouping "open+close"

    } else {
      nextToken();
      // Previous token was not open -- maybe the next is?
      console.log('2nd:', fmttok(s));
      switch (s.type) {
        case tokTypes.bracketL:     open = s.type; close = tokTypes.bracketR; break;
        case tokTypes.braceL:
        case tokTypes.dollarBraceL: open = s.type; close = tokTypes.braceR; break
        case tokTypes.parenL:       open = s.type; close = tokTypes.parenR; break;
        case tokTypes.eof:          if (behaviour === Pattern) { this.unexpected(); } break;
      }
      if (!close) {
        console.log('exit with single token');
      }
    }

    if (close) {
      nextToken();
      depth = 1;
      loop2: while (1) {
        console.log('nth:', fmttok(s));
        switch (s.type) {
          case open: ++depth; break;
          case close: {
            if (--depth === 0) {
              if (openFirst && close === tokTypes.braceR) {
                // The first token was "{" -- i.e. the pattern style is "{...}"
                // eat and ignore the current token:
                this.nextToken();
                // remove the first token "{":
                s.tokens.splice(tokenStartIndex,1)
              } else {
                // parse and include the current token
                var tokindex = s.tokens.length;
                nextToken();
                console.log('tokindex: ['+tokindex+','+s.tokens.length+']')
              }
              break loop2;
            }
            break;
          }
          case tokTypes.name: if (s.value.charCodeAt(0) === ccDollar) { parseMacroVar(); } break;
          case tokTypes.eof: {
            if (behaviour === Pattern) {
              this.raise(startPos, 'Missing terminating "'+close.label+'" in macro pattern')
            } // else behaviour === Body: valid to have a macro be the last thing of input
            break loop2;
          }
        }
        nextToken();
      }
    }

    console.log('exit at:');
    dumpPState(s);

    return {
      tokens: s.tokens.splice(tokenStartIndex), // move tokens from s
      vars:   vars,
    };
  }


  pp.parseMacroDefinition = function(m /*:Node*/) {
    // MacroDefinition := "macro" <space>+ macroPattern "->" macroBody
    //
    // macroPattern    := "{" Token macroExprToken* "}"
    //                  | <macroExprToken where first must be Token>
    //
    // macroBody       := "{" macroExprToken* "}"
    //                  | macroExprToken
    //
    // macroExprToken  := "(" macroExprToken ")"
    //                  | "{" macroExprToken "}"
    //                  | "${" macroExprToken "}"
    //                  | "[" macroExprToken "]"
    //                  | macroToken
    // macroToken      := (macroVar | Token)
    // macroVar        := "..."? "$" <any Identifier except "$">?
    //
    // E.g.
    //   macro x -> { y }      # 'x()' -> 'y()'
    //   macro {x} -> { y }    # 'x()' -> 'y()'
    //   macro x -> y()        # 'x()' -> 'y()()'
    //   macro x -> {}         # 'x()' -> '()'
    //   macro {x} -> {}       # 'x' -> '()'
    //   macro \u007B -> { y \u007B } # '}' -> 'y }'
    //   macro {x 1} -> {y} # 'x 1' -> 'y'
    //   macro {x $} -> {y} # 'x 123' -> 'y'

    var p = this;
    var n = p.startNode(); // noop node that will be returned in-place of the macro
    var s = p.state;

    // Ignore comments while parsing macro
    var orig_pushComment = p.pushComment;
    p.pushComment = function(){};

    try {
      // macroPattern
      m.pattern = p.parseMacroTokens1(Pattern);
      console.log('m.pattern' +
                  '\n  .tokens: ' + fmttoks(m.pattern.tokens) +
                  '\n  .vars:   '+(m.pattern.vars ? '{' + fmtit(m.pattern.vars.keys())+'}' : '-'));

      // "=>"
      // if (s.type === tokTypes.arrow) {
      //   p.nextToken(); // advance to next token w/o remembering "=>"
      // } else {
      //   p.raise(s.start, 'Unexpected token (expected "=>")');
      // }

      // "->"
      if (s.type === tokTypes.plusMin && s.input.charCodeAt(s.pos) === ccGreaterThan) {
        s.start = s.pos; ++s.pos; s.type = tokTypes.relational; // p.nextToken();
        p.nextToken();
      } else {
        p.raise(s.start, 'Unexpected token (expected "->")');
      }

      // macroBody
      m.body = p.parseMacroTokens1(Body, m.pattern.vars);
      console.log('m.body' +
                  '\n  .tokens: ' + fmttoks(m.body.tokens))
    } finally {
      p.pushComment = orig_pushComment;
    }

    // optional ;
    if (s.type === tokTypes.semi) {
      p.nextToken();
    }

    // Finish our noop node before the macro node so that trailing comments remain with the AST
    p.finishNode(n, "Noop");
    p.finishNode(m, "MacroDefinition");
    n.leadingComments = m.leadingComments;
    n.trailingComments = m.trailingComments;

    // Add comment to replacement node
    var raw = p.input.substring(m.start, m.end);
    var comment = {
      type: raw.indexOf('\n') !== -1 ? "CommentBlock" : "CommentLine",
      value: raw,
      start: m.start,
      end: m.end,
      loc: {start: m.loc.start, end: m.loc.end},
      range: [m.start, m.end],
    };
    if (n.leadingComments) {
      n.leadingComments.push(comment);
    } else if (n.trailingComments) {
      n.trailingComments.unshift(comment);
    } else {
      n.leadingComments = [comment];
    }

    // Register macro
    var prevMacro = p.macroCtx.defineMacro(m);
    if (prevMacro) {
      // Would fail here if we want:
      // p.raise(p.state.start, 'Duplicate macro definition "'+m.id.name+'"');
      p.pushDiagnostic('warn', m.start, 'Macro '+fmtmacro(m,false)+' redefined', m.end);
    }

    console.log('macrodef:', fmtmacro(m));
    //process.exit(1);

    // Assign empty body to noop block statement
    n.body = [];

    // We just performed nextToken to advance to the token that follows the macro def, but the
    // macro-expansion hook is disabled while matching macros.
    if (tokeq(s, m.pattern.tokens[0])) {
      console.log('possible immediate expansion after definition')
    }

    return n;
  };


  var MISMATCH = Symbol('MISMATCH');

  //
  // opts:
  //   m: MacroDefinition
  //   token: Token { type: BabylonTokenType, value: String|null }
  //   persistToken(t:Token) -> Token
  //   nextToken() -> Token
  //   error(message:String)
  //   createSnapshot?() -> Snapshot
  //   restoreSnapshot?(Snapshot)
  //   
  function matchMacroPattern(opts) {
    // pass:   1   2   3   4
    // mtoks: foo  [   $a  ]
    // stoks: foo  [   1   ]

    var m = opts.m;
    var stok = opts.token;

    function consumeSToks(mtokTerm, isRest, rewindLast) {
      var depth = 0;
      var termType = mtokTerm ? mtokTerm.type : tokTypes.semi;
      var t, tokens = null; // Token[];
      var snapshot;
      console.log('consumeSToks: termType:', repr(termType.label))

      loop: while (true) {
        console.log('  consumeSToks stok:', fmttok(stok))

        switch (stok.type) {
          case termType: {
            if (depth === 0) {
              break loop;
            }
            // fallthrough
          }
          case tokTypes.bracketL:
          case tokTypes.braceL:
          case tokTypes.dollarBraceL:
          case tokTypes.parenL: {
            // TODO: support flow generics, eg. "Set<Map<int,string>>"
            ++depth;
            break;
          }
          case tokTypes.bracketR:
          case tokTypes.braceR:
          case tokTypes.parenR: {
            if (depth === 0 && isRest && termType === tokTypes.semi) {
              // E.g.
              //   macro foo { ...$b } -> {}
              //   (foo 1 2 3)
              //             ^
              break loop;
            }
            --depth;
            break;
          }
          case tokTypes.eof: {
            if (!isRest) {
              opts.error('Unterminated macro match');
            }
            // Rest ended at EOF -- validation happens by receiver of return value
            // if (!tokens) { tokens = []; } tokens[HasEOF] = true;
            break loop;
          }
        }
        
        t = opts.persistToken(stok);
        if (!tokens) { tokens = [t]; } else { tokens.push(t); }

        if (depth === 0 && !isRest) {
          // Not a "..." and at the root -- we have taken exactly one stok
          break;
        }

        if (rewindLast) {
          // We have been asked to rewind the last token we parse. To do that, we need to
          // take a snapshot of the state before advancing to the next token.
          snapshot = opts.createSnapshot();
        }

        stok = opts.nextToken();
      }

      if (rewindLast && snapshot) {
        // We have been asked to rewind (or undo) the last token
        assert(snapshot);
        opts.restoreSnapshot(snapshot);
      }

      return tokens;
    }


    var i = 0, L = m.pattern.tokens.length
      , mtok
      , mtokTerm
      , stoks
      , subs = null // Map<Token,Token[]> var substitutions
      , skipNextToken = false
      , varTag
      , bodyToken
      ;
    for (; i !== L; ++i) {
      mtok = m.pattern.tokens[i];
      console.log('mtok:', fmttok(mtok) + ', stok:', fmttok(stok))

      if (varTag = mtok[TokenVarTag]) {
        // Read source tokens and associate them with the variable
        mtokTerm = m.pattern.tokens[i+1];
        stoks = consumeSToks(
          mtokTerm,
          varTag === TokenVarN,
          /*rewindLast=*/ opts.createSnapshot && mtok.isRest && i === L-1
        );
        if (varTag === TokenVarN) {
          // Because "...$" consumes a terminating token, so it's already queued up
          // at this point.
          skipNextToken = true;
        } else if (!stoks) {
          return MISMATCH;
        }
        console.log('x mtok:', fmttok(mtok))
        if (bodyToken = mtok[MatchingToken]) {
          // Does appear in body -- associate so it can later be expanded
          if (!subs) { subs = new Map }
          subs.set(bodyToken, stoks || Empty);
            // `Empty` means that bodyToken is replaced by nothing, E.g.
            //    macro A(...$) -> a($); A() => a()
        }
        console.log(fmttok(mtok)+' -> [' + (!stoks ? '' : stoks.map(fmttok).join(', ')) + ']');
      } else {
        // match tokens
        if (!tokeq(mtok, stok)) {
          console.log('MISMATCH', fmttok(mtok), '!==', fmttok(stok))
          return MISMATCH;
        }
      }

      if (skipNextToken) {
        skipNextToken = false;
      } else if (i < L-1) {
        stok = opts.nextToken();
      }

    }

    return subs;
  }


  pp.expandMacro = function(m, toks, cont) {
    var p = this;
    var s = p.state;
    var toksIndex = 0;
    var endAfterFinishNode = false;
    var orig_nextToken = p.nextToken;
    var pstateAfterMacroMatch = s.clone();
    console.log('+++++++++++++++++++++++++++ begin expand +++++++++++++++++++++++++++');
    // console.log(fmtcallstack());


    p.nextToken = function expandMacro$nextToken() {
      console.log('EXP next');
      // console.log(fmtcallstack());

      var t = toks[toksIndex++];
      if (!t) {
        console.log('EXP end');
        p.state = pstateAfterMacroMatch;
        // console.log('EXP s at end:'); dumpPState(p.state);
        console.log('+++++++++++++++++++++++++++ end expand +++++++++++++++++++++++++++');
        var r = (p.nextToken = orig_nextToken).call(p);
        cont(true);
        return r;
      }

      s.end             = t.end;
      s.start           = t.start;
      s.startLoc        = { line: t.loc.start.line, column: t.loc.start.column };
      s.pos             = t.end;
      s.type            = t.type;
      s.value           = t.value;

      console.log('EXP t: '+fmttok(t))
      console.log('EXP s: '+fmttok(s))
      // console.log('EXP s when leaving next:'); dumpPState(s);
    }

    p.nextToken();
  }


  pp.reportMacroMatchAttempt = function(m, startPos, endPos) {
    this.pushDiagnostic(
      'info',
      startPos === undefined ? this.state.start : startPos,
      'Attempted to expand macro '+fmtmacropat(m.pattern, Pattern, false),
      endPos
    );
    console.log(this.state.diagnostics[this.state.diagnostics.length-1].message);
  }


  pp.maybeMatchMacroPattern = function(m) {
    var p = this;
    console.log('- - - - - - - - - - - begin match - - - - - - - - - - -')
    dumpPState(p.state);

    var subs = null;
    if (m.pattern) {
      // State:
      //  macro bar {$a $b} -> { ($a, $b) }
      //  foo bar 3 4 5
      //         ^-- state.pos
      //      ^----- state.start
      //
      var pStateBeforeMatch = p.state.clone();
      subs = matchMacroPattern({
        m:               m,
        token:           p.state,
        persistToken:    copytok,
        error:           function(msg) { p.raise(p.state.start, msg) },
        nextToken:       function() { p.nextToken(); return p.state; },
        createSnapshot:  p.state.clone.bind(p.state),
        restoreSnapshot: function(snapshot) { p.state = snapshot; },
      });
      if (subs === MISMATCH) {
        // didn't match -- restore state
        var endPos = p.state.end;
        p.state = pStateBeforeMatch;
        p.reportMacroMatchAttempt(m, p.state.start, endPos)
        console.log('- - - - - - - - - - - end match nomatch - - - - - - - - - - -')
        return MISMATCH;
      }

      // Note: match might have replaced p.state at this point

      dumpPState(p.state);
      console.log('- - - - - - - - - - - end match subs - - - - - - - - - - -')
      // State:
      //  macro bar {$a $b} -> { ($a, $b) }
      //  foo bar 3 4 5
      //             ^-- state.pos
      //            ^--- state.start
      //
    } else {
      dumpPState(p.state);
      console.log('- - - - - - - - - - - end match simple - - - - - - - - - - -')
      // Simple substitution macro w/o match
      // State:
      //  macro bar { 1 }
      //  foo bar 3 4 5
      //         ^-- state.pos
      //      ^----- state.start
      //
    }

    return subs;
  }


  function maybeExpandInnerMacro(macroCtx, p, m, parentM, stoks) {
    if (macroCtx._evalSet) {
      if (macroCtx._evalSet.has(parentM)) {
        s = [];
        for (v of macroCtx._evalSet) { s.push(v); }
        s.push(parentM);
        s = s.map(function(m){ return fmtmacro(m, false) });
        p.raise(
          p.state.start,
          'Cyclic macro expansion ' + s.join('  -->  ')
        );
      } else {
        macroCtx._evalSet.add(parentM);
      }
    } else {
      macroCtx._evalSet = new Set([parentM])
    }

    var matchSource
      , subs
      , numToksConsumed = 1
      ;
    if (m.pattern.tokens.length > 1) {
      // Note: If the number of tokens in macro pattern is just 1, then we have already
      // matched that token (before this function was called.) So we only perform a full
      // match for len>1.
      // In the future if/when we support patterns with variables as the first token,
      // the condition should include a check for if the one and only token is a variable,
      // as it will be in need of substitution. E.g.
      //    if (m.pattern.tokens.length > 1 || TokenVarTag in m.pattern.tokens[0])
      matchSource = {
        m:               m,
        token:           stoks[0],
        _tokenIndex:     0,
        persistToken:    function(t) { return t },
        error:           function(msg) { p.raise(stoks[++this._tokenIndex].start, msg) },
        nextToken:       function() { return stoks[++this._tokenIndex] },
      };
      subs = matchMacroPattern(matchSource);
      if (subs === MISMATCH) {
        p.reportMacroMatchAttempt(m, stoks[0].start)
        return false;
      }
      numToksConsumed += matchSource._tokenIndex;
    }

    var toks = evalMacro(macroCtx, p, m, subs);
    console.log('EIM evalMacro ->', toks.map(fmttok).join(', '))
    macroCtx._evalSet.delete(parentM);
    return [0, numToksConsumed].concat(toks); // suitable for applying on Array.splice
  }


  function evalMacro(macroCtx, p, m, subs, scopeSet) {
    // Note: This function is not recrusive itself, but relies on maybeExpandInnerMacro
    // for cyclic expansion checks. I.e. we can't call evalMacro directly from evalMacro.

    // memozied?
    var memoized = m[MemoizedResult];
    if (memoized) {
      return memoized;
    }

    // expand substitutions
    var toks;
    if (subs) {
      toks = [];
      m.body.tokens.forEach(function(etok) {
        var subToks = subs.get(etok);
        if (subToks) {
          // Empty means that etok is replaced by nothing, otherwise we have substitutes:
          if (subToks !== Empty) {
            assert(Array.isArray(subToks));
            toks = toks.concat(subToks);
          }
        } else {
          // Verbatim
          toks.push(etok);
        }
      })
    } else {
      // No variables
      toks = m.body.tokens;
    }

    // match & expand inner macros
    var i = 0, L = toks.length, m2, t, r;
    for (; i !== L; ++i) {
      t = toks[i];
      if (m2 = macroCtx.getMacro(t.type, t.value)) {
        if (r = maybeExpandInnerMacro(macroCtx, p, m2, m, toks)) {
          r[0] = i; // splice start index = first token replaced
          toks.splice.apply(toks, r);
          i += r[1]-1; // number-of-tokens consumed by maybeExpandInnerMacro
        }
      }
    }

    if (!subs) {
      // memoize pure macro
      m[MemoizedResult] = toks;
    }

    return toks;
  }


  pp.maybeExpandMacro = function() {
    console.log('maybeExpandMacro')
    var m = this.macroCtx.getMacro(this.state.type, this.state.value);
    if (!m) {
      return;
    }

    disableMacroExpansionHook();
    var finalize = enableMacroExpansionHook;

    // attempt match
    var subs = this.maybeMatchMacroPattern(m);
    if (subs === MISMATCH) {
      return finalize();
    }

    // evaluate macro, returning the tokens which should replace the match
    //console.log('subs:', subs);
    var toks = evalMacro(this.macroCtx, this, m, subs);
    console.log('expanded toks:', toks.map(fmttok).join(', '))

    if (toks.length === 0) {
      // No replacement tokens
      // E.g. "macro { ... } -> {}"
      this.nextToken();
      finalize();
    } else {
      // produce `toks` for the parser
      this.expandMacro(m, toks, finalize);
    }
  };


  var orig_nextToken = pp.nextToken;
  var macroExpansionHookCounter = 0;
  var expandMacro$nextToken0 = function() {
    orig_nextToken.apply(this, arguments);
    this.maybeExpandMacro(); // HOTPATH
  };
  function enableMacroExpansionHook() {
    if (++macroExpansionHookCounter === 1) {
      console.log('macroExpansionHook:ENABLE ' + (new Error).stack.split(/\n/)[2].trim());
      pp.nextToken = expandMacro$nextToken0;
    } else console.log('macroExpansionHook:enable ' + (new Error).stack.split(/\n/)[2].trim());
  }
  function disableMacroExpansionHook() {
    if (--macroExpansionHookCounter === 0) {
      console.log('macroExpansionHook:DISABLE ' + (new Error).stack.split(/\n/)[2].trim());
      pp.nextToken = orig_nextToken;
    } else console.log('macroExpansionHook:disable ' + (new Error).stack.split(/\n/)[2].trim());
  }


  // var orig_finishToken = pp.finishToken;
  // var inMaybeExpand = false;
  // var expandMacro$finishToken = function() {
  //   console.log('finishToken', fmttok(this.state));
  //   orig_finishToken.apply(this, arguments);
  //   if (this.macroCtx && !inMaybeExpand) {
  //     console.log('macroCtx.getMacro', fmttok(this.state));
  //     var m = this.macroCtx.getMacro(this.state.type, this.state.value);
  //     if (m) {
  //       this.finishToken = orig_nextToken;
  //       console.log('call maybeExpandMacro')
  //       this.maybeExpandMacro(m, function(r) {
  //         console.log('expand cont', r)
  //         this.finishToken = expandMacro$finishToken;
  //       });
  //     }
  //   }
  // };
  // pp.finishToken = expandMacro$finishToken;


  // pp.extend("parseMaybeAssign", function(inner) {
  //   return function(noIn, refShorthandDefaultPos, afterLeftParse) {
  //     var m = this.macroCtx.getMacro(this.state.type, this.state.value);
  //     if (m) {
  //       this.maybeExpandMacro(m);
  //     }
  //     return inner.apply(this, arguments);
  //   };
  // });
}


var babylonParser = require('babel-core/node_modules/babylon/lib/parser');
babylonParser.plugins.macro = MacroParserPlugin;



function parse(code, options) {
  var opts = {
    allowImportExportEverywhere: false,
    allowReturnOutsideFunction:  false,
    allowHashBang:               true,
    ecmaVersion:                 Infinity,
    strictMode:                  false,
    sourceType:                  'module',
    locations:                   true,
    ranges:                      true,
    plugins: {
      jsx: true,
      flow: true,
      macro: true,
    },
    features: {},
  };
  var k;
  for (k in babel.pipeline.transformers) {
    opts.features[k] = true;
  }
  if (options) {
    for (k in options) {
      opts[k] = options[k];
    }
  }
  var file = babylon.parse(code, opts);
  return {
    ast: file.program,
    macros: file.macros,
    diagnostics: file.diagnostics,
  };
}

time('babel.parse');
try {
  res = parse(srcCode);
  time.end();
  if (res.diagnostics) {
    res.diagnostics.map(function(d) {
      console.warn(d.type+':', d.message);
    });
  }
  // res.ast.body[1].expression.object.innerComments = [];
  // console.log('babel.parse -> {res.ast.body[1].expression} =>',
  //   repr(res.ast.body[1].expression,4));
  // console.log('babel.parse =>', repr(res.ast,4));
} catch (err) {
  time.end();
  if (err instanceof SyntaxError && err.pos !== undefined && err.loc) {
    var line = srcCode.split('\n')[err.loc.line-1];
    var cur = '                                                  ^'.substr(-err.loc.column-1);
    console.error(err.message + '\n' + line + '\n' + cur +
                  err.stack.substr(err.stack.indexOf('\n')));
  } else {
    console.error(err.stack || String(err));
  }
  process.exit(1);
}


function codegen(ast, compact) {
  return babel.transform.fromAst(ast, null, {
    code:                true,     // output JavaScript code
    ast:                 false,    // output AST
    compact:             compact, // this.target.mode === TARGET_MODE_RELEASE, // "minify"
    comments:            !compact, //this.target.mode === TARGET_MODE_DEV,
    externalHelpers:     true,
    modules:             'ignore',
    experimental:        true,
    stage:               0, // 0=strawman 1=proposal 2=draft 3=candidate 4=finished. TODO config
    nonStandard:         true, // Enable support for JSX and Flow
    loose:               [],  // disallows import/exports beyond head and return at root

    // xxx
    filename:            'foo.js',
    inputSourceMap:      null,//inSourceMap,
    sourceMaps:          true,     // true|false|"inline" generate SourceMap
    sourceRoot:          '/src/foo',//srcfile.dir,

    // See http://babeljs.io/docs/advanced/transformers/
    blacklist: //this.target.disabledTransforms(
      [
      'es6.modules',
      'validation.react',
      'validation.undeclaredVariableCheck',
      'utility.inlineEnvironmentVariables', // we do this ourselves
      'reactCompat',
      'strict', // just puts `"use strict"` in every source
      'jscript',

      // target_nodejs
      'spec.protoToAssign', // x.__proto__ = y supported by v8, no need to shallow-copy
      'es6.spec.blockScoping', // supported by v8
      'es6.spec.symbols',      // supported by v8
      'regenerator',           // b/c yield is supported by v8
    ],

    optional: //this.target.transforms(
      [
      'es6.spec.blockScoping',
      'es6.spec.symbols',
      'es6.spec.templateLiterals',
      'react',
      'flow',

      // target_nodejs
      'asyncToGenerator',  // async/await on yield. Requires Node.js >0.11.2
    ],
  });
}


time('babel.transform.fromAst');
res = codegen(res.ast, /*compact=*/false);
time.end();

// console.log('metadata:', repr(code.metadata,3));
// console.log('map:', repr(code.map,3));
console.log('code:\n' + res.code);
// return


var A = require('assert');

// assertParses(expectedCode:string, sourceCode:string[]|string, parseOptions?:{})
function assertParses0(expectedCode, sourceCode, parseOptions) {
  if (Array.isArray(sourceCode)) {
    sourceCode = sourceCode.join('\n');
  }
  var ast        = parse(sourceCode, parseOptions).ast;
  var genCode    = codegen(ast, /*compact=*/true).code;
  A.equal(genCode.trim(), expectedCode.trim());
}

// assertParses(expectedCode:string, ...sourceCodes:string[]|string)
function assertParsesSame(expectedCode) {
  Array.prototype.slice.call(arguments,1).forEach(function(sourceCodes) {
    assertParses0(expectedCode, sourceCodes);
  });
}

// assertParses(expectedCode:string, ...sourceCodeLine:string, parseOptions?:{})
function assertParses(expectedCode) {
  var parseOptions = null, sourceCode;
  if (arguments.length > 2 && typeof arguments[arguments.length-1] === 'object') {
    parseOptions = arguments[arguments.length-1];
    sourceCode = Array.prototype.slice.call(arguments,1,arguments.length-1);
  } else {
    sourceCode = Array.prototype.slice.call(arguments,1);
  }
  assertParses0(expectedCode, sourceCode, parseOptions);
}

// assertParseThrows(error:RegExp|string, ...code:string, parseOptions?:{})
function assertParseThrows(error, code) {
  var parseOptions = null, sourceCode;
  if (arguments.length > 2 && typeof arguments[arguments.length-1] === 'object') {
    parseOptions = arguments[arguments.length-1];
    sourceCode = Array.prototype.slice.call(arguments,1,arguments.length-1);
  } else {
    sourceCode = Array.prototype.slice.call(arguments,1);
  }
  sourceCode = sourceCode.join('\n');
  A.throws(function() { parse(sourceCode, parseOptions); }, error);
}

assertParses('foo();'
  , 'foo()');

assertParsesSame('bar();'
  , 'macro foo -> bar; foo()'
  , 'macro foo -> bar\nfoo()'
  , 'macro foo -> bar foo()'
)

assertParseThrows(/Unexpected token.*\(1:10\)/i,
  'macro foo = bar foo()')

assertParsesSame('bar;'
  , 'macro foo() -> bar; foo()'
  , 'macro {foo()} -> bar; foo()'
  , 'macro {foo()} -> {bar}; foo()'
  , 'macro foo() -> {bar}; foo()'
  , 'macro foo($) -> bar; foo(1)'
)

assertParsesSame('bar[1];'
  , 'macro foo($) -> bar[$]; foo(1)'
  , 'macro {foo($)} -> bar[$]; foo(1)'
  , 'macro {foo $} -> bar[$]; foo 1'
)

// BUG fails when flow plugin is enabled, with "Unexpected token" at "*" during expansion:
var src =
  'macro {mul $1 $2} -> ($1 * $2);\n'+
  'mul 3 4';
assertParses('3 * 4;', src, { plugins: { jsx: 1, macro: 1 } } )
assertParses('3 * 4;', src, { plugins: { macro: 1 } } )
assertParseThrows(/Unexpected token.*\(1:25\)/i
  , src, { plugins: { jsx: 1, macro: 1, flow: 1 } } )
assertParseThrows(/Unexpected token.*\(1:25\)/i
  , src, { plugins: { macro: 1, flow: 1 } } )
assertParseThrows(/Unexpected token.*\(1:26\)/i
  , 'macro {mul($1 $2)} -> ($1 * $2)'
  , 'mul(3 4)'
  , { plugins: { macro: 1, flow: 1 } } )

assertParses('r();'
  , 'macro A -> {}; r(A)')


// deep expansion
assertParses('r(d(3,d));'
  , 'macro D -> d'
  , 'macro C -> D'
  , 'macro B -> C(3, D)'
  , 'macro A -> B'
  , 'r(A)')
assertParses('r(d(2,1,d));'
  , 'macro D -> d'
  , 'macro C -> D'
  , 'macro {B $2 $1} -> C($1, $2, D)'
  , 'macro A -> {B 1 2}'
  , 'r(A)')
assertParseThrows(/Cyclic macro expansion/i
  , 'macro B -> C(A)'
  , 'macro A -> B'
  , 'a(A)')
assertParseThrows(/Cyclic macro expansion/i
  , 'macro D -> B'
  , 'macro C -> D'
  , 'macro B -> C(3, D)'
  , 'macro A -> B'
  , 'r(A)')


// rest/spread vars
assertParses('d(1,2,3);'
  , 'macro D(...$) -> { d($) }' // non-greedy, bounded rest
  , 'D(1,2,3)') //< rest terminating at expected token ")"
assertParses('d();'
  , 'macro D(...$) -> { d($) }' // non-greedy, bounded rest
  , 'D()') //< empty rest terminating at expected token ")"
assertParses('d(1,2,3);'
  , 'macro { D ...$ } -> { d($) }' // greedy rest
  , 'D 1,2,3') //< rest terminating at EOF
assertParses('d();'
  , 'macro { D ...$ } -> { d($) }' // greedy rest
  , 'D') //< empty rest terminating at EOF

console.log(color('g','PASS'));