From ae564d6e66706ba0c256a43097deb3c07ca1cc9a Mon Sep 17 00:00:00 2001
From: Shu-yu Guo <shu@rfrn.org>
Date: Tue, 24 Aug 2010 19:45:21 -0700
Subject: [PATCH] Refactor structured property names to pseudo-namespaces using
 bind

---
 js/narcissus/jsexec.js  |    8 +-
 js/narcissus/jsparse.js | 1826 ++++++++++++++++++++-------------------
 2 files changed, 934 insertions(+), 900 deletions(-)

diff --git a/js/narcissus/jsexec.js b/js/narcissus/jsexec.js
index 777ed4e48b8a..0ab9b233f420 100644
--- a/js/narcissus/jsexec.js
+++ b/js/narcissus/jsexec.js
@@ -85,7 +85,7 @@ Narcissus.interpreter = (function() {
             x2.callee = x.callee;
             x2.scope = x.scope;
             try {
-                x2.execute(parser.parse(new parser.VanillaBuilder, s));
+                x2.execute(parser.parse(new parser.DefaultBuilder, s));
                 return x2.result;
             } catch (e if e instanceof SyntaxError || isStackOverflow(e)) {
                 /*
@@ -119,7 +119,7 @@ Narcissus.interpreter = (function() {
 
             // NB: Use the STATEMENT_FORM constant since we don't want to push this
             // function onto the fake compilation context.
-            var x = { builder: new parser.VanillaBuilder };
+            var x = { builder: new parser.DefaultBuilder };
             var f = parser.FunctionDefinition(t, x, false, parser.STATEMENT_FORM);
             var s = {object: global, parent: null};
             return newFunction(f,{scope:s});
@@ -1023,7 +1023,7 @@ Narcissus.interpreter = (function() {
             return s;
 
         var x = new ExecutionContext(GLOBAL_CODE);
-        x.execute(parser.parse(new parser.VanillaBuilder, s, f, l));
+        x.execute(parser.parse(new parser.DefaultBuilder, s, f, l));
         return x.result;
     }
 
@@ -1059,7 +1059,7 @@ Narcissus.interpreter = (function() {
             }
         }
 
-        var b = new parser.VanillaBuilder;
+        var b = new parser.DefaultBuilder;
         var x = new ExecutionContext(GLOBAL_CODE);
 
         ExecutionContext.current = x;
diff --git a/js/narcissus/jsparse.js b/js/narcissus/jsparse.js
index e1da444505bd..f5918bd43fe2 100644
--- a/js/narcissus/jsparse.js
+++ b/js/narcissus/jsparse.js
@@ -51,740 +51,771 @@ Narcissus.parser = (function() {
     // Set constants in the local scope.
     eval(definitions.consts);
 
-   /*
-    * The vanilla AST builder.
-    */
-    function VanillaBuilder() {
+    /*
+     * Function.prototype.bind is not yet implemented in many browsers.
+     * The following definition will be removed when it is.
+     *
+     * Similar to Prototype's implementation.
+     */
+
+    function bindMethod(method, context) {
+        if (arguments.length < 3 && arguments[0] === undefined)
+            return method;
+        var slice = Array.prototype.slice;
+        var args = slice.call(arguments, 2);
+        // Optimization for when there's no currying.
+        if (args.length === 0) {
+            return function() {
+                return method.apply(context, arguments);
+            }
+        }
+
+        return function() {
+            var a = slice.call(args, 0);
+            for (var i = 0, j = arguments.length; i < j; i++) {
+                a.push(arguments[i]);
+            }
+            return method.apply(context, a);
+        }
     }
 
-    VanillaBuilder.prototype = {
-        IF$build: function(t) {
-            return new Node(t, IF);
-        },
+    function bindSubBuilders(builder, proto) {
+        for (var ns in proto) {
+            var unbound = proto[ns];
+            // We do not want to bind functions like setHoists.
+            if (typeof unbound !== "object")
+                continue;
+
+            /*
+             * We store the bound sub-builder as builder's own property
+             * so that we can have multiple builders at the same time.
+             */
+            var bound = builder[ns] = {};
+            for (var m in unbound) {
+                bound[m] = bindMethod(unbound[m], builder);
+            }
+        }
+    }
+
+    /*
+     * The vanilla AST builder.
+     */
+
+    function DefaultBuilder() {
+        bindSubBuilders(this, DefaultBuilder.prototype);
+    }
+
+    function mkBinopBuilder(type) {
+        return {
+            build: !type ? function(t) { return new Node(t); }
+                          : function(t) { return new Node(t, type); },
+            addOperand: function(n, n2) { n.push(n2); },
+            finish: function(n) { }
+        };
+    }
+
+    DefaultBuilder.prototype = {
+        IF: {
+            build: function(t) {
+                return new Node(t, IF);
+            },
+
+            setCondition: function(n, e) {
+                n.condition = e;
+            },
+
+            setThenPart: function(n, s) {
+                n.thenPart = s;
+            },
+
+            setElsePart: function(n, s) {
+                n.elsePart = s;
+            },
+
+            finish: function(n) {
+            }
+        },
+
+        SWITCH: {
+            build: function(t) {
+                var n = new Node(t, SWITCH);
+                n.cases = [];
+                n.defaultIndex = -1;
+                return n;
+            },
+
+            setDiscriminant: function(n, e) {
+                n.discriminant = e;
+            },
+
+            setDefaultIndex: function(n, i) {
+                n.defaultIndex = i;
+            },
+
+            addCase: function(n, n2) {
+                n.cases.push(n2);
+            },
+
+            finish: function(n) {
+            }
+        },
+
+        CASE: {
+            build: function(t) {
+                return new Node(t, CASE);
+            },
+
+            setLabel: function(n, e) {
+                n.caseLabel = e;
+            },
+
+            initializeStatements: function(n, t) {
+                n.statements = new Node(t, BLOCK);
+            },
+
+            addStatement: function(n, s) {
+                n.statements.push(s);
+            },
+
+            finish: function(n) {
+            }
+        },
+
+        DEFAULT: {
+            build: function(t, p) {
+                return new Node(t, DEFAULT);
+            },
+
+            initializeStatements: function(n, t) {
+                n.statements = new Node(t, BLOCK);
+            },
+
+            addStatement: function(n, s) {
+                n.statements.push(s);
+            },
 
-        IF$setCondition: function(n, e) {
-            n.condition = e;
+            finish: function(n) {
+            }
         },
 
-        IF$setThenPart: function(n, s) {
-            n.thenPart = s;
-        },
+        FOR: {
+            build: function(t) {
+                var n = new Node(t, FOR);
+                n.isLoop = true;
+                n.isEach = false;
+                return n;
+            },
 
-        IF$setElsePart: function(n, s) {
-            n.elsePart = s;
-        },
+            rebuildForEach: function(n) {
+                n.isEach = true;
+            },
 
-        IF$finish: function(n) {
-        },
+            // NB. This function is called after rebuildForEach, if that's called
+            // at all.
+            rebuildForIn: function(n) {
+                n.type = FOR_IN;
+            },
 
-        SWITCH$build: function(t) {
-            var n = new Node(t, SWITCH);
-            n.cases = [];
-            n.defaultIndex = -1;
-            return n;
-        },
+            setCondition: function(n, e) {
+                n.condition = e;
+            },
 
-        SWITCH$setDiscriminant: function(n, e) {
-            n.discriminant = e;
-        },
+            setSetup: function(n, e) {
+                n.setup = e || null;
+            },
 
-        SWITCH$setDefaultIndex: function(n, i) {
-            n.defaultIndex = i;
-        },
+            setUpdate: function(n, e) {
+                n.update = e;
+            },
 
-        SWITCH$addCase: function(n, n2) {
-            n.cases.push(n2);
-        },
+            setObject: function(n, e) {
+                n.object = e;
+            },
 
-        SWITCH$finish: function(n) {
-        },
+            setIterator: function(n, e, e2) {
+                n.iterator = e;
+                n.varDecl = e2;
+            },
 
-        CASE$build: function(t) {
-            return new Node(t, CASE);
-        },
+            setBody: function(n, s) {
+                n.body = s;
+            },
 
-        CASE$setLabel: function(n, e) {
-            n.caseLabel = e;
+            finish: function(n) {
+            }
         },
 
-        CASE$initializeStatements: function(n, t) {
-            n.statements = new Node(t, BLOCK);
-        },
+        WHILE: {
+            build: function(t) {
+                var n = new Node(t, WHILE);
+                n.isLoop = true;
+                return n;
+            },
 
-        CASE$addStatement: function(n, s) {
-            n.statements.push(s);
-        },
+            setCondition: function(n, e) {
+                n.condition = e;
+            },
 
-        CASE$finish: function(n) {
-        },
+            setBody: function(n, s) {
+                n.body = s;
+            },
 
-        DEFAULT$build: function(t, p) {
-            return new Node(t, DEFAULT);
+            finish: function(n) {
+            }
         },
 
-        DEFAULT$initializeStatements: function(n, t) {
-            n.statements = new Node(t, BLOCK);
-        },
+        DO: {
+            build: function(t) {
+                var n = new Node(t, DO);
+                n.isLoop = true;
+                return n;
+            },
 
-        DEFAULT$addStatement: function(n, s) {
-            n.statements.push(s);
-        },
+            setCondition: function(n, e) {
+                n.condition = e;
+            },
 
-        DEFAULT$finish: function(n) {
-        },
+            setBody: function(n, s) {
+                n.body = s;
+            },
 
-        FOR$build: function(t) {
-            var n = new Node(t, FOR);
-            n.isLoop = true;
-            n.isEach = false;
-            return n;
+            finish: function(n) {
+            }
         },
 
-        FOR$rebuildForEach: function(n) {
-            n.isEach = true;
-        },
+        BREAK: {
+            build: function(t) {
+                return new Node(t, BREAK);
+            },
 
-        // NB. This function is called after rebuildForEach, if that's called
-        // at all.
-        FOR$rebuildForIn: function(n) {
-            n.type = FOR_IN;
-        },
+            setLabel: function(n, v) {
+                n.label = v;
+            },
 
-        FOR$setCondition: function(n, e) {
-            n.condition = e;
-        },
+            setTarget: function(n, n2) {
+                n.target = n2;
+            },
 
-        FOR$setSetup: function(n, e) {
-            n.setup = e || null;
+            finish: function(n) {
+            }
         },
 
-        FOR$setUpdate: function(n, e) {
-            n.update = e;
-        },
+        CONTINUE: {
+            build: function(t) {
+                return new Node(t, CONTINUE);
+            },
 
-        FOR$setObject: function(n, e) {
-            n.object = e;
-        },
+            setLabel: function(n, v) {
+                n.label = v;
+            },
 
-        FOR$setIterator: function(n, e, e2) {
-            n.iterator = e;
-            n.varDecl = e2;
-        },
+            setTarget: function(n, n2) {
+                n.target = n2;
+            },
 
-        FOR$setBody: function(n, s) {
-            n.body = s;
+            finish: function(n) {
+            }
         },
 
-        FOR$finish: function(n) {
-        },
+        TRY: {
+            build: function(t) {
+                var n = new Node(t, TRY);
+                n.catchClauses = [];
+                return n;
+            },
 
-        WHILE$build: function(t) {
-            var n = new Node(t, WHILE);
-            n.isLoop = true;
-            return n;
-        },
+            setTryBlock: function(n, s) {
+                n.tryBlock = s;
+            },
 
-        WHILE$setCondition: function(n, e) {
-            n.condition = e;
-        },
+            addCatch: function(n, n2) {
+                n.catchClauses.push(n2);
+            },
 
-        WHILE$setBody: function(n, s) {
-            n.body = s;
-        },
+            finishCatches: function(n) {
+            },
 
-        WHILE$finish: function(n) {
-        },
+            setFinallyBlock: function(n, s) {
+                n.finallyBlock = s;
+            },
 
-        DO$build: function(t) {
-            var n = new Node(t, DO);
-            n.isLoop = true;
-            return n;
+            finish: function(n) {
+            }
         },
 
-        DO$setCondition: function(n, e) {
-            n.condition = e;
-        },
+        CATCH: {
+            build: function(t) {
+                var n = new Node(t, CATCH);
+                n.guard = null;
+                return n;
+            },
 
-        DO$setBody: function(n, s) {
-            n.body = s;
-        },
+            setVarName: function(n, v) {
+                n.varName = v;
+            },
 
-        DO$finish: function(n) {
-        },
+            setGuard: function(n, e) {
+                n.guard = e;
+            },
 
-        BREAK$build: function(t) {
-            return new Node(t, BREAK);
-        },
+            setBlock: function(n, s) {
+                n.block = s;
+            },
 
-        BREAK$setLabel: function(n, v) {
-            n.label = v;
+            finish: function(n) {
+            }
         },
 
-        BREAK$setTarget: function(n, n2) {
-            n.target = n2;
-        },
+        THROW: {
+            build: function(t) {
+                return new Node(t, THROW);
+            },
 
-        BREAK$finish: function(n) {
-        },
+            setException: function(n, e) {
+                n.exception = e;
+            },
 
-        CONTINUE$build: function(t) {
-            return new Node(t, CONTINUE);
+            finish: function(n) {
+            }
         },
 
-        CONTINUE$setLabel: function(n, v) {
-            n.label = v;
-        },
+        RETURN: {
+            build: function(t) {
+                return new Node(t, RETURN);
+            },
 
-        CONTINUE$setTarget: function(n, n2) {
-            n.target = n2;
-        },
+            setValue: function(n, e) {
+                n.value = e;
+            },
 
-        CONTINUE$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
-        TRY$build: function(t) {
-            var n = new Node(t, TRY);
-            n.catchClauses = [];
-            return n;
-        },
+        YIELD: {
+            build: function(t) {
+                return new Node(t, YIELD);
+            },
 
-        TRY$setTryBlock: function(n, s) {
-            n.tryBlock = s;
-        },
+            setValue: function(n, e) {
+                n.value = e;
+            },
 
-        TRY$addCatch: function(n, n2) {
-            n.catchClauses.push(n2);
+            finish: function(n) {
+            }
         },
 
-        TRY$finishCatches: function(n) {
-        },
+        GENERATOR: {
+            build: function(t) {
+                return new Node(t, GENERATOR);
+            },
 
-        TRY$setFinallyBlock: function(n, s) {
-            n.finallyBlock = s;
-        },
+            setExpression: function(n, e) {
+                n.expression = e;
+            },
 
-        TRY$finish: function(n) {
-        },
+            setTail: function(n, n2) {
+                n.tail = n2;
+            },
 
-        CATCH$build: function(t) {
-            var n = new Node(t, CATCH);
-            n.guard = null;
-            return n;
+            finish: function(n) {
+            }
         },
 
-        CATCH$setVarName: function(n, v) {
-            n.varName = v;
-        },
+        WITH: {
+            build: function(t) {
+                return new Node(t, WITH);
+            },
 
-        CATCH$setGuard: function(n, e) {
-            n.guard = e;
-        },
+            setObject: function(n, e) {
+                n.object = e;
+            },
 
-        CATCH$setBlock: function(n, s) {
-            n.block = s;
-        },
+            setBody: function(n, s) {
+                n.body = s;
+            },
 
-        CATCH$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
-        THROW$build: function(t) {
-            return new Node(t, THROW);
+        DEBUGGER: {
+            build: function(t) {
+                return new Node(t, DEBUGGER);
+            }
         },
 
-        THROW$setException: function(n, e) {
-            n.exception = e;
-        },
+        SEMICOLON: {
+            build: function(t) {
+                return new Node(t, SEMICOLON);
+            },
 
-        THROW$finish: function(n) {
-        },
+            setExpression: function(n, e) {
+                n.expression = e;
+            },
 
-        RETURN$build: function(t) {
-            return new Node(t, RETURN);
+            finish: function(n) {
+            }
         },
 
-        RETURN$setValue: function(n, e) {
-            n.value = e;
-        },
+        LABEL: {
+            build: function(t) {
+                return new Node(t, LABEL);
+            },
 
-        RETURN$finish: function(n) {
-        },
+            setLabel: function(n, e) {
+                n.label = e;
+            },
 
-        YIELD$build: function(t) {
-            return new Node(t, YIELD);
-        },
+            setStatement: function(n, s) {
+                n.statement = s;
+            },
 
-        YIELD$setValue: function(n, e) {
-            n.value = e;
+            finish: function(n) {
+            }
         },
 
-        YIELD$finish: function(n) {
-        },
+        FUNCTION: {
+            build: function(t) {
+                var n = new Node(t);
+                if (n.type !== FUNCTION)
+                    n.type = (n.value === "get") ? GETTER : SETTER;
+                n.params = [];
+                return n;
+            },
 
-        GENERATOR$build: function(t) {
-            return new Node(t, GENERATOR);
-        },
+            setName: function(n, v) {
+                n.name = v;
+            },
 
-        GENERATOR$setExpression: function(n, e) {
-            n.expression = e;
-        },
+            addParam: function(n, v) {
+                n.params.push(v);
+            },
 
-        GENERATOR$setTail: function(n, n2) {
-            n.tail = n2;
-        },
+            setBody: function(n, s) {
+                n.body = s;
+            },
 
-        GENERATOR$finish: function(n) {
-        },
+            hoistVars: function(x) {
+            },
 
-        WITH$build: function(t) {
-            return new Node(t, WITH);
+            finish: function(n, x) {
+            }
         },
 
-        WITH$setObject: function(n, e) {
-            n.object = e;
-        },
+        VAR: {
+            build: function(t) {
+                return new Node(t, VAR);
+            },
 
-        WITH$setBody: function(n, s) {
-            n.body = s;
-        },
+            addDecl: function(n, n2, x) {
+                n.push(n2);
+            },
 
-        WITH$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
-        DEBUGGER$build: function(t) {
-            return new Node(t, DEBUGGER);
-        },
+        CONST: {
+            build: function(t) {
+                return new Node(t, VAR);
+            },
 
-        SEMICOLON$build: function(t) {
-            return new Node(t, SEMICOLON);
-        },
+            addDecl: function(n, n2, x) {
+                n.push(n2);
+            },
 
-        SEMICOLON$setExpression: function(n, e) {
-            n.expression = e;
+            finish: function(n) {
+            }
         },
 
-        SEMICOLON$finish: function(n) {
-        },
+        LET: {
+            build: function(t) {
+                return new Node(t, LET);
+            },
 
-        LABEL$build: function(t) {
-            return new Node(t, LABEL);
-        },
+            addDecl: function(n, n2, x) {
+                n.push(n2);
+            },
 
-        LABEL$setLabel: function(n, e) {
-            n.label = e;
+            finish: function(n) {
+            }
         },
 
-        LABEL$setStatement: function(n, s) {
-            n.statement = s;
-        },
+        DECL: {
+            build: function(t) {
+                return new Node(t, IDENTIFIER);
+            },
 
-        LABEL$finish: function(n) {
-        },
+            setName: function(n, v) {
+                n.name = v;
+            },
 
-        FUNCTION$build: function(t) {
-            var n = new Node(t);
-            if (n.type !== FUNCTION)
-                n.type = (n.value === "get") ? GETTER : SETTER;
-            n.params = [];
-            return n;
-        },
+            setInitializer: function(n, e) {
+                n.initializer = e;
+            },
 
-        FUNCTION$setName: function(n, v) {
-            n.name = v;
-        },
+            setReadOnly: function(n, b) {
+                n.readOnly = b;
+            },
 
-        FUNCTION$addParam: function(n, v) {
-            n.params.push(v);
+            finish: function(n) {
+            }
         },
 
-        FUNCTION$setBody: function(n, s) {
-            n.body = s;
-        },
+        LET_BLOCK: {
+            build: function(t) {
+                var n = Node(t, LET_BLOCK);
+                n.varDecls = [];
+                return n;
+            },
 
-        FUNCTION$hoistVars: function(x) {
-        },
+            setVariables: function(n, n2) {
+                n.variables = n2;
+            },
 
-        FUNCTION$finish: function(n, x) {
-        },
+            setExpression: function(n, e) {
+                n.expression = e;
+            },
 
-        VAR$build: function(t) {
-            return new Node(t, VAR);
-        },
+            setBlock: function(n, s) {
+                n.block = s;
+            },
 
-        VAR$addDecl: function(n, n2, x) {
-            n.push(n2);
+            finish: function(n) {
+            }
         },
 
-        VAR$finish: function(n) {
-        },
+        BLOCK: {
+            build: function(t, id) {
+                var n = new Node(t, BLOCK);
+                n.varDecls = [];
+                n.id = id;
+                return n;
+            },
 
-        CONST$build: function(t) {
-            return new Node(t, VAR);
-        },
+            hoistLets: function(n) {
+            },
 
-        CONST$addDecl: function(n, n2, x) {
-            n.push(n2);
-        },
+            addStatement: function(n, n2) {
+                n.push(n2);
+            },
 
-        CONST$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
-        LET$build: function(t) {
-            return new Node(t, LET);
-        },
+        EXPRESSION: {
+            build: function(t, tt) {
+                return new Node(t, tt);
+            },
 
-        LET$addDecl: function(n, n2, x) {
-            n.push(n2);
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        LET$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
-        DECL$build: function(t) {
-            return new Node(t, IDENTIFIER);
-        },
+        ASSIGN: {
+            build: function(t) {
+                return new Node(t, ASSIGN);
+            },
 
-        DECL$setName: function(n, v) {
-            n.name = v;
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        DECL$setInitializer: function(n, e) {
-            n.initializer = e;
-        },
+            setAssignOp: function(n, o) {
+                n.assignOp = o;
+            },
 
-        DECL$setReadOnly: function(n, b) {
-            n.readOnly = b;
+            finish: function(n) {
+            }
         },
 
-        DECL$finish: function(n) {
-        },
+        HOOK: {
+            build: function(t) {
+                return new Node(t, HOOK);
+            },
 
-        LET_BLOCK$build: function(t) {
-            var n = Node(t, LET_BLOCK);
-            n.varDecls = [];
-            return n;
-        },
+            setCondition: function(n, e) {
+                n[0] = e;
+            },
 
-        LET_BLOCK$setVariables: function(n, n2) {
-            n.variables = n2;
-        },
+            setThenPart: function(n, n2) {
+                n[1] = n2;
+            },
 
-        LET_BLOCK$setExpression: function(n, e) {
-            n.expression = e;
-        },
+            setElsePart: function(n, n2) {
+                n[2] = n2;
+            },
 
-        LET_BLOCK$setBlock: function(n, s) {
-            n.block = s;
+            finish: function(n) {
+            }
         },
 
-        LET_BLOCK$finish: function(n) {
-        },
+        OR: mkBinopBuilder(OR),
+        AND: mkBinopBuilder(AND),
+        BITWISE_OR: mkBinopBuilder(BITWISE_OR),
+        BITWISE_XOR: mkBinopBuilder(BITWISE_XOR),
+        BITWISE_AND: mkBinopBuilder(BITWISE_AND),
+        EQUALITY: mkBinopBuilder(), // EQ | NE | STRICT_EQ | STRICT_NE
+        RELATIONAL: mkBinopBuilder(), // LT | LE | GE | GT
+        SHIFT: mkBinopBuilder(), // LSH | RSH | URSH
+        ADD: mkBinopBuilder(), // PLUS | MINUS
+        MULTIPLY: mkBinopBuilder(), // MUL | DIV | MOD
 
-        BLOCK$build: function(t, id) {
-            var n = new Node(t, BLOCK);
-            n.varDecls = [];
-            n.id = id;
-            return n;
-        },
+        UNARY: {
+            // DELETE | VOID | TYPEOF | NOT | BITWISE_NOT
+            // UNARY_PLUS | UNARY_MINUS | INCREMENT | DECREMENT
+            build: function(t) {
+                if (t.token.type === PLUS)
+                    t.token.type = UNARY_PLUS;
+                else if (t.token.type === MINUS)
+                    t.token.type = UNARY_MINUS;
+                return new Node(t);
+            },
 
-        BLOCK$hoistLets: function(n) {
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        BLOCK$addStatement: function(n, n2) {
-            n.push(n2);
-        },
+            setPostfix: function(n) {
+                n.postfix = true;
+            },
 
-        BLOCK$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
-        EXPRESSION$build: function(t, tt) {
-            return new Node(t, tt);
-        },
+        MEMBER: {
+            // NEW | DOT | INDEX
+            build: function(t, tt) {
+                return new Node(t, tt);
+            },
 
-        EXPRESSION$addOperand: function(n, n2) {
-            n.push(n2);
-        },
+            rebuildNewWithArgs: function(n) {
+                n.type = NEW_WITH_ARGS;
+            },
 
-        EXPRESSION$finish: function(n) {
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        ASSIGN$build: function(t) {
-            return new Node(t, ASSIGN);
+            finish: function(n) {
+            }
         },
 
-        ASSIGN$addOperand: function(n, n2) {
-            n.push(n2);
-        },
+        PRIMARY: {
+            build: function(t, tt) {
+                // NB t.token.type must be NULL, THIS, TRUIE, FALSE, IDENTIFIER,
+                // NUMBER, STRING, or REGEXP.
+                return new Node(t, tt);
+            },
 
-        ASSIGN$setAssignOp: function(n, o) {
-            n.assignOp = o;
+            finish: function(n) {
+            }
         },
 
-        ASSIGN$finish: function(n) {
-        },
+        ARRAY_INIT: {
+            build: function(t) {
+                return new Node(t, ARRAY_INIT);
+            },
 
-        HOOK$build: function(t) {
-            return new Node(t, HOOK);
-        },
+            addElement: function(n, n2) {
+                n.push(n2);
+            },
 
-        HOOK$setCondition: function(n, e) {
-            n[0] = e;
+            finish: function(n) {
+            }
         },
 
-        HOOK$setThenPart: function(n, n2) {
-            n[1] = n2;
-        },
+        ARRAY_COMP: {
+            build: function(t) {
+                return new Node(t, ARRAY_COMP);
+            },
 
-        HOOK$setElsePart: function(n, n2) {
-            n[2] = n2;
-        },
+            setExpression: function(n, e) {
+                n.expression = e
+            },
 
-        HOOK$finish: function(n) {
-        },
+            setTail: function(n, n2) {
+                n.tail = n2;
+            },
 
-        OR$build: function(t) {
-            return new Node(t, OR);
+            finish: function(n) {
+            }
         },
 
-        OR$addOperand: function(n, n2) {
-            n.push(n2);
-        },
+        COMP_TAIL: {
+            build: function(t) {
+                return new Node(t, COMP_TAIL);
+            },
 
-        OR$finish: function(n) {
-        },
+            setGuard: function(n, e) {
+                n.guard = e;
+            },
 
-        AND$build: function(t) {
-            return new Node(t, AND);
-        },
+            addFor: function(n, n2) {
+                n.push(n2);
+            },
 
-        AND$addOperand: function(n, n2) {
-            n.push(n2);
+            finish: function(n) {
+            }
         },
 
-        AND$finish: function(n) {
-        },
+        OBJECT_INIT: {
+            build: function(t) {
+                return new Node(t, OBJECT_INIT);
+            },
 
-        BITWISE_OR$build: function(t) {
-            return new Node(t, BITWISE_OR);
-        },
+            addProperty: function(n, n2) {
+                n.push(n2);
+            },
 
-        BITWISE_OR$addOperand: function(n, n2) {
-            n.push(n2);
+            finish: function(n) {
+            }
         },
 
-        BITWISE_OR$finish: function(n) {
-        },
+        PROPERTY_INIT: {
+            build: function(t) {
+                return new Node(t, PROPERTY_INIT);
+            },
 
-        BITWISE_XOR$build: function(t) {
-            return new Node(t, BITWISE_XOR);
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        BITWISE_XOR$addOperand: function(n, n2) {
-            n.push(n2);
+            finish: function(n) {
+            }
         },
 
-        BITWISE_XOR$finish: function(n) {
-        },
+        COMMA: {
+            build: function(t) {
+                return new Node(t, COMMA);
+            },
 
-        BITWISE_AND$build: function(t) {
-            return new Node(t, BITWISE_AND);
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        BITWISE_AND$addOperand: function(n, n2) {
-            n.push(n2);
+            finish: function(n) {
+            }
         },
 
-        BITWISE_AND$finish: function(n) {
-        },
+        LIST: {
+            build: function(t) {
+                return new Node(t, LIST);
+            },
 
-        EQUALITY$build: function(t) {
-            // NB t.token.type must be EQ, NE, STRICT_EQ, or STRICT_NE.
-            return new Node(t);
-        },
-
-        EQUALITY$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        EQUALITY$finish: function(n) {
-        },
-
-        RELATIONAL$build: function(t) {
-            // NB t.token.type must be LT, LE, GE, or GT.
-            return new Node(t);
-        },
-
-        RELATIONAL$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        RELATIONAL$finish: function(n) {
-        },
-
-        SHIFT$build: function(t) {
-            // NB t.token.type must be LSH, RSH, or URSH.
-            return new Node(t);
-        },
-
-        SHIFT$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        SHIFT$finish: function(n) {
-        },
-
-        ADD$build: function(t) {
-            // NB t.token.type must be PLUS or MINUS.
-            return new Node(t);
-        },
-
-        ADD$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        ADD$finish: function(n) {
-        },
-
-        MULTIPLY$build: function(t) {
-            // NB t.token.type must be MUL, DIV, or MOD.
-            return new Node(t);
-        },
-
-        MULTIPLY$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        MULTIPLY$finish: function(n) {
-        },
-
-        UNARY$build: function(t) {
-            // NB t.token.type must be DELETE, VOID, TYPEOF, NOT, BITWISE_NOT,
-            // UNARY_PLUS, UNARY_MINUS, INCREMENT, or DECREMENT.
-            if (t.token.type === PLUS)
-                t.token.type = UNARY_PLUS;
-            else if (t.token.type === MINUS)
-                t.token.type = UNARY_MINUS;
-            return new Node(t);
-        },
-
-        UNARY$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        UNARY$setPostfix: function(n) {
-            n.postfix = true;
-        },
-
-        UNARY$finish: function(n) {
-        },
-
-        MEMBER$build: function(t, tt) {
-            // NB t.token.type must be NEW, DOT, or INDEX.
-            return new Node(t, tt);
-        },
-
-        MEMBER$rebuildNewWithArgs: function(n) {
-            n.type = NEW_WITH_ARGS;
-        },
-
-        MEMBER$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        MEMBER$finish: function(n) {
-        },
-
-        PRIMARY$build: function(t, tt) {
-            // NB t.token.type must be NULL, THIS, TRUIE, FALSE, IDENTIFIER,
-            // NUMBER, STRING, or REGEXP.
-            return new Node(t, tt);
-        },
-
-        PRIMARY$finish: function(n) {
-        },
-
-        ARRAY_INIT$build: function(t) {
-            return new Node(t, ARRAY_INIT);
-        },
-
-        ARRAY_INIT$addElement: function(n, n2) {
-            n.push(n2);
-        },
-
-        ARRAY_INIT$finish: function(n) {
-        },
-
-        ARRAY_COMP$build: function(t) {
-            return new Node(t, ARRAY_COMP);
-        },
-
-        ARRAY_COMP$setExpression: function(n, e) {
-            n.expression = e
-        },
-
-        ARRAY_COMP$setTail: function(n, n2) {
-            n.tail = n2;
-        },
-
-        ARRAY_COMP$finish: function(n) {
-        },
-
-        COMP_TAIL$build: function(t) {
-            return new Node(t, COMP_TAIL);
-        },
-
-        COMP_TAIL$setGuard: function(n, e) {
-            n.guard = e;
-        },
-
-        COMP_TAIL$addFor: function(n, n2) {
-            n.push(n2);
-        },
-
-        COMP_TAIL$finish: function(n) {
-        },
-
-        OBJECT_INIT$build: function(t) {
-            return new Node(t, OBJECT_INIT);
-        },
-
-        OBJECT_INIT$addProperty: function(n, n2) {
-            n.push(n2);
-        },
-
-        OBJECT_INIT$finish: function(n) {
-        },
-
-        PROPERTY_INIT$build: function(t) {
-            return new Node(t, PROPERTY_INIT);
-        },
-
-        PROPERTY_INIT$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        PROPERTY_INIT$finish: function(n) {
-        },
-
-        COMMA$build: function(t) {
-            return new Node(t, COMMA);
-        },
-
-        COMMA$addOperand: function(n, n2) {
-            n.push(n2);
-        },
-
-        COMMA$finish: function(n) {
-        },
-
-        LIST$build: function(t) {
-            return new Node(t, LIST);
-        },
-
-        LIST$addOperand: function(n, n2) {
-            n.push(n2);
-        },
+            addOperand: function(n, n2) {
+                n.push(n2);
+            },
 
-        LIST$finish: function(n) {
+            finish: function(n) {
+            }
         },
 
         setHoists: function(id, vds) {
@@ -936,16 +967,17 @@ Narcissus.parser = (function() {
          * For more details in its interaction with hoisting, see comments in
          * FunctionDefinition.
          */
-        var b = x.builder;
-        var n = b.BLOCK$build(t, x.blockId++);
-        b.BLOCK$hoistLets(n);
+        var builder = x.builder;
+        var b = builder.BLOCK;
+        var n = b.build(t, x.blockId++);
+        b.hoistLets(n);
         x.stmtStack.push(n);
         while (!t.done && t.peek(true) !== RIGHT_CURLY)
-            b.BLOCK$addStatement(n, Statement(t, x));
+            b.addStatement(n, Statement(t, x));
         x.stmtStack.pop();
-        b.BLOCK$finish(n);
+        b.finish(n);
         if (n.needsHoisting) {
-            b.setHoists(n.id, n.varDecls);
+            builder.setHoists(n.id, n.varDecls);
             /*
              * If a block needs hoisting, we need to propagate this flag up to
              * the CompilerContext.
@@ -971,7 +1003,7 @@ Narcissus.parser = (function() {
      */
     function Statement(t, x) {
         var i, label, n, n2, ss, tt = t.get(true);
-        var b = x.builder;
+        var builder = x.builder, b, b2, b3;
 
         // Cases for statements ending in a right curly return early, avoiding the
         // common semicolon insertion magic after this switch.
@@ -989,20 +1021,24 @@ Narcissus.parser = (function() {
             return n;
 
           case IF:
-            n = b.IF$build(t);
-            b.IF$setCondition(n, ParenExpression(t, x));
+            b = builder.IF;
+            n = b.build(t);
+            b.setCondition(n, ParenExpression(t, x));
             x.stmtStack.push(n);
-            b.IF$setThenPart(n, Statement(t, x));
+            b.setThenPart(n, Statement(t, x));
             if (t.match(ELSE))
-                b.IF$setElsePart(n, Statement(t, x));
+                b.setElsePart(n, Statement(t, x));
             x.stmtStack.pop();
-            b.IF$finish(n);
+            b.finish(n);
             return n;
 
           case SWITCH:
             // This allows CASEs after a DEFAULT, which is in the standard.
-            n = b.SWITCH$build(t);
-            b.SWITCH$setDiscriminant(n, ParenExpression(t, x));
+            b = builder.SWITCH;
+            b2 = builder.DEFAULT;
+            b3 = builder.CASE;
+            n = b.build(t);
+            b.setDiscriminant(n, ParenExpression(t, x));
             x.stmtStack.push(n);
             t.mustMatch(LEFT_CURLY);
             while ((tt = t.get()) !== RIGHT_CURLY) {
@@ -1010,40 +1046,41 @@ Narcissus.parser = (function() {
                   case DEFAULT:
                     if (n.defaultIndex >= 0)
                         throw t.newSyntaxError("More than one switch default");
-                    n2 = b.DEFAULT$build(t);
-                    b.SWITCH$setDefaultIndex(n, n.cases.length);
+                    n2 = b2.build(t);
+                    b.setDefaultIndex(n, n.cases.length);
                     t.mustMatch(COLON);
-                    b.DEFAULT$initializeStatements(n2, t);
+                    b2.initializeStatements(n2, t);
                     while ((tt=t.peek(true)) !== CASE && tt !== DEFAULT &&
                            tt !== RIGHT_CURLY)
-                        b.DEFAULT$addStatement(n2, Statement(t, x));
-                    b.DEFAULT$finish(n2);
+                        b2.addStatement(n2, Statement(t, x));
+                    b2.finish(n2);
                     break;
 
                   case CASE:
-                    n2 = b.CASE$build(t);
-                    b.CASE$setLabel(n2, Expression(t, x, COLON));
+                    n2 = b3.build(t);
+                    b3.setLabel(n2, Expression(t, x, COLON));
                     t.mustMatch(COLON);
-                    b.CASE$initializeStatements(n2, t);
+                    b3.initializeStatements(n2, t);
                     while ((tt=t.peek(true)) !== CASE && tt !== DEFAULT &&
                            tt !== RIGHT_CURLY)
-                        b.CASE$addStatement(n2, Statement(t, x));
-                    b.CASE$finish(n2);
+                        b3.addStatement(n2, Statement(t, x));
+                    b3.finish(n2);
                     break;
 
                   default:
                     throw t.newSyntaxError("Invalid switch case");
                 }
-                b.SWITCH$addCase(n, n2);
+                b.addCase(n, n2);
             }
             x.stmtStack.pop();
-            b.SWITCH$finish(n);
+            b.finish(n);
             return n;
 
           case FOR:
-            n = b.FOR$build(t);
+            b = builder.FOR;
+            n = b.build(t);
             if (t.match(IDENTIFIER) && t.token.value === "each")
-                b.FOR$rebuildForEach(n);
+                b.rebuildForEach(n);
             t.mustMatch(LEFT_PAREN);
             if ((tt = t.peek()) !== SEMICOLON) {
                 x.inForLoopInit = true;
@@ -1059,7 +1096,7 @@ Narcissus.parser = (function() {
                          * Let in for head, we need to add an implicit block
                          * around the rest of the for.
                          */
-                        var forBlock = b.BLOCK$build(t, x.blockId++);
+                        var forBlock = builder.BLOCK.build(t, x.blockId++);
                         x.stmtStack.push(forBlock);
                         n2 = Variables(t, x, forBlock);
                     }
@@ -1069,51 +1106,53 @@ Narcissus.parser = (function() {
                 x.inForLoopInit = false;
             }
             if (n2 && t.match(IN)) {
-                b.FOR$rebuildForIn(n);
-                b.FOR$setObject(n, Expression(t, x), forBlock);
+                b.rebuildForIn(n);
+                b.setObject(n, Expression(t, x), forBlock);
                 if (n2.type === VAR || n2.type === LET) {
                     if (n2.length !== 1) {
                         throw new SyntaxError("Invalid for..in left-hand side",
                                               t.filename, n2.lineno);
                     }
-                    b.FOR$setIterator(n, n2[0], n2, forBlock);
+                    b.setIterator(n, n2[0], n2, forBlock);
                 } else {
-                    b.FOR$setIterator(n, n2, null, forBlock);
+                    b.setIterator(n, n2, null, forBlock);
                 }
             } else {
-                b.FOR$setSetup(n, n2);
+                b.setSetup(n, n2);
                 t.mustMatch(SEMICOLON);
                 if (n.isEach)
                     throw t.newSyntaxError("Invalid for each..in loop");
-                b.FOR$setCondition(n, (t.peek() === SEMICOLON)
+                b.setCondition(n, (t.peek() === SEMICOLON)
                                   ? null
                                   : Expression(t, x));
                 t.mustMatch(SEMICOLON);
-                b.FOR$setUpdate(n, (t.peek() === RIGHT_PAREN)
+                b.setUpdate(n, (t.peek() === RIGHT_PAREN)
                                    ? null
                                    : Expression(t, x));
             }
             t.mustMatch(RIGHT_PAREN);
-            b.FOR$setBody(n, nest(t, x, n, Statement));
+            b.setBody(n, nest(t, x, n, Statement));
             if (forBlock) {
-                b.BLOCK$finish(forBlock);
+                builder.BLOCK.finish(forBlock);
                 x.stmtStack.pop();
             }
-            b.FOR$finish(n);
+            b.finish(n);
             return n;
 
           case WHILE:
-            n = b.WHILE$build(t);
-            b.WHILE$setCondition(n, ParenExpression(t, x));
-            b.WHILE$setBody(n, nest(t, x, n, Statement));
-            b.WHILE$finish(n);
+            b = builder.WHILE;
+            n = b.build(t);
+            b.setCondition(n, ParenExpression(t, x));
+            b.setBody(n, nest(t, x, n, Statement));
+            b.finish(n);
             return n;
 
           case DO:
-            n = b.DO$build(t);
-            b.DO$setBody(n, nest(t, x, n, Statement, WHILE));
-            b.DO$setCondition(n, ParenExpression(t, x));
-            b.DO$finish(n);
+            b = builder.DO;
+            n = b.build(t);
+            b.setBody(n, nest(t, x, n, Statement, WHILE));
+            b.setCondition(n, ParenExpression(t, x));
+            b.finish(n);
             if (!x.ecmaStrictMode) {
                 // <script language="JavaScript"> (without version hints) may need
                 // automatic semicolon insertion without a newline after do-while.
@@ -1125,14 +1164,16 @@ Narcissus.parser = (function() {
 
           case BREAK:
           case CONTINUE:
-            n = tt === BREAK ? b.BREAK$build(t) : b.CONTINUE$build(t);
+            if (tt === BREAK) {
+                b = builder.BREAK;
+            } else {
+                b = builder.CONTINUE;
+            }
+            n = b.build(t);
 
             if (t.peekOnSameLine() === IDENTIFIER) {
                 t.get();
-                if (tt === BREAK)
-                    b.BREAK$setLabel(n, t.token.value);
-                else
-                    b.CONTINUE$setLabel(n, t.token.value);
+                b.setLabel(n, t.token.value);
             }
 
             ss = x.stmtStack;
@@ -1167,29 +1208,26 @@ Narcissus.parser = (function() {
                     }
                 } while (!ss[i].isLoop && !(tt === BREAK && ss[i].type === SWITCH));
             }
-            if (tt === BREAK) {
-                b.BREAK$setTarget(n, ss[i]);
-                b.BREAK$finish(n);
-            } else {
-                b.CONTINUE$setTarget(n, ss[i]);
-                b.CONTINUE$finish(n);
-            }
+            b.setTarget(n, ss[i]);
+            b.finish(n);
             break;
 
           case TRY:
-            n = b.TRY$build(t);
-            b.TRY$setTryBlock(n, Block(t, x));
+            b = builder.TRY;
+            b2 = builder.CATCH;
+            n = b.build(t);
+            b.setTryBlock(n, Block(t, x));
             while (t.match(CATCH)) {
-                n2 = b.CATCH$build(t);
+                n2 = b2.build(t);
                 t.mustMatch(LEFT_PAREN);
                 switch (t.get()) {
                   case LEFT_BRACKET:
                   case LEFT_CURLY:
                     // Destructured catch identifiers.
                     t.unget();
-                    b.CATCH$setVarName(n2, DestructuringExpression(t, x, true));
+                    b2.setVarName(n2, DestructuringExpression(t, x, true));
                   case IDENTIFIER:
-                    b.CATCH$setVarName(n2, t.token.value);
+                    b2.setVarName(n2, t.token.value);
                     break;
                   default:
                     throw t.newSyntaxError("missing identifier in catch");
@@ -1200,21 +1238,21 @@ Narcissus.parser = (function() {
                         throw t.newSyntaxError("Illegal catch guard");
                     if (n.catchClauses.length && !n.catchClauses.top().guard)
                         throw t.newSyntaxError("Guarded catch after unguarded");
-                    b.CATCH$setGuard(n2, Expression(t, x));
+                    b2.setGuard(n2, Expression(t, x));
                 } else {
-                    b.CATCH$setGuard(n2, null);
+                    b2.setGuard(n2, null);
                 }
                 t.mustMatch(RIGHT_PAREN);
-                b.CATCH$setBlock(n2, Block(t, x));
-                b.CATCH$finish(n2);
-                b.TRY$addCatch(n, n2);
+                b2.setBlock(n2, Block(t, x));
+                b2.finish(n2);
+                b.addCatch(n, n2);
             }
-            b.TRY$finishCatches(n);
+            b.finishCatches(n);
             if (t.match(FINALLY))
-                b.TRY$setFinallyBlock(n, Block(t, x));
+                b.setFinallyBlock(n, Block(t, x));
             if (!n.catchClauses.length && !n.finallyBlock)
                 throw t.newSyntaxError("Invalid try statement");
-            b.TRY$finish(n);
+            b.finish(n);
             return n;
 
           case CATCH:
@@ -1222,9 +1260,10 @@ Narcissus.parser = (function() {
             throw t.newSyntaxError(definitions.tokens[tt] + " without preceding try");
 
           case THROW:
-            n = b.THROW$build(t);
-            b.THROW$setException(n, Expression(t, x));
-            b.THROW$finish(n);
+            b = builder.THROW;
+            n = b.build(t);
+            b.setException(n, Expression(t, x));
+            b.finish(n);
             break;
 
           case RETURN:
@@ -1232,10 +1271,11 @@ Narcissus.parser = (function() {
             break;
 
           case WITH:
-            n = b.WITH$build(t);
-            b.WITH$setObject(n, ParenExpression(t, x));
-            b.WITH$setBody(n, nest(t, x, n, Statement));
-            b.WITH$finish(n);
+            b = builder.WITH;
+            n = b.build(t);
+            b.setObject(n, ParenExpression(t, x));
+            b.setBody(n, nest(t, x, n, Statement));
+            b.finish(n);
             return n;
 
           case VAR:
@@ -1251,14 +1291,15 @@ Narcissus.parser = (function() {
             break;
 
           case DEBUGGER:
-            n = b.DEBUGGER$build(t);
+            n = builder.DEBUGGER.build(t);
             break;
 
           case NEWLINE:
           case SEMICOLON:
-            n = b.SEMICOLON$build(t);
-            b.SEMICOLON$setExpression(n, null);
-            b.SEMICOLON$finish(t);
+            b = builder.SEMICOLON;
+            n = b.build(t);
+            b.setExpression(n, null);
+            b.finish(t);
             return n;
 
           default:
@@ -1273,21 +1314,23 @@ Narcissus.parser = (function() {
                             throw t.newSyntaxError("Duplicate label");
                     }
                     t.get();
-                    n = b.LABEL$build(t);
-                    b.LABEL$setLabel(n, label)
-                    b.LABEL$setStatement(n, nest(t, x, n, Statement));
-                    b.LABEL$finish(n);
+                    b = builder.LABEL;
+                    n = b.build(t);
+                    b.setLabel(n, label)
+                    b.setStatement(n, nest(t, x, n, Statement));
+                    b.finish(n);
                     return n;
                 }
             }
 
             // Expression statement.
             // We unget the current token to parse the expression as a whole.
-            n = b.SEMICOLON$build(t);
+            b = builder.SEMICOLON;
+            n = b.build(t);
             t.unget();
-            b.SEMICOLON$setExpression(n, Expression(t, x));
+            b.setExpression(n, Expression(t, x));
             n.end = n.expression.end;
-            b.SEMICOLON$finish(n);
+            b.finish(n);
             break;
         }
 
@@ -1306,18 +1349,19 @@ Narcissus.parser = (function() {
     }
 
     function returnOrYield(t, x) {
-        var n, b = x.builder, tt = t.token.type, tt2;
+        var n, b, tt = t.token.type, tt2;
 
         if (tt === RETURN) {
             if (!x.inFunction)
                 throw t.newSyntaxError("Return not in function");
-            n = b.RETURN$build(t);
+            b = x.builder.RETURN;
         } else /* (tt === YIELD) */ {
             if (!x.inFunction)
                 throw t.newSyntaxError("Yield not in function");
             x.isGenerator = true;
-            n = b.YIELD$build(t);
+            b = x.builder.YIELD;
         }
+        n = b.build(t);
 
         tt2 = t.peek(true);
         if (tt2 !== END && tt2 !== NEWLINE && tt2 !== SEMICOLON && tt2 !== RIGHT_CURLY
@@ -1325,10 +1369,10 @@ Narcissus.parser = (function() {
                 (tt2 !== tt && tt2 !== RIGHT_BRACKET && tt2 !== RIGHT_PAREN &&
                  tt2 !== COLON && tt2 !== COMMA))) {
             if (tt === RETURN) {
-                b.RETURN$setValue(n, Expression(t, x));
+                b.setValue(n, Expression(t, x));
                 x.hasReturnWithValue = true;
             } else {
-                b.YIELD$setValue(n, AssignExpression(t, x));
+                b.setValue(n, AssignExpression(t, x));
             }
         } else if (tt === RETURN) {
             x.hasEmptyReturn = true;
@@ -1338,11 +1382,7 @@ Narcissus.parser = (function() {
         if (x.hasReturnWithValue && x.isGenerator)
             throw t.newSyntaxError("Generator returns a value");
 
-        if (tt === RETURN)
-            b.RETURN$finish(n);
-        else
-            b.YIELD$finish(n);
-
+        b.finish(n);
         return n;
     }
 
@@ -1352,10 +1392,12 @@ Narcissus.parser = (function() {
      *                    -> node
      */
     function FunctionDefinition(t, x, requireName, functionForm) {
-        var b = x.builder;
-        var f = b.FUNCTION$build(t);
+        var tt, x2, rp;
+        var builder = x.builder;
+        var b = builder.FUNCTION;
+        var f = b.build(t);
         if (t.match(IDENTIFIER))
-            b.FUNCTION$setName(f, t.token.value);
+            b.setName(f, t.token.value);
         else if (requireName)
             throw t.newSyntaxError("missing function identifier");
 
@@ -1367,10 +1409,10 @@ Narcissus.parser = (function() {
                   case LEFT_CURLY:
                     // Destructured formal parameters.
                     t.unget();
-                    b.FUNCTION$addParam(f, DestructuringExpression(t, x));
+                    b.addParam(f, DestructuringExpression(t, x));
                     break;
                   case IDENTIFIER:
-                    b.FUNCTION$addParam(f, t.token.value);
+                    b.addParam(f, t.token.value);
                     break;
                   default:
                     throw t.newSyntaxError("missing formal parameter");
@@ -1381,12 +1423,12 @@ Narcissus.parser = (function() {
         }
 
         // Do we have an expression closure or a normal body?
-        var tt = t.get();
+        tt = t.get();
         if (tt !== LEFT_CURLY)
             t.unget();
 
-        var x2 = new StaticContext(true, b);
-        var rp = t.save();
+        x2 = new StaticContext(true, builder);
+        rp = t.save();
         if (x.inFunction) {
             /*
              * Inner functions don't reset block numbering, only functions at
@@ -1396,12 +1438,12 @@ Narcissus.parser = (function() {
         }
 
         if (tt !== LEFT_CURLY) {
-            b.FUNCTION$setBody(f, AssignExpression(t, x));
+            b.setBody(f, AssignExpression(t, x));
             if (x.isGenerator)
                 throw t.newSyntaxError("Generator returns a value");
         } else {
-            b.FUNCTION$hoistVars(x2.blockId);
-            b.FUNCTION$setBody(f, Script(t, x2));
+            b.hoistVars(x2.blockId);
+            b.setBody(f, Script(t, x2));
         }
 
         /*
@@ -1454,12 +1496,11 @@ Narcissus.parser = (function() {
          * Statements.
          */
         if (x2.needsHoisting) {
-
             /*
              * Order is important here! Builders expect funDecls to come after
              * varDecls!
              */
-            b.setHoists(f.body.id, x2.varDecls.concat(x2.funDecls));
+            builder.setHoists(f.body.id, x2.varDecls.concat(x2.funDecls));
 
             if (x.inFunction) {
                 /*
@@ -1469,16 +1510,16 @@ Narcissus.parser = (function() {
                 x.needsHoisting = true;
             } else {
                 // Only re-parse functions at the top level of the program.
-                x2 = new StaticContext(true, b);
+                x2 = new StaticContext(true, builder);
                 t.rewind(rp);
                 /*
                  * Set a flag in case the builder wants to have different behavior
                  * on the second pass.
                  */
-                b.secondPass = true;
-                b.FUNCTION$hoistVars(f.body.id, true);
-                b.FUNCTION$setBody(f, Script(t, x2));
-                b.secondPass = false;
+                builder.secondPass = true;
+                b.hoistVars(f.body.id, true);
+                b.setBody(f, Script(t, x2));
+                builder.secondPass = false;
             }
         }
 
@@ -1489,7 +1530,7 @@ Narcissus.parser = (function() {
         f.functionForm = functionForm;
         if (functionForm === DECLARED_FORM)
             x.funDecls.push(f);
-        b.FUNCTION$finish(f, x);
+        b.finish(f, x);
         return f;
     }
 
@@ -1500,27 +1541,23 @@ Narcissus.parser = (function() {
      * initializations).
      */
     function Variables(t, x, letBlock) {
-        var b = x.builder;
-        var n, ss, i, s;
-        var build, addDecl, finish;
+        var b, bDecl, bAssign, n, n2, n3, ss, i, s, tt, id, data;
+        var builder = x.builder;
+        var bDecl = builder.DECL;
+        var bAssign = builder.ASSIGN;
+
         switch (t.token.type) {
           case VAR:
-            build = b.VAR$build;
-            addDecl = b.VAR$addDecl;
-            finish = b.VAR$finish;
+            b = builder.VAR;
             s = x;
             break;
           case CONST:
-            build = b.CONST$build;
-            addDecl = b.CONST$addDecl;
-            finish = b.CONST$finish;
+            b = builder.CONST;
             s = x;
             break;
           case LET:
           case LEFT_PAREN:
-            build = b.LET$build;
-            addDecl = b.LET$addDecl;
-            finish = b.LET$finish;
+            b = builder.LET;
             if (!letBlock) {
                 ss = x.stmtStack;
                 i = ss.length;
@@ -1530,9 +1567,7 @@ Narcissus.parser = (function() {
                  * SpiderMonkey.
                  */
                 if (i === 0) {
-                    build = b.VAR$build;
-                    addDecl = b.VAR$addDecl;
-                    finish = b.VAR$finish;
+                    b = builder.VAR;
                     s = x;
                 } else {
                     s = ss[i];
@@ -1542,25 +1577,27 @@ Narcissus.parser = (function() {
             }
             break;
         }
-        n = build.call(b, t);
+
+        n = b.build(t);
         initializers = [];
+
         do {
-            var tt = t.get();
+            tt = t.get();
             /*
              * FIXME Should have a special DECLARATION node instead of overloading
              * IDENTIFIER to mean both identifier declarations and destructured
              * declarations.
              */
-            var n2 = b.DECL$build(t);
+            n2 = bDecl.build(t);
             if (tt === LEFT_BRACKET || tt === LEFT_CURLY) {
                 // Pass in s if we need to add each pattern matched into
                 // its varDecls, else pass in x.
-                var data = null;
+                data = null;
                 // Need to unget to parse the full destructured expression.
                 t.unget();
-                b.DECL$setName(n2, DestructuringExpression(t, x, true, s));
+                bDecl.setName(n2, DestructuringExpression(t, x, true, s));
                 if (x.inForLoopInit && t.peek() === IN) {
-                    addDecl.call(b, n, n2, s);
+                    b.addDecl(n, n2, s);
                     continue;
                 }
 
@@ -1569,46 +1606,46 @@ Narcissus.parser = (function() {
                     throw t.newSyntaxError("Invalid variable initialization");
 
                 // Parse the init as a normal assignment.
-                var n3 = b.ASSIGN$build(t);
-                b.ASSIGN$addOperand(n3, n2.name);
-                b.ASSIGN$addOperand(n3, AssignExpression(t, x));
-                b.ASSIGN$finish(n3);
+                n3 = bAssign.build(t);
+                bAssign.addOperand(n3, n2.name);
+                bAssign.addOperand(n3, AssignExpression(t, x));
+                bAssign.finish(n3);
 
                 // But only add the rhs as the initializer.
-                b.DECL$setInitializer(n2, n3[1]);
-                b.DECL$finish(n2);
-                addDecl.call(b, n, n2, s);
+                bDecl.setInitializer(n2, n3[1]);
+                bDecl.finish(n2);
+                b.addDecl(n, n2, s);
                 continue;
             }
 
             if (tt !== IDENTIFIER)
                 throw t.newSyntaxError("missing variable name");
 
-            b.DECL$setName(n2, t.token.value);
-            b.DECL$setReadOnly(n2, n.type === CONST);
-            addDecl.call(b, n, n2, s);
+            bDecl.setName(n2, t.token.value);
+            bDecl.setReadOnly(n2, n.type === CONST);
+            b.addDecl(n, n2, s);
 
             if (t.match(ASSIGN)) {
                 if (t.token.assignOp)
                     throw t.newSyntaxError("Invalid variable initialization");
 
-                // Parse the init as a normal assignment with a fake lhs.
-                var id = new Node(n2.tokenizer, IDENTIFIER);
-                var n3 = b.ASSIGN$build(t);
+                // Parse the init as a normal assignment.
+                id = new Node(n2.tokenizer, IDENTIFIER);
+                n3 = bAssign.build(t);
                 id.name = id.value = n2.name;
-                b.ASSIGN$addOperand(n3, id);
-                b.ASSIGN$addOperand(n3, AssignExpression(t, x));
-                b.ASSIGN$finish(n3);
+                bAssign.addOperand(n3, id);
+                bAssign.addOperand(n3, AssignExpression(t, x));
+                bAssign.finish(n3);
                 initializers.push(n3);
 
                 // But only add the rhs as the initializer.
-                b.DECL$setInitializer(n2, n3[1]);
+                bDecl.setInitializer(n2, n3[1]);
             }
 
-            b.DECL$finish(n2);
+            bDecl.finish(n2);
             s.varDecls.push(n2);
         } while (t.match(COMMA));
-        finish.call(b, n);
+        b.finish(n);
         return n;
     }
 
@@ -1619,12 +1656,13 @@ Narcissus.parser = (function() {
      */
     function LetBlock(t, x, isStatement) {
         var n, n2, binds;
-        var b = x.builder;
+        var builder = x.builder;
+        var b = builder.LET_BLOCK, b2;
 
         // t.token.type must be LET
-        n = b.LET_BLOCK$build(t);
+        n = b.build(t);
         t.mustMatch(LEFT_PAREN);
-        b.LET_BLOCK$setVariables(n, Variables(t, x, n));
+        b.setVariables(n, Variables(t, x, n));
         t.mustMatch(RIGHT_PAREN);
 
         if (isStatement && t.peek() !== LEFT_CURLY) {
@@ -1633,21 +1671,22 @@ Narcissus.parser = (function() {
              * need to wrap the LET_BLOCK node in a SEMICOLON node so that we pop
              * the return value of the expression.
              */
-            n2 = b.SEMICOLON$build(t);
-            b.SEMICOLON$setExpression(n2, n);
-            b.SEMICOLON$finish(n2);
+            b2 = builder.SEMICOLON;
+            n2 = b2.build(t);
+            b2.setExpression(n2, n);
+            b2.finish(n2);
             isStatement = false;
         }
 
         if (isStatement) {
             n2 = Block(t, x);
-            b.LET_BLOCK$setBlock(n, n2);
+            b.setBlock(n, n2);
         } else {
             n2 = AssignExpression(t, x);
-            b.LET_BLOCK$setExpression(n, n2);
+            b.setExpression(n, n2);
         }
 
-        b.LET_BLOCK$finish(n);
+        b.finish(n);
 
         return n;
     }
@@ -1658,10 +1697,9 @@ Narcissus.parser = (function() {
         if (n.type !== ARRAY_INIT && n.type !== OBJECT_INIT)
             return;
 
-        var b = x.builder;
-
+        var nn, n2, lhs, rhs, b = x.builder.DECL;
         for (var i = 0, j = n.length; i < j; i++) {
-            var nn = n[i], lhs, rhs;
+            nn = n[i];
             if (!nn)
                 continue;
             if (nn.type === PROPERTY_INIT)
@@ -1675,11 +1713,11 @@ Narcissus.parser = (function() {
                 if (lhs.type !== IDENTIFIER) {
                     throw t.newSyntaxError("missing name in pattern");
                 } else if (data) {
-                    var n2 = b.DECL$build(t);
-                    b.DECL$setName(n2, lhs.value);
+                    n2 = b.build(t);
+                    b.setName(n2, lhs.value);
                     // Don't need to set initializer because it's just for
                     // hoisting anyways.
-                    b.DECL$finish(n2);
+                    b.finish(n2);
                     // Each pattern needs to be added to varDecls.
                     data.varDecls.push(n2);
                 }
@@ -1694,30 +1732,35 @@ Narcissus.parser = (function() {
     }
 
     function GeneratorExpression(t, x, e) {
-        var n;
+        var n, b = x.builder.GENERATOR;
 
-        n = b.GENERATOR$build(t);
-        b.GENERATOR$setExpression(n, e);
-        b.GENERATOR$setTail(n, comprehensionTail(t, x));
-        b.GENERATOR$finish(n);
+        n = b.build(t);
+        b.setExpression(n, e);
+        b.setTail(n, comprehensionTail(t, x));
+        b.finish(n);
 
         return n;
     }
 
     function comprehensionTail(t, x) {
         var body, n;
-        var b = x.builder;
+        var builder = x.builder;
+        var b = builder.COMP_TAIL;
+        var bFor = builder.FOR;
+        var bDecl = builder.DECL;
+        var bVar = builder.VAR;
+
         // t.token.type must be FOR
-        body = b.COMP_TAIL$build(t);
+        body = b.build(t);
 
         do {
-            n = b.FOR$build(t);
+            n = bFor.build(t);
             // Comprehension tails are always for..in loops.
-            b.FOR$rebuildForIn(n);
+            bFor.rebuildForIn(n);
             if (t.match(IDENTIFIER)) {
                 // But sometimes they're for each..in.
                 if (t.token.value === "each")
-                    b.FOR$rebuildForEach(n);
+                    bFor.rebuildForEach(n);
                 else
                     t.unget();
             }
@@ -1727,17 +1770,17 @@ Narcissus.parser = (function() {
               case LEFT_CURLY:
                 t.unget();
                 // Destructured left side of for in comprehension tails.
-                b.FOR$setIterator(n, DestructuringExpression(t, x), null);
+                b2.setIterator(n, DestructuringExpression(t, x), null);
                 break;
 
               case IDENTIFIER:
-                var n3 = b.DECL$build(t);
-                b.DECL$setName(n3, n3.value);
-                b.DECL$finish(n3);
-                var n2 = b.VAR$build(t);
-                b.VAR$addDecl(n2, n3);
-                b.VAR$finish(n2);
-                b.FOR$setIterator(n, n3, n2);
+                var n3 = bDecl.build(t);
+                bDecl.setName(n3, n3.value);
+                bDecl.finish(n3);
+                var n2 = bVar.build(t);
+                bVar.addDecl(n2, n3);
+                bVar.finish(n2);
+                bFor.setIterator(n, n3, n2);
                 /*
                  * Don't add to varDecls since the semantics of comprehensions is
                  * such that the variables are in their own function when
@@ -1749,16 +1792,16 @@ Narcissus.parser = (function() {
                 throw t.newSyntaxError("missing identifier");
             }
             t.mustMatch(IN);
-            b.FOR$setObject(n, Expression(t, x));
+            bFor.setObject(n, Expression(t, x));
             t.mustMatch(RIGHT_PAREN);
-            b.COMP_TAIL$addFor(body, n);
+            b.addFor(body, n);
         } while (t.match(FOR));
 
         // Optional guard.
         if (t.match(IF))
-            b.COMP_TAIL$setGuard(body, ParenExpression(t, x));
+            b.setGuard(body, ParenExpression(t, x));
 
-        b.COMP_TAIL$finish(body);
+        b.finish(body);
         return body;
     }
 
@@ -1790,45 +1833,43 @@ Narcissus.parser = (function() {
     }
 
     /*
-     * Expression: (tokenizer, compiler context) -> node
+     * Expression :: (tokenizer, compiler context) -> node
      *
      * Top-down expression parser matched against SpiderMonkey.
      */
     function Expression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.COMMA;
 
         n = AssignExpression(t, x);
         if (t.match(COMMA)) {
-            n2 = b.COMMA$build(t);
-            b.COMMA$addOperand(n2, n);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
             n = n2;
             do {
                 n2 = n[n.length-1];
                 if (n2.type === YIELD && !n2.parenthesized)
                     throw t.newSyntaxError("Yield expression must be parenthesized");
-                b.COMMA$addOperand(n, AssignExpression(t, x));
+                b.addOperand(n, AssignExpression(t, x));
             } while (t.match(COMMA));
-            b.COMMA$finish(n);
+            b.finish(n);
         }
 
         return n;
     }
 
     function AssignExpression(t, x) {
-        var n, lhs;
-        var b = x.builder;
+        var n, lhs, b = x.builder.ASSIGN;
 
         // Have to treat yield like an operand because it could be the leftmost
         // operand of the expression.
         if (t.match(YIELD, true))
             return returnOrYield(t, x);
 
-        n = b.ASSIGN$build(t);
+        n = b.build(t);
         lhs = ConditionalExpression(t, x);
 
         if (!t.match(ASSIGN)) {
-            b.ASSIGN$finish(n);
+            b.finish(n);
             return lhs;
         }
 
@@ -1844,23 +1885,22 @@ Narcissus.parser = (function() {
             break;
         }
 
-        b.ASSIGN$setAssignOp(n, t.token.assignOp);
-        b.ASSIGN$addOperand(n, lhs);
-        b.ASSIGN$addOperand(n, AssignExpression(t, x));
-        b.ASSIGN$finish(n);
+        b.setAssignOp(n, t.token.assignOp);
+        b.addOperand(n, lhs);
+        b.addOperand(n, AssignExpression(t, x));
+        b.finish(n);
 
         return n;
     }
 
     function ConditionalExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.HOOK;
 
         n = OrExpression(t, x);
         if (t.match(HOOK)) {
             n2 = n;
-            n = b.HOOK$build(t);
-            b.HOOK$setCondition(n, n2);
+            n = b.build(t);
+            b.setCondition(n, n2);
             /*
              * Always accept the 'in' operator in the middle clause of a ternary,
              * where it's unambiguous, even if we might be parsing the init of a
@@ -1868,27 +1908,26 @@ Narcissus.parser = (function() {
              */
             var oldLoopInit = x.inForLoopInit;
             x.inForLoopInit = false;
-            b.HOOK$setThenPart(n, AssignExpression(t, x));
+            b.setThenPart(n, AssignExpression(t, x));
             x.inForLoopInit = oldLoopInit;
             if (!t.match(COLON))
                 throw t.newSyntaxError("missing : after ?");
-            b.HOOK$setElsePart(n, AssignExpression(t, x));
-            b.HOOK$finish(n);
+            b.setElsePart(n, AssignExpression(t, x));
+            b.finish(n);
         }
 
         return n;
     }
 
     function OrExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.OR;
 
         n = AndExpression(t, x);
         while (t.match(OR)) {
-            n2 = b.OR$build(t);
-            b.OR$addOperand(n2, n);
-            b.OR$addOperand(n2, AndExpression(t, x));
-            b.OR$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, AndExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -1896,15 +1935,14 @@ Narcissus.parser = (function() {
     }
 
     function AndExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.AND;
 
         n = BitwiseOrExpression(t, x);
         while (t.match(AND)) {
-            n2 = b.AND$build(t);
-            b.AND$addOperand(n2, n);
-            b.AND$addOperand(n2, BitwiseOrExpression(t, x));
-            b.AND$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, BitwiseOrExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -1912,15 +1950,14 @@ Narcissus.parser = (function() {
     }
 
     function BitwiseOrExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.BITWISE_OR;
 
         n = BitwiseXorExpression(t, x);
         while (t.match(BITWISE_OR)) {
-            n2 = b.BITWISE_OR$build(t);
-            b.BITWISE_OR$addOperand(n2, n);
-            b.BITWISE_OR$addOperand(n2, BitwiseXorExpression(t, x));
-            b.BITWISE_OR$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, BitwiseXorExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -1928,15 +1965,14 @@ Narcissus.parser = (function() {
     }
 
     function BitwiseXorExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.BITWISE_XOR;
 
         n = BitwiseAndExpression(t, x);
         while (t.match(BITWISE_XOR)) {
-            n2 = b.BITWISE_XOR$build(t);
-            b.BITWISE_XOR$addOperand(n2, n);
-            b.BITWISE_XOR$addOperand(n2, BitwiseAndExpression(t, x));
-            b.BITWISE_XOR$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, BitwiseAndExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -1944,15 +1980,14 @@ Narcissus.parser = (function() {
     }
 
     function BitwiseAndExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.BITWISE_AND;
 
         n = EqualityExpression(t, x);
         while (t.match(BITWISE_AND)) {
-            n2 = b.BITWISE_AND$build(t);
-            b.BITWISE_AND$addOperand(n2, n);
-            b.BITWISE_AND$addOperand(n2, EqualityExpression(t, x));
-            b.BITWISE_AND$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, EqualityExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -1960,16 +1995,15 @@ Narcissus.parser = (function() {
     }
 
     function EqualityExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.EQUALITY;
 
         n = RelationalExpression(t, x);
         while (t.match(EQ) || t.match(NE) ||
                t.match(STRICT_EQ) || t.match(STRICT_NE)) {
-            n2 = b.EQUALITY$build(t);
-            b.EQUALITY$addOperand(n2, n);
-            b.EQUALITY$addOperand(n2, RelationalExpression(t, x));
-            b.EQUALITY$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, RelationalExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -1977,8 +2011,7 @@ Narcissus.parser = (function() {
     }
 
     function RelationalExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.RELATIONAL;
         var oldLoopInit = x.inForLoopInit;
 
         /*
@@ -1990,10 +2023,10 @@ Narcissus.parser = (function() {
         while ((t.match(LT) || t.match(LE) || t.match(GE) || t.match(GT) ||
                (oldLoopInit === false && t.match(IN)) ||
                t.match(INSTANCEOF))) {
-            n2 = b.RELATIONAL$build(t);
-            b.RELATIONAL$addOperand(n2, n);
-            b.RELATIONAL$addOperand(n2, ShiftExpression(t, x));
-            b.RELATIONAL$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, ShiftExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
         x.inForLoopInit = oldLoopInit;
@@ -2002,15 +2035,14 @@ Narcissus.parser = (function() {
     }
 
     function ShiftExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.SHIFT;
 
         n = AddExpression(t, x);
         while (t.match(LSH) || t.match(RSH) || t.match(URSH)) {
-            n2 = b.SHIFT$build(t);
-            b.SHIFT$addOperand(n2, n);
-            b.SHIFT$addOperand(n2, AddExpression(t, x));
-            b.SHIFT$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, AddExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -2018,15 +2050,14 @@ Narcissus.parser = (function() {
     }
 
     function AddExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.ADD;
 
         n = MultiplyExpression(t, x);
         while (t.match(PLUS) || t.match(MINUS)) {
-            n2 = b.ADD$build(t);
-            b.ADD$addOperand(n2, n);
-            b.ADD$addOperand(n2, MultiplyExpression(t, x));
-            b.ADD$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, MultiplyExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -2034,15 +2065,14 @@ Narcissus.parser = (function() {
     }
 
     function MultiplyExpression(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.MULTIPLY;
 
         n = UnaryExpression(t, x);
         while (t.match(MUL) || t.match(DIV) || t.match(MOD)) {
-            n2 = b.MULTIPLY$build(t);
-            b.MULTIPLY$addOperand(n2, n);
-            b.MULTIPLY$addOperand(n2, UnaryExpression(t, x));
-            b.MULTIPLY$finish(n2);
+            n2 = b.build(t);
+            b.addOperand(n2, n);
+            b.addOperand(n2, UnaryExpression(t, x));
+            b.finish(n2);
             n = n2;
         }
 
@@ -2050,21 +2080,20 @@ Narcissus.parser = (function() {
     }
 
     function UnaryExpression(t, x) {
-        var n, n2, tt;
-        var b = x.builder;
+        var n, n2, tt, b = x.builder.UNARY;
 
         switch (tt = t.get(true)) {
           case DELETE: case VOID: case TYPEOF:
           case NOT: case BITWISE_NOT: case PLUS: case MINUS:
-            n = b.UNARY$build(t);
-            b.UNARY$addOperand(n, UnaryExpression(t, x));
+            n = b.build(t);
+            b.addOperand(n, UnaryExpression(t, x));
             break;
 
           case INCREMENT:
           case DECREMENT:
             // Prefix increment/decrement.
-            n = b.UNARY$build(t)
-            b.UNARY$addOperand(n, MemberExpression(t, x, true));
+            n = b.build(t)
+            b.addOperand(n, MemberExpression(t, x, true));
             break;
 
           default:
@@ -2075,32 +2104,31 @@ Narcissus.parser = (function() {
             if (t.tokens[(t.tokenIndex + t.lookahead - 1) & 3].lineno ===
                 t.lineno) {
                 if (t.match(INCREMENT) || t.match(DECREMENT)) {
-                    n2 = b.UNARY$build(t);
-                    b.UNARY$setPostfix(n2);
-                    b.UNARY$finish(n);
-                    b.UNARY$addOperand(n2, n);
+                    n2 = b.build(t);
+                    b.setPostfix(n2);
+                    b.finish(n);
+                    b.addOperand(n2, n);
                     n = n2;
                 }
             }
             break;
         }
 
-        b.UNARY$finish(n);
+        b.finish(n);
         return n;
     }
 
     function MemberExpression(t, x, allowCallSyntax) {
-        var n, n2, tt;
-        var b = x.builder;
+        var n, n2, tt, b = x.builder.MEMBER;
 
         if (t.match(NEW)) {
-            n = b.MEMBER$build(t);
-            b.MEMBER$addOperand(n, MemberExpression(t, x, false));
+            n = b.build(t);
+            b.addOperand(n, MemberExpression(t, x, false));
             if (t.match(LEFT_PAREN)) {
-                b.MEMBER$rebuildNewWithArgs(n);
-                b.MEMBER$addOperand(n, ArgumentList(t, x));
+                b.rebuildNewWithArgs(n);
+                b.addOperand(n, ArgumentList(t, x));
             }
-            b.MEMBER$finish(n);
+            b.finish(n);
         } else {
             n = PrimaryExpression(t, x);
         }
@@ -2108,24 +2136,24 @@ Narcissus.parser = (function() {
         while ((tt = t.get()) !== END) {
             switch (tt) {
               case DOT:
-                n2 = b.MEMBER$build(t);
-                b.MEMBER$addOperand(n2, n);
+                n2 = b.build(t);
+                b.addOperand(n2, n);
                 t.mustMatch(IDENTIFIER);
-                b.MEMBER$addOperand(n2, b.MEMBER$build(t));
+                b.addOperand(n2, b.build(t));
                 break;
 
               case LEFT_BRACKET:
-                n2 = b.MEMBER$build(t, INDEX);
-                b.MEMBER$addOperand(n2, n);
-                b.MEMBER$addOperand(n2, Expression(t, x));
+                n2 = b.build(t, INDEX);
+                b.addOperand(n2, n);
+                b.addOperand(n2, Expression(t, x));
                 t.mustMatch(RIGHT_BRACKET);
                 break;
 
               case LEFT_PAREN:
                 if (allowCallSyntax) {
-                    n2 = b.MEMBER$build(t, CALL);
-                    b.MEMBER$addOperand(n2, n);
-                    b.MEMBER$addOperand(n2, ArgumentList(t, x));
+                    n2 = b.build(t, CALL);
+                    b.addOperand(n2, n);
+                    b.addOperand(n2, ArgumentList(t, x));
                     break;
                 }
 
@@ -2135,7 +2163,7 @@ Narcissus.parser = (function() {
                 return n;
             }
 
-            b.MEMBER$finish(n2);
+            b.finish(n2);
             n = n2;
         }
 
@@ -2143,11 +2171,10 @@ Narcissus.parser = (function() {
     }
 
     function ArgumentList(t, x) {
-        var n, n2;
-        var b = x.builder;
+        var n, n2, b = x.builder.LIST;
         var err = "expression must be parenthesized";
 
-        n = b.LIST$build(t);
+        n = b.build(t);
         if (t.match(RIGHT_PAREN, true))
             return n;
         do {
@@ -2159,17 +2186,22 @@ Narcissus.parser = (function() {
                 if (n.length > 1 || t.peek(true) === COMMA)
                     throw t.newSyntaxError("Generator " + err);
             }
-            b.LIST$addOperand(n, n2);
+            b.addOperand(n, n2);
         } while (t.match(COMMA));
         t.mustMatch(RIGHT_PAREN);
-        b.LIST$finish(n);
+        b.finish(n);
 
         return n;
     }
 
     function PrimaryExpression(t, x) {
         var n, n2, n3, tt = t.get(true);
-        var b = x.builder;
+        var builder = x.builder;
+        var bArrayInit = builder.ARRAY_INIT;
+        var bArrayComp = builder.ARRAY_COMP;
+        var bPrimary = builder.PRIMARY;
+        var bObjInit = builder.OBJECT_INIT;
+        var bPropInit = builder.PROPERTY_INIT;
 
         switch (tt) {
           case FUNCTION:
@@ -2177,14 +2209,14 @@ Narcissus.parser = (function() {
             break;
 
           case LEFT_BRACKET:
-            n = b.ARRAY_INIT$build(t);
+            n = bArrayInit.build(t);
             while ((tt = t.peek()) !== RIGHT_BRACKET) {
                 if (tt === COMMA) {
                     t.get();
-                    b.ARRAY_INIT$addElement(n, null);
+                    bArrayInit.addElement(n, null);
                     continue;
                 }
-                b.ARRAY_INIT$addElement(n, AssignExpression(t, x));
+                bArrayInit.addElement(n, AssignExpression(t, x));
                 if (tt !== COMMA && !t.match(COMMA))
                     break;
             }
@@ -2192,18 +2224,18 @@ Narcissus.parser = (function() {
             // If we matched exactly one element and got a FOR, we have an
             // array comprehension.
             if (n.length === 1 && t.match(FOR)) {
-                n2 = b.ARRAY_COMP$build(t);
-                b.ARRAY_COMP$setExpression(n2, n[0]);
-                b.ARRAY_COMP$setTail(n2, comprehensionTail(t, x));
+                n2 = bArrayComp.build(t);
+                bArrayComp.setExpression(n2, n[0]);
+                bArrayComp.setTail(n2, comprehensionTail(t, x));
                 n = n2;
             }
             t.mustMatch(RIGHT_BRACKET);
-            b.PRIMARY$finish(n);
+            bPrimary.finish(n);
             break;
 
           case LEFT_CURLY:
-            var id;
-            n = b.OBJECT_INIT$build(t);
+            var id, fd;
+            n = bObjInit.build(t);
 
           object_init:
             if (!t.match(RIGHT_CURLY)) {
@@ -2213,13 +2245,13 @@ Narcissus.parser = (function() {
                         t.peek() === IDENTIFIER) {
                         if (x.ecma3OnlyMode)
                             throw t.newSyntaxError("Illegal property accessor");
-                        var fd = FunctionDefinition(t, x, true, EXPRESSED_FORM);
-                        b.OBJECT_INIT$addProperty(n, fd);
+                        fd = FunctionDefinition(t, x, true, EXPRESSED_FORM);
+                        bObjInit.addProperty(n, fd);
                     } else {
                         switch (tt) {
                           case IDENTIFIER: case NUMBER: case STRING:
-                            id = b.PRIMARY$build(t, IDENTIFIER);
-                            b.PRIMARY$finish(id);
+                            id = bPrimary.build(t, IDENTIFIER);
+                            bPrimary.finish(id);
                             break;
                           case RIGHT_CURLY:
                             if (x.ecma3OnlyMode)
@@ -2227,30 +2259,30 @@ Narcissus.parser = (function() {
                             break object_init;
                           default:
                             if (t.token.value in definitions.keywords) {
-                                id = b.PRIMARY$build(t, IDENTIFIER);
-                                b.PRIMARY$finish(id);
+                                id = bPrimary.build(t, IDENTIFIER);
+                                bPrimary.finish(id);
                                 break;
                             }
                             throw t.newSyntaxError("Invalid property name");
                         }
                         if (t.match(COLON)) {
-                            n2 = b.PROPERTY_INIT$build(t);
-                            b.PROPERTY_INIT$addOperand(n2, id);
-                            b.PROPERTY_INIT$addOperand(n2, AssignExpression(t, x));
-                            b.PROPERTY_INIT$finish(n2);
-                            b.OBJECT_INIT$addProperty(n, n2);
+                            n2 = bPropInit.build(t);
+                            bPropInit.addOperand(n2, id);
+                            bPropInit.addOperand(n2, AssignExpression(t, x));
+                            bPropInit.finish(n2);
+                            bObjInit.addProperty(n, n2);
                         } else {
                             // Support, e.g., |var {x, y} = o| as destructuring shorthand
                             // for |var {x: x, y: y} = o|, per proposed JS2/ES4 for JS1.8.
                             if (t.peek() !== COMMA && t.peek() !== RIGHT_CURLY)
                                 throw t.newSyntaxError("missing : after property");
-                            b.OBJECT_INIT$addProperty(n, id);
+                            bObjInit.addProperty(n, id);
                         }
                     }
                 } while (t.match(COMMA));
                 t.mustMatch(RIGHT_CURLY);
             }
-            b.OBJECT_INIT$finish(n);
+            bObjInit.finish(n);
             break;
 
           case LEFT_PAREN:
@@ -2267,8 +2299,8 @@ Narcissus.parser = (function() {
 
           case NULL: case THIS: case TRUE: case FALSE:
           case IDENTIFIER: case NUMBER: case STRING: case REGEXP:
-            n = b.PRIMARY$build(t);
-            b.PRIMARY$finish(n);
+            n = bPrimary.build(t);
+            bPrimary.finish(n);
             break;
 
           default:
@@ -2294,7 +2326,9 @@ Narcissus.parser = (function() {
 
     return {
         parse: parse,
-        VanillaBuilder: VanillaBuilder,
+        Node: Node,
+        DefaultBuilder: DefaultBuilder,
+        bindSubBuilders: bindSubBuilders,
         DECLARED_FORM: DECLARED_FORM,
         EXPRESSED_FORM: EXPRESSED_FORM,
         STATEMENT_FORM: STATEMENT_FORM,