         fun += name.compile o if name
       return "#{fun}.apply(#{ref}, #{splatargs})"
     call = 'call(this)'
-    argvar = (n) -> n instanceof LiteralNode and n.value is 'arguments'
+    argvar = (node) -> node instanceof LiteralNode and node.value is 'arguments'
     for arg in @args when arg.contains argvar
       call = 'apply(this, arguments)'
       break
-    a = o.scope.freeVariable 'ctor'
-    b = o.scope.freeVariable 'ref'
-    c = o.scope.freeVariable 'result'
+    ctor   = o.scope.freeVariable 'ctor'
+    ref    = o.scope.freeVariable 'ref'
+    result = o.scope.freeVariable 'result'
     """
     (function() {
     #{idt = @idt 1}var ctor = function() {};
-    #{idt}#{utility 'extends'}(ctor, #{a} = #{ @variable.compile o });
-    #{idt}return typeof (#{c} = #{a}.apply(#{b} = new ctor, #{splatargs})) === "object" ? #{c} : #{b};
+    #{idt}#{utility 'extends'}(ctor, #{ctor} = #{ @variable.compile o });
+    #{idt}return typeof (#{result} = #{ctor}.apply(#{ref} = new ctor, #{splatargs})) === "object" ? #{result} : #{ref};
     #{@tab}}).#{call}
     """
 


# Faux-Nodes
# ----------

#### PushNode

# Faux-nodes are never created by the grammar, but are used during code
# generation to generate other combinations of nodes. The **PushNode** creates
# the tree for `array.push(value)`, which is helpful for recording the result
# arrays from comprehensions.
PushNode = exports.PushNode =
  wrap: (array, expressions) ->
    expr = expressions.unwrap()
    return expressions if expr.isPureStatement() or expr.containsPureStatement()
    Expressions.wrap([new CallNode(
      new ValueNode(literal(array), [new AccessorNode(literal('push'))]), [expr]
    )])

#### ClosureNode

# A faux-node used to wrap an expressions body in a closure.
ClosureNode = exports.ClosureNode =

  # Wrap the expressions body, unless it contains a pure statement,
  # in which case, no dice. If the body mentions `this` or `arguments`,
  # then make sure that the closure wrapper preserves the original values.
  wrap: (expressions, statement) ->
    return expressions if expressions.containsPureStatement()
    func = new ParentheticalNode(new CodeNode([], Expressions.wrap([expressions])))
    args = []
    mentionsArgs = expressions.contains (n) ->
      n instanceof LiteralNode and (n.value is 'arguments')
    mentionsThis = expressions.contains (n) ->
      (n instanceof LiteralNode and (n.value is 'this')) or
      (n instanceof CodeNode and n.bound)
    if mentionsArgs or mentionsThis
      meth = literal(if mentionsArgs then 'apply' else 'call')
      args = [literal('this')]
      args.push literal 'arguments' if mentionsArgs
      func = new ValueNode func, [new AccessorNode(meth)]
    call = new CallNode(func, args)
    if statement then Expressions.wrap([call]) else call

# Utility Functions
# -----------------

UTILITIES =

  # Correctly set up a prototype chain for inheritance, including a reference
  # to the superclass for `super()` calls. See:
  # [goog.inherits](http://closure-library.googlecode.com/svn/docs/closureGoogBase.js.source.html#line1206).
  extends:  """
            function(child, parent) {
                var ctor = function(){};
                ctor.prototype = parent.prototype;
                child.prototype = new ctor();
                child.prototype.constructor = child;
                if (typeof parent.extended === "function") parent.extended(child);
                child.__super__ = parent.prototype;
              }
            """

  # Create a function bound to the current value of "this".
  bind: """
        function(func, context) {
            return function(){ return func.apply(context, arguments); };
          }
        """

  # Shortcuts to speed up the lookup time for native functions.
  hasProp: 'Object.prototype.hasOwnProperty'
  slice:   'Array.prototype.slice'

# Constants
# ---------

# Tabs are two spaces for pretty printing.
TAB = '  '


  # equivalent syntax tree and compile that, in pieces. You can see the
  # constructor, property assignments, and inheritance getting built out below.
  compileNode: (o) ->
    {variable} = this
    variable   = literal o.scope.freeVariable 'ctor' if variable.value is '__temp__'
    extension  = @parent and new ExtendsNode variable, @parent
    props      = new Expressions
    o.top      = true
    me         = null
    className  = variable.compile o
    constScope = null

    if @parent
