spade 0.0.8.1 → 0.1.0

data/packages/coffee-script/src/nodes.coffee

@@ -1,1754 +0,0 @@
-# `nodes.coffee` contains all of the node classes for the syntax tree. Most
-# nodes are created as the result of actions in the [grammar](grammar.html),
-# but some are created by other nodes as a method of code generation. To convert
-# the syntax tree into a string of JavaScript code, call `compile()` on the root.
-
-{Scope} = require './scope'
-
-# Import the helpers we plan to use.
-{compact, flatten, extend, merge, del, starts, ends, last} = require './helpers'
-
-exports.extend = extend  # for parser
-
-# Constant functions for nodes that don't need customization.
-YES     = -> yes
-NO      = -> no
-THIS    = -> this
-NEGATE  = -> @negated = not @negated; this
-
-#### Base
-
-# The **Base** is the abstract base class for all nodes in the syntax tree.
-# Each subclass implements the `compileNode` method, which performs the
-# code generation for that node. To compile a node to JavaScript,
-# call `compile` on it, which wraps `compileNode` in some generic extra smarts,
-# to know when the generated code needs to be wrapped up in a closure.
-# An options hash is passed and cloned throughout, containing information about
-# the environment from higher in the tree (such as if a returned value is
-# being requested by the surrounding function), information about the current
-# scope, and indentation level.
-exports.Base = class Base
-
-  # Common logic for determining whether to wrap this node in a closure before
-  # compiling it, or to compile directly. We need to wrap if this node is a
-  # *statement*, and it's not a *pureStatement*, and we're not at
-  # the top level of a block (which would be unnecessary), and we haven't
-  # already been asked to return the result (because statements know how to
-  # return results).
-  compile: (o, lvl) ->
-    o        = extend {}, o
-    o.level  = lvl if lvl
-    node     = @unfoldSoak(o) or this
-    node.tab = o.indent
-    if o.level is LEVEL_TOP or not node.isStatement(o)
-      node.compileNode o
-    else
-      node.compileClosure o
-
-  # Statements converted into expressions via closure-wrapping share a scope
-  # object with their parent closure, to preserve the expected lexical scope.
-  compileClosure: (o) ->
-    if @jumps()
-      throw SyntaxError 'cannot use a pure statement in an expression.'
-    o.sharedScope = yes
-    Closure.wrap(this).compileNode o
-
-  # If the code generation wishes to use the result of a complex expression
-  # in multiple places, ensure that the expression is only ever evaluated once,
-  # by assigning it to a temporary variable. Pass a level to precompile.
-  cache: (o, level, reused) ->
-    unless @isComplex()
-      ref = if level then @compile o, level else this
-      [ref, ref]
-    else
-      ref = new Literal reused or o.scope.freeVariable 'ref'
-      sub = new Assign ref, this
-      if level then [sub.compile(o, level), ref.value] else [sub, ref]
-
-  # Compile to a source/variable pair suitable for looping.
-  compileLoopReference: (o, name) ->
-    src = tmp = @compile o, LEVEL_LIST
-    unless -Infinity < +src < Infinity or IDENTIFIER.test(src) and o.scope.check(src, yes)
-      src = "#{ tmp = o.scope.freeVariable name } = #{src}"
-    [src, tmp]
-
-  # Construct a node that returns the current node's result.
-  # Note that this is overridden for smarter behavior for
-  # many statement nodes (e.g. If, For)...
-  makeReturn: ->
-    new Return this
-
-  # Does this node, or any of its children, contain a node of a certain kind?
-  # Recursively traverses down the *children* of the nodes, yielding to a block
-  # and returning true when the block finds a match. `contains` does not cross
-  # scope boundaries.
-  contains: (pred) ->
-    contains = no
-    @traverseChildren no, (node) ->
-      if pred node
-        contains = yes
-        return no
-    contains
-
-  # Is this node of a certain type, or does it contain the type?
-  containsType: (type) ->
-    this instanceof type or @contains (node) -> node instanceof type
-
-  # Pull out the last non-comment node of a node list.
-  lastNonComment: (list) ->
-    i = list.length
-    return list[i] while i-- when list[i] not instanceof Comment
-    null
-
-  # `toString` representation of the node, for inspecting the parse tree.
-  # This is what `coffee --nodes` prints out.
-  toString: (idt = '', name = @constructor.name) ->
-    tree = '\n' + idt + name
-    tree += '?' if @soak
-    @eachChild (node) -> tree += node.toString idt + TAB
-    tree
-
-  # Passes each child to a function, breaking when the function returns `false`.
-  eachChild: (func) ->
-    return this unless @children
-    for attr in @children when @[attr]
-      for child in flatten [@[attr]]
-        return this if func(child) is false
-    this
-
-  traverseChildren: (crossScope, func) ->
-    @eachChild (child) ->
-      return false if func(child) is false
-      child.traverseChildren crossScope, func
-
-  invert: ->
-    new Op '!', this
-
-  unwrapAll: ->
-    node = this
-    continue until node is node = node.unwrap()
-    node
-
-  # Default implementations of the common node properties and methods. Nodes
-  # will override these with custom logic, if needed.
-  children: []
-
-  isStatement     : NO
-  jumps           : NO
-  isComplex       : YES
-  isChainable     : NO
-  isAssignable    : NO
-
-  unwrap     : THIS
-  unfoldSoak : NO
-
-  # Is this node used to assign a certain variable?
-  assigns: NO
-
-#### Expressions
-
-# The expressions body is the list of expressions that forms the body of an
-# indented block of code -- the implementation of a function, a clause in an
-# `if`, `switch`, or `try`, and so on...
-exports.Expressions = class Expressions extends Base
-  constructor: (nodes) ->
-    @expressions = compact flatten nodes or []
-
-  children: ['expressions']
-
-  # Tack an expression on to the end of this expression list.
-  push: (node) ->
-    @expressions.push node
-    this
-
-  # Remove and return the last expression of this expression list.
-  pop: ->
-    @expressions.pop()
-
-  # Add an expression at the beginning of this expression list.
-  unshift: (node) ->
-    @expressions.unshift node
-    this
-
-  # If this Expressions consists of just a single node, unwrap it by pulling
-  # it back out.
-  unwrap: ->
-    if @expressions.length is 1 then @expressions[0] else this
-
-  # Is this an empty block of code?
-  isEmpty: ->
-    not @expressions.length
-
-  isStatement: (o) ->
-    for exp in @expressions when exp.isStatement o
-      return yes
-    no
-
-  jumps: (o) ->
-    for exp in @expressions
-      return exp if exp.jumps o
-
-  # An Expressions node does not return its entire body, rather it
-  # ensures that the final expression is returned.
-  makeReturn: ->
-    len = @expressions.length
-    while len--
-      expr = @expressions[len]
-      if expr not instanceof Comment
-        @expressions[len] = expr.makeReturn()
-        break
-    this
-
-  # An **Expressions** is the only node that can serve as the root.
-  compile: (o = {}, level) ->
-    if o.scope then super o, level else @compileRoot o
-
-  # Compile all expressions within the **Expressions** body. If we need to
-  # return the result, and it's an expression, simply return it. If it's a
-  # statement, ask the statement to do so.
-  compileNode: (o) ->
-    @tab  = o.indent
-    top   = o.level is LEVEL_TOP
-    codes = []
-    for node in @expressions
-      node = node.unwrapAll()
-      node = (node.unfoldSoak(o) or node)
-      if top
-        node.front = true
-        code = node.compile o
-        codes.push if node.isStatement o then code else @tab + code + ';'
-      else
-        codes.push node.compile o, LEVEL_LIST
-    return codes.join '\n' if top
-    code = codes.join(', ') or 'void 0'
-    if codes.length > 1 and o.level >= LEVEL_LIST then "(#{code})" else code
-
-  # If we happen to be the top-level **Expressions**, wrap everything in
-  # a safety closure, unless requested not to.
-  # It would be better not to generate them in the first place, but for now,
-  # clean up obvious double-parentheses.
-  compileRoot: (o) ->
-    o.indent = @tab = if o.bare then '' else TAB
-    o.scope  = new Scope null, this, null
-    o.level  = LEVEL_TOP
-    code     = @compileWithDeclarations o
-    code     = code.replace TRAILING_WHITESPACE, ''
-    if o.bare then code else "(function() {\n#{code}\n}).call(this);\n"
-
-  # Compile the expressions body for the contents of a function, with
-  # declarations of all inner variables pushed up to the top.
-  compileWithDeclarations: (o) ->
-    code = post = ''
-    for exp, i in @expressions
-      exp = exp.unwrap()
-      break unless exp instanceof Comment or exp instanceof Literal
-    o = merge(o, level: LEVEL_TOP)
-    if i
-      rest = @expressions.splice i, @expressions.length
-      code = @compileNode o
-      @expressions = rest
-    post = @compileNode o
-    {scope} = o
-    if scope.expressions is this
-      if not o.globals and o.scope.hasDeclarations()
-        code += "#{@tab}var #{ scope.declaredVariables().join(', ') };\n"
-      if scope.hasAssignments
-        code += "#{@tab}var #{ multident scope.assignedVariables().join(', '), @tab };\n"
-    code + post
-
-  # Wrap up the given nodes as an **Expressions**, unless it already happens
-  # to be one.
-  @wrap: (nodes) ->
-    return nodes[0] if nodes.length is 1 and nodes[0] instanceof Expressions
-    new Expressions nodes
-
-#### Literal
-
-# Literals are static values that can be passed through directly into
-# JavaScript without translation, such as: strings, numbers,
-# `true`, `false`, `null`...
-exports.Literal = class Literal extends Base
-  constructor: (@value) ->
-
-  makeReturn: ->
-    if @isStatement() then this else new Return this
-
-  isAssignable: ->
-    IDENTIFIER.test @value
-
-  isStatement: ->
-    @value in ['break', 'continue', 'debugger']
-
-  isComplex: NO
-
-  assigns: (name) ->
-    name is @value
-
-  jumps: (o) ->
-    return no unless @isStatement()
-    if not (o and (o.loop or o.block and (@value isnt 'continue'))) then this else no
-
-  compileNode: (o) ->
-    code = if @value.reserved then "\"#{@value}\"" else @value
-    if @isStatement() then "#{@tab}#{code};" else code
-
-  toString: ->
-    ' "' + @value + '"'
-
-#### Return
-
-# A `return` is a *pureStatement* -- wrapping it in a closure wouldn't
-# make sense.
-exports.Return = class Return extends Base
-  constructor: (@expression) ->
-
-  children: ['expression']
-
-  isStatement:     YES
-  makeReturn:      THIS
-  jumps:           THIS
-
-  compile: (o, level) ->
-    expr = @expression?.makeReturn()
-    if expr and expr not instanceof Return then expr.compile o, level else super o, level
-
-  compileNode: (o) ->
-    @tab + "return#{ if @expression then ' ' + @expression.compile(o, LEVEL_PAREN) else '' };"
-
-#### Value
-
-# A value, variable or literal or parenthesized, indexed or dotted into,
-# or vanilla.
-exports.Value = class Value extends Base
-  constructor: (base, props, tag) ->
-    return base if not props and base instanceof Value
-    @base       = base
-    @properties = props or []
-    @[tag]      = true if tag
-    return this
-
-  children: ['base', 'properties']
-
-  # Add a property access to the list.
-  push: (prop) ->
-    @properties.push prop
-    this
-
-  hasProperties: ->
-    !!@properties.length
-
-  # Some boolean checks for the benefit of other nodes.
-  isArray        : -> not @properties.length and @base instanceof Arr
-  isComplex      : -> @hasProperties() or @base.isComplex()
-  isAssignable   : -> @hasProperties() or @base.isAssignable()
-  isSimpleNumber : -> @base instanceof Literal and SIMPLENUM.test @base.value
-  isAtomic       : ->
-    for node in @properties.concat @base
-      return no if node.soak or node instanceof Call
-    yes
-
-  isStatement : (o)    -> not @properties.length and @base.isStatement o
-  assigns     : (name) -> not @properties.length and @base.assigns name
-  jumps       : (o)    -> not @properties.length and @base.jumps o
-
-  isObject: (onlyGenerated) ->
-    return no if @properties.length
-    (@base instanceof Obj) and (not onlyGenerated or @base.generated)
-
-  isSplice: ->
-    last(@properties) instanceof Slice
-
-  makeReturn: ->
-    if @properties.length then super() else @base.makeReturn()
-
-  # The value can be unwrapped as its inner node, if there are no attached
-  # properties.
-  unwrap: ->
-    if @properties.length then this else @base
-
-  # A reference has base part (`this` value) and name part.
-  # We cache them separately for compiling complex expressions.
-  # `a()[b()] ?= c` -> `(_base = a())[_name = b()] ? _base[_name] = c`
-  cacheReference: (o) ->
-    name = last @properties
-    if @properties.length < 2 and not @base.isComplex() and not name?.isComplex()
-      return [this, this]  # `a` `a.b`
-    base = new Value @base, @properties.slice 0, -1
-    if base.isComplex()  # `a().b`
-      bref = new Literal o.scope.freeVariable 'base'
-      base = new Value new Parens new Assign bref, base
-    return [base, bref] unless name  # `a()`
-    if name.isComplex()  # `a[b()]`
-      nref = new Literal o.scope.freeVariable 'name'
-      name = new Index new Assign nref, name.index
-      nref = new Index nref
-    [base.push(name), new Value(bref or base.base, [nref or name])]
-
-  # We compile a value to JavaScript by compiling and joining each property.
-  # Things get much more interesting if the chain of properties has *soak*
-  # operators `?.` interspersed. Then we have to take care not to accidentally
-  # evaluate anything twice when building the soak chain.
-  compileNode: (o) ->
-    @base.front = @front
-    props = @properties
-    code  = @base.compile o, if props.length then LEVEL_ACCESS else null
-    code  = "(#{code})" if props[0] instanceof Access and @isSimpleNumber()
-    code += prop.compile o for prop in props
-    code
-
-  # Unfold a soak into an `If`: `a?.b` -> `a.b if a?`
-  unfoldSoak: (o) ->
-    if ifn = @base.unfoldSoak o
-      Array::push.apply ifn.body.properties, @properties
-      return ifn
-    for prop, i in @properties when prop.soak
-      prop.soak = off
-      fst = new Value @base, @properties.slice 0, i
-      snd = new Value @base, @properties.slice i
-      if fst.isComplex()
-        ref = new Literal o.scope.freeVariable 'ref'
-        fst = new Parens new Assign ref, fst
-        snd.base = ref
-      return new If new Existence(fst), snd, soak: on
-    null
-
-#### Comment
-
-# CoffeeScript passes through block comments as JavaScript block comments
-# at the same position.
-exports.Comment = class Comment extends Base
-  constructor: (@comment) ->
-
-  isStatement:     YES
-  makeReturn:      THIS
-
-  compileNode: (o, level) ->
-    code = '/*' + multident(@comment, @tab) + '*/'
-    code = o.indent + code if (level or o.level) is LEVEL_TOP
-    code
-
-#### Call
-
-# Node for a function invocation. Takes care of converting `super()` calls into
-# calls against the prototype's function of the same name.
-exports.Call = class Call extends Base
-  constructor: (variable, @args = [], @soak) ->
-    @isNew    = false
-    @isSuper  = variable is 'super'
-    @variable = if @isSuper then null else variable
-
-  children: ['variable', 'args']
-
-  # Tag this invocation as creating a new instance.
-  newInstance: ->
-    base = @variable.base or @variable
-    if base instanceof Call
-      base.newInstance()
-    else
-      @isNew = true
-    this
-
-  # Grab the reference to the superclass's implementation of the current
-  # method.
-  superReference: (o) ->
-    {method} = o.scope
-    throw SyntaxError 'cannot call super outside of a function.' unless method
-    {name} = method
-    throw SyntaxError 'cannot call super on an anonymous function.' unless name
-    if method.klass
-      "#{method.klass}.__super__.#{name}"
-    else
-      "#{name}.__super__.constructor"
-
-  # Soaked chained invocations unfold into if/else ternary structures.
-  unfoldSoak: (o) ->
-    if @soak
-      if @variable
-        return ifn if ifn = unfoldSoak o, this, 'variable'
-        [left, rite] = new Value(@variable).cacheReference o
-      else
-        left = new Literal @superReference o
-        rite = new Value left
-      rite = new Call rite, @args
-      rite.isNew = @isNew
-      left = new Literal "typeof #{ left.compile o } === \"function\""
-      return new If left, new Value(rite), soak: yes
-    call = this
-    list = []
-    loop
-      if call.variable instanceof Call
-        list.push call
-        call = call.variable
-        continue
-      break unless call.variable instanceof Value
-      list.push call
-      break unless (call = call.variable.base) instanceof Call
-    for call in list.reverse()
-      if ifn
-        if call.variable instanceof Call
-          call.variable = ifn
-        else
-          call.variable.base = ifn
-      ifn = unfoldSoak o, call, 'variable'
-    ifn
-
-  # Compile a vanilla function call.
-  compileNode: (o) ->
-    @variable?.front = @front
-    if code = Splat.compileSplattedArray o, @args, true
-      return @compileSplat o, code
-    args = (arg.compile o, LEVEL_LIST for arg in @args).join ', '
-    if @isSuper
-      @superReference(o) + ".call(this#{ args and ', ' + args })"
-    else
-      (if @isNew then 'new ' else '') + @variable.compile(o, LEVEL_ACCESS) + "(#{args})"
-
-  # `super()` is converted into a call against the superclass's implementation
-  # of the current function.
-  compileSuper: (args, o) ->
-    "#{@superReference(o)}.call(this#{ if args.length then ', ' else '' }#{args})"
-
-  # If you call a function with a splat, it's converted into a JavaScript
-  # `.apply()` call to allow an array of arguments to be passed.
-  # If it's a constructor, then things get real tricky. We have to inject an
-  # inner constructor in order to be able to pass the varargs.
-  compileSplat: (o, splatArgs) ->
-    return "#{ @superReference o }.apply(this, #{splatArgs})" if @isSuper
-    if @isNew
-      idt = @tab + TAB
-      return """
-		(function(func, args, ctor) {
-		#{idt}ctor.prototype = func.prototype;
-		#{idt}var child = new ctor, result = func.apply(child, args);
-		#{idt}return typeof result === "object" ? result : child;
-		#{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function() {})
-      """
-    base = new Value @variable
-    if (name = base.properties.pop()) and base.isComplex()
-      ref = o.scope.freeVariable 'ref'
-      fun = "(#{ref} = #{ base.compile o, LEVEL_LIST })#{ name.compile o }"
-    else
-      fun = base.compile o, LEVEL_ACCESS
-      if name
-        ref = fun
-        fun += name.compile o
-      else
-        ref = 'null'
-    "#{fun}.apply(#{ref}, #{splatArgs})"
-
-#### Extends
-
-# Node to extend an object's prototype with an ancestor object.
-# After `goog.inherits` from the
-# [Closure Library](http://closure-library.googlecode.com/svn/docs/closureGoogBase.js.html).
-exports.Extends = class Extends extends Base
-  constructor: (@child, @parent) ->
-
-  children: ['child', 'parent']
-
-  # Hooks one constructor into another's prototype chain.
-  compile: (o) ->
-    utility 'hasProp'
-    new Call(new Value(new Literal utility 'extends'), [@child, @parent]).compile o
-
-#### Access
-
-# A `.` access into a property of a value, or the `::` shorthand for
-# an access into the object's prototype.
-exports.Access = class Access extends Base
-  constructor: (@name, tag) ->
-    @name.asKey = yes
-    @proto = if tag is 'proto' then '.prototype' else ''
-    @soak  = tag is 'soak'
-
-  children: ['name']
-
-  compile: (o) ->
-    name = @name.compile o
-    @proto + if IS_STRING.test name then "[#{name}]" else ".#{name}"
-
-  isComplex: NO
-
-#### Index
-
-# A `[ ... ]` indexed access into an array or object.
-exports.Index = class Index extends Base
-  constructor: (@index) ->
-
-  children: ['index']
-
-  compile: (o) ->
-    (if @proto then '.prototype' else '') + "[#{ @index.compile o, LEVEL_PAREN }]"
-
-  isComplex: ->
-    @index.isComplex()
-
-#### Range
-
-# A range literal. Ranges can be used to extract portions (slices) of arrays,
-# to specify a range for comprehensions, or as a value, to be expanded into the
-# corresponding array of integers at runtime.
-exports.Range = class Range extends Base
-
-  children: ['from', 'to']
-
-  constructor: (@from, @to, tag) ->
-    @exclusive = tag is 'exclusive'
-    @equals = if @exclusive then '' else '='
-
-  # Compiles the range's source variables -- where it starts and where it ends.
-  # But only if they need to be cached to avoid double evaluation.
-  compileVariables: (o) ->
-    o = merge(o, top: true)
-    [@from, @fromVar] =  @from.cache o, LEVEL_LIST
-    [@to, @toVar] =      @to.cache o, LEVEL_LIST
-    [@fromNum, @toNum] = [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]
-    parts = []
-    parts.push @from if @from isnt @fromVar
-    parts.push @to if @to isnt @toVar
-
-  # When compiled normally, the range returns the contents of the *for loop*
-  # needed to iterate over the values in the range. Used by comprehensions.
-  compileNode: (o) ->
-    @compileVariables o
-    return    @compileArray(o)  unless o.index
-    return    @compileSimple(o) if @fromNum and @toNum
-    idx      = del o, 'index'
-    step     = del o, 'step'
-    vars     = "#{idx} = #{@from}" + if @to isnt @toVar then ", #{@to}" else ''
-    intro    = "(#{@fromVar} <= #{@toVar} ? #{idx}"
-    compare  = "#{intro} <#{@equals} #{@toVar} : #{idx} >#{@equals} #{@toVar})"
-    stepPart = if step then step.compile(o) else '1'
-    incr     = if step then "#{idx} += #{stepPart}" else "#{intro} += #{stepPart} : #{idx} -= #{stepPart})"
-    "#{vars}; #{compare}; #{incr}"
-
-  # Compile a simple range comprehension, with integers.
-  compileSimple: (o) ->
-    [from, to] = [+@fromNum, +@toNum]
-    idx        = del o, 'index'
-    step       = del o, 'step'
-    step       and= "#{idx} += #{step.compile(o)}"
-    if from <= to
-      "#{idx} = #{from}; #{idx} <#{@equals} #{to}; #{step or "#{idx}++"}"
-    else
-      "#{idx} = #{from}; #{idx} >#{@equals} #{to}; #{step or "#{idx}--"}"
-
-  # When used as a value, expand the range into the equivalent array.
-  compileArray: (o) ->
-    if @fromNum and @toNum and Math.abs(@fromNum - @toNum) <= 20
-      range = [+@fromNum..+@toNum]
-      range.pop() if @exclusive
-      return "[#{ range.join(', ') }]"
-    idt    = @tab + TAB
-    i      = o.scope.freeVariable 'i'
-    result = o.scope.freeVariable 'results'
-    pre    = "\n#{idt}#{result} = [];"
-    if @fromNum and @toNum
-      o.index = i
-      body = @compileSimple o
-    else
-      vars = "#{i} = #{@from}" + if @to isnt @toVar then ", #{@to}" else ''
-      clause = "#{@fromVar} <= #{@toVar} ?"
-      body   = "var #{vars}; #{clause} #{i} <#{@equals} #{@toVar} : #{i} >#{@equals} #{@toVar}; #{clause} #{i} += 1 : #{i} -= 1"
-    post   = "{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}"
-    "(function() {#{pre}\n#{idt}for (#{body})#{post}}).call(this)"
-
-#### Slice
-
-# An array slice literal. Unlike JavaScript's `Array#slice`, the second parameter
-# specifies the index of the end of the slice, just as the first parameter
-# is the index of the beginning.
-exports.Slice = class Slice extends Base
-
-  children: ['range']
-
-  constructor: (@range) ->
-    super()
-
-  # We have to be careful when trying to slice through the end of the array,
-  # `9e9` is used because not all implementations respect `undefined` or `1/0`.
-  # `9e9` should be safe because `9e9` > `2**32`, the max array length.
-  compileNode: (o) ->
-    {to, from} = @range
-    fromStr    = from and from.compile(o, LEVEL_PAREN) or '0'
-    compiled   = to and to.compile o, LEVEL_PAREN
-    if to and not (not @range.exclusive and +compiled is -1)
-      toStr = ', ' + if @range.exclusive
-        compiled
-      else if SIMPLENUM.test compiled
-        (+compiled + 1).toString()
-      else
-        "(#{compiled} + 1) || 9e9"
-    ".slice(#{ fromStr }#{ toStr or '' })"
-
-#### Obj
-
-# An object literal, nothing fancy.
-exports.Obj = class Obj extends Base
-  constructor: (props, @generated = false) ->
-    @objects = @properties = props or []
-
-  children: ['properties']
-
-  compileNode: (o) ->
-    props = @properties
-    return (if @front then '({})' else '{}') unless props.length
-    idt         = o.indent += TAB
-    lastNoncom  = @lastNonComment @properties
-    props = for prop, i in props
-      join = if i is props.length - 1
-        ''
-      else if prop is lastNoncom or prop instanceof Comment
-        '\n'
-      else
-        ',\n'
-      indent = if prop instanceof Comment then '' else idt
-      if prop instanceof Value and prop.this
-        prop = new Assign prop.properties[0].name, prop, 'object'
-      if prop not instanceof Comment
-        if prop not instanceof Assign
-          prop = new Assign prop, prop, 'object'
-        (prop.variable.base or prop.variable).asKey = yes
-      indent + prop.compile(o, LEVEL_TOP) + join
-    props = props.join ''
-    obj   = "{#{ props and '\n' + props + '\n' + @tab }}"
-    if @front then "(#{obj})" else obj
-
-  assigns: (name) ->
-    for prop in @properties when prop.assigns name then return yes
-    no
-
-#### Arr
-
-# An array literal.
-exports.Arr = class Arr extends Base
-  constructor: (objs) ->
-    @objects = objs or []
-
-  children: ['objects']
-
-  compileNode: (o) ->
-    return '[]' unless @objects.length
-    o.indent += TAB
-    return code if code = Splat.compileSplattedArray o, @objects
-    code = (obj.compile o, LEVEL_LIST for obj in @objects).join ', '
-    if code.indexOf('\n') >= 0
-      "[\n#{o.indent}#{code}\n#{@tab}]"
-    else
-      "[#{code}]"
-
-  assigns: (name) ->
-    for obj in @objects when obj.assigns name then return yes
-    no
-
-#### Class
-
-# The CoffeeScript class definition.
-# Initialize a **Class** with its name, an optional superclass, and a
-# list of prototype property assignments.
-exports.Class = class Class extends Base
-  constructor: (@variable, @parent, @body = new Expressions) ->
-    @boundFuncs = []
-    @body.classBody = yes
-
-  children: ['variable', 'parent', 'body']
-
-  # Figure out the appropriate name for the constructor function of this class.
-  determineName: ->
-    return null unless @variable
-    decl = if tail = last @variable.properties
-      tail instanceof Access and tail.name.value
-    else
-      @variable.base.value
-    decl and= IDENTIFIER.test(decl) and decl
-
-  # For all `this`-references and bound functions in the class definition,
-  # `this` is the Class being constructed.
-  setContext: (name) ->
-    @body.traverseChildren false, (node) ->
-      return false if node.classBody
-      if node instanceof Literal and node.value is 'this'
-        node.value    = name
-      else if node instanceof Code
-        node.klass    = name
-        node.context  = name if node.bound
-
-  # Ensure that all functions bound to the instance are proxied in the
-  # constructor.
-  addBoundFunctions: (o) ->
-    if @boundFuncs.length
-      for bvar in @boundFuncs
-        bname = bvar.compile o
-        @ctor.body.unshift new Literal "this.#{bname} = #{utility 'bind'}(this.#{bname}, this);"
-
-  # Merge the properties from a top-level object as prototypal properties
-  # on the class.
-  addProperties: (node, name) ->
-    props = node.base.properties.slice 0
-    while assign = props.shift()
-      if assign instanceof Assign
-        base = assign.variable.base
-        delete assign.context
-        func = assign.value
-        if base.value is 'constructor'
-          if @ctor
-            throw new Error 'cannot define more than one constructor in a class'
-          if func.bound
-            throw new Error 'cannot define a constructor as a bound function'
-          if func instanceof Code
-            assign = @ctor = func
-          else
-            assign = @ctor = new Assign(new Value(new Literal name), func)
-        else
-          unless assign.variable.this
-            assign.variable = new Value(new Literal(name), [new Access(base, 'proto')])
-          if func instanceof Code and func.bound
-            @boundFuncs.push base
-            func.bound = no
-      assign
-
-  # Walk the body of the class, looking for prototype properties to be converted.
-  walkBody: (name) ->
-    @traverseChildren false, (child) =>
-      return false if child instanceof Class
-      if child instanceof Expressions
-        for node, i in exps = child.expressions
-          if node instanceof Value and node.isObject(true)
-            exps[i] = @addProperties node, name
-        child.expressions = exps = flatten exps
-
-  # Make sure that a constructor is defined for the class, and properly
-  # configured.
-  ensureConstructor: (name) ->
-    if not @ctor
-      @ctor = new Code
-      @ctor.body.push new Call 'super', [new Splat new Literal 'arguments'] if @parent
-      @body.expressions.unshift @ctor
-    @ctor.ctor     = @ctor.name = name
-    @ctor.klass    = null
-    @ctor.noReturn = yes
-
-  # Instead of generating the JavaScript string directly, we build up the
-  # equivalent syntax tree and compile that, in pieces. You can see the
-  # constructor, property assignments, and inheritance getting built out below.
-  compileNode: (o) ->
-    decl  = @determineName()
-    name  = decl or @name or '_Class'
-    lname = new Literal name
-
-    @setContext name
-    @walkBody name
-    @body.expressions.unshift new Extends lname, @parent if @parent
-    @ensureConstructor name
-    @body.expressions.push lname
-    @addBoundFunctions o
-
-    klass = new Parens Closure.wrap(@body), true
-    klass = new Assign @variable, klass if @variable
-    klass.compile o
-
-#### Assign
-
-# The **Assign** is used to assign a local variable to value, or to set the
-# property of an object -- including within object literals.
-exports.Assign = class Assign extends Base
-  constructor: (@variable, @value, @context, options) ->
-    @param = options and options.param
-
-  # Matchers for detecting class/method names
-  METHOD_DEF: /^(?:(\S+)\.prototype\.|\S+?)?\b([$A-Za-z_][$\w]*)$/
-
-  children: ['variable', 'value']
-
-  assigns: (name) ->
-    @[if @context is 'object' then 'value' else 'variable'].assigns name
-
-  unfoldSoak: (o) ->
-    unfoldSoak o, this, 'variable'
-
-  # Compile an assignment, delegating to `compilePatternMatch` or
-  # `compileSplice` if appropriate. Keep track of the name of the base object
-  # we've been assigned to, for correct internal references. If the variable
-  # has not been seen yet within the current scope, declare it.
-  compileNode: (o) ->
-    if isValue = @variable instanceof Value
-      return @compilePatternMatch o if @variable.isArray() or @variable.isObject()
-      return @compileSplice       o if @variable.isSplice()
-      return @compileConditional  o if @context in ['||=', '&&=', '?=']
-    name = @variable.compile o, LEVEL_LIST
-    if @value instanceof Code and match = @METHOD_DEF.exec name
-      @value.name  = match[2]
-      @value.klass = match[1] if match[1]
-    val = @value.compile o, LEVEL_LIST
-    return "#{name}: #{val}" if @context is 'object'
-    unless @variable.isAssignable()
-      throw SyntaxError "\"#{ @variable.compile o }\" cannot be assigned."
-    unless @context or isValue and (@variable.namespaced or @variable.hasProperties())
-      if @param
-        o.scope.add name, 'var'
-      else
-        o.scope.find name
-    val = name + " #{ @context or '=' } " + val
-    if o.level <= LEVEL_LIST then val else "(#{val})"
-
-  # Brief implementation of recursive pattern matching, when assigning array or
-  # object literals to a value. Peeks at their properties to assign inner names.
-  # See the [ECMAScript Harmony Wiki](http://wiki.ecmascript.org/doku.php?id=harmony:destructuring)
-  # for details.
-  compilePatternMatch: (o) ->
-    top       = o.level is LEVEL_TOP
-    {value}   = this
-    {objects} = @variable.base
-    return value.compile o unless olen = objects.length
-    isObject = @variable.isObject()
-    if top and olen is 1 and (obj = objects[0]) not instanceof Splat
-      # Unroll simplest cases: `{v} = x` -> `v = x.v`
-      if obj instanceof Assign
-        {variable: {base: idx}, value: obj} = obj
-      else
-        if obj.base instanceof Parens
-          [obj, idx] = new Value(obj.unwrapAll()).cacheReference o
-        else
-          idx = if isObject
-            if obj.this then obj.properties[0].name else obj
-          else
-            new Literal 0
-      acc   = IDENTIFIER.test idx.unwrap().value or 0
-      value = new Value value
-      value.properties.push new (if acc then Access else Index) idx
-      return new Assign(obj, value).compile o
-    vvar    = value.compile o, LEVEL_LIST
-    assigns = []
-    splat   = false
-    if not IDENTIFIER.test(vvar) or @variable.assigns(vvar)
-      assigns.push "#{ ref = o.scope.freeVariable 'ref' } = #{vvar}"
-      vvar = ref
-    for obj, i in objects
-      # A regular array pattern-match.
-      idx = i
-      if isObject
-        if obj instanceof Assign
-          # A regular object pattern-match.
-          {variable: {base: idx}, value: obj} = obj
-        else
-          # A shorthand `{a, b, @c} = val` pattern-match.
-          if obj.base instanceof Parens
-            [obj, idx] = new Value(obj.unwrapAll()).cacheReference o
-          else
-            idx = if obj.this then obj.properties[0].name else obj
-      if not splat and obj instanceof Splat
-        val = "#{olen} <= #{vvar}.length ? #{ utility 'slice' }.call(#{vvar}, #{i}"
-        if rest = olen - i - 1
-          ivar = o.scope.freeVariable 'i'
-          val += ", #{ivar} = #{vvar}.length - #{rest}) : (#{ivar} = #{i}, [])"
-        else
-          val += ") : []"
-        val   = new Literal val
-        splat = "#{ivar}++"
-      else
-        if obj instanceof Splat
-          obj = obj.name.compile o
-          throw SyntaxError \
-            "multiple splats are disallowed in an assignment: #{obj} ..."
-        if typeof idx is 'number'
-          idx = new Literal splat or idx
-          acc = no
-        else
-          acc = isObject and IDENTIFIER.test idx.unwrap().value or 0
-        val = new Value new Literal(vvar), [new (if acc then Access else Index) idx]
-      assigns.push new Assign(obj, val, null, param: @param).compile o, LEVEL_TOP
-    assigns.push vvar unless top
-    code = assigns.join ', '
-    if o.level < LEVEL_LIST then code else "(#{code})"
-
-  # When compiling a conditional assignment, take care to ensure that the
-  # operands are only evaluated once, even though we have to reference them
-  # more than once.
-  compileConditional: (o) ->
-    [left, rite] = @variable.cacheReference o
-    new Op(@context.slice(0, -1), left, new Assign(rite, @value, '=')).compile o
-
-  # Compile the assignment from an array splice literal, using JavaScript's
-  # `Array#splice` method.
-  compileSplice: (o) ->
-    {range: {from, to, exclusive}} = @variable.properties.pop()
-    name = @variable.compile o
-    [fromDecl, fromRef] = from?.cache(o, LEVEL_OP) or ['0', '0']
-    if to
-      if from?.isSimpleNumber() and to.isSimpleNumber()
-        to = +to.compile(o) - +fromRef
-        to += 1 unless exclusive
-      else
-        to = to.compile(o) + ' - ' + fromRef
-        to += ' + 1' unless exclusive
-    else
-      to = "9e9"
-    [valDef, valRef] = @value.cache o, LEVEL_LIST
-    code = "[].splice.apply(#{name}, [#{fromDecl}, #{to}].concat(#{valDef})), #{valRef}"
-    if o.level > LEVEL_TOP then "(#{code})" else code
-
-#### Code
-
-# A function definition. This is the only node that creates a new Scope.
-# When for the purposes of walking the contents of a function body, the Code
-# has no *children* -- they're within the inner scope.
-exports.Code = class Code extends Base
-  constructor: (params, body, tag) ->
-    @params  = params or []
-    @body    = body or new Expressions
-    @bound   = tag is 'boundfunc'
-    @context = 'this' if @bound
-
-  children: ['params', 'body']
-
-  isStatement: -> !!@ctor
-
-  jumps: NO
-
-  # Compilation creates a new scope unless explicitly asked to share with the
-  # outer scope. Handles splat parameters in the parameter list by peeking at
-  # the JavaScript `arguments` objects. If the function is bound with the `=>`
-  # arrow, generates a wrapper that saves the current value of `this` through
-  # a closure.
-  compileNode: (o) ->
-    o.scope         = new Scope o.scope, @body, this
-    o.scope.shared  = del o, 'sharedScope'
-    o.indent        += TAB
-    delete o.bare
-    delete o.globals
-    vars   = []
-    exprs  = []
-    for param in @params when param.splat
-      splats = new Assign new Value(new Arr(p.asReference o for p in @params)),
-                          new Value new Literal 'arguments'
-      break
-    for param in @params
-      if param.isComplex()
-        val = ref = param.asReference o
-        val = new Op '?', ref, param.value if param.value
-        exprs.push new Assign new Value(param.name), val, '=', param: yes
-      else
-        ref = param
-        if param.value
-          lit = new Literal ref.name.value + ' == null'
-          val = new Assign new Value(param.name), param.value, '='
-          exprs.push new If lit, val
-      vars.push ref unless splats
-    wasEmpty = @body.isEmpty()
-    exprs.unshift splats if splats
-    @body.expressions.unshift exprs... if exprs.length
-    o.scope.parameter vars[i] = v.compile o for v, i in vars unless splats
-    @body.makeReturn() unless wasEmpty or @noReturn
-    idt   = o.indent
-    code  = 'function'
-    code  += ' ' + @name if @ctor
-    code  += '(' + vars.join(', ') + ') {'
-    code  += "\n#{ @body.compileWithDeclarations o }\n#{@tab}" unless @body.isEmpty()
-    code  += '}'
-    return @tab + code if @ctor
-    return utility('bind') + "(#{code}, #{@context})" if @bound
-    if @front or (o.level >= LEVEL_ACCESS) then "(#{code})" else code
-
-  # Short-circuit `traverseChildren` method to prevent it from crossing scope boundaries
-  # unless `crossScope` is `true`.
-  traverseChildren: (crossScope, func) ->
-    super(crossScope, func) if crossScope
-
-#### Param
-
-# A parameter in a function definition. Beyond a typical Javascript parameter,
-# these parameters can also attach themselves to the context of the function,
-# as well as be a splat, gathering up a group of parameters into an array.
-exports.Param = class Param extends Base
-  constructor: (@name, @value, @splat) ->
-
-  children: ['name', 'value']
-
-  compile: (o) ->
-    @name.compile o, LEVEL_LIST
-
-  asReference: (o) ->
-    return @reference if @reference
-    node = @name
-    if node.this
-      node = node.properties[0].name
-      node = new Literal '_' + node.value if node.value.reserved
-    else if node.isComplex()
-      node = new Literal o.scope.freeVariable 'arg'
-    node = new Value node
-    node = new Splat node if @splat
-    @reference = node
-
-  isComplex: ->
-    @name.isComplex()
-
-#### Splat
-
-# A splat, either as a parameter to a function, an argument to a call,
-# or as part of a destructuring assignment.
-exports.Splat = class Splat extends Base
-
-  children: ['name']
-
-  isAssignable: YES
-
-  constructor: (name) ->
-    @name = if name.compile then name else new Literal name
-
-  assigns: (name) ->
-    @name.assigns name
-
-  compile: (o) ->
-    if @index? then @compileParam o else @name.compile o
-
-  # Utility function that converts arbitrary number of elements, mixed with
-  # splats, to a proper array.
-  @compileSplattedArray: (o, list, apply) ->
-    index = -1
-    continue while (node = list[++index]) and node not instanceof Splat
-    return '' if index >= list.length
-    if list.length is 1
-      code = list[0].compile o, LEVEL_LIST
-      return code if apply
-      return "#{ utility 'slice' }.call(#{code})"
-    args = list.slice index
-    for node, i in args
-      code = node.compile o, LEVEL_LIST
-      args[i] = if node instanceof Splat
-      then "#{ utility 'slice' }.call(#{code})"
-      else "[#{code}]"
-    return args[0] + ".concat(#{ args.slice(1).join ', ' })" if index is 0
-    base = (node.compile o, LEVEL_LIST for node in list.slice 0, index)
-    "[#{ base.join ', ' }].concat(#{ args.join ', ' })"
-
-#### While
-
-# A while loop, the only sort of low-level loop exposed by CoffeeScript. From
-# it, all other loops can be manufactured. Useful in cases where you need more
-# flexibility or more speed than a comprehension can provide.
-exports.While = class While extends Base
-  constructor: (condition, options) ->
-    @condition = if options?.invert then condition.invert() else condition
-    @guard     = options?.guard
-
-  children: ['condition', 'guard', 'body']
-
-  isStatement: YES
-
-  makeReturn: ->
-    @returns = yes
-    this
-
-  addBody: (@body) ->
-    this
-
-  jumps: ->
-    {expressions} = @body
-    return no unless expressions.length
-    for node in expressions
-      return node if node.jumps loop: yes
-    no
-
-  # The main difference from a JavaScript *while* is that the CoffeeScript
-  # *while* can be used as a part of a larger expression -- while loops may
-  # return an array containing the computed result of each iteration.
-  compileNode: (o) ->
-    o.indent += TAB
-    set      = ''
-    {body}   = this
-    if body.isEmpty()
-      body = ''
-    else
-      if o.level > LEVEL_TOP or @returns
-        rvar = o.scope.freeVariable 'results'
-        set  = "#{@tab}#{rvar} = [];\n"
-        body = Push.wrap rvar, body if body
-      body = Expressions.wrap [new If @guard, body] if @guard
-      body = "\n#{ body.compile o, LEVEL_TOP }\n#{@tab}"
-    code = set + @tab + "while (#{ @condition.compile o, LEVEL_PAREN }) {#{body}}"
-    if @returns
-      code += "\n#{@tab}return #{rvar};"
-    code
-
-#### Op
-
-# Simple Arithmetic and logical operations. Performs some conversion from
-# CoffeeScript operations into their JavaScript equivalents.
-exports.Op = class Op extends Base
-  constructor: (op, first, second, flip) ->
-    return new In first, second if op is 'in'
-    return new Call first, first.params or [] if op is 'do'
-    if op is 'new'
-      return first.newInstance() if first instanceof Call
-      first = new Parens first   if first instanceof Code and first.bound
-    @operator = CONVERSIONS[op] or op
-    @first    = first
-    @second   = second
-    @flip     = !!flip
-    return this
-
-  # The map of conversions from CoffeeScript to JavaScript symbols.
-  CONVERSIONS =
-    '==': '==='
-    '!=': '!=='
-    'of': 'in'
-
-  # The map of invertible operators.
-  INVERSIONS =
-    '!==': '==='
-    '===': '!=='
-
-  children: ['first', 'second']
-
-  isSimpleNumber: NO
-
-  isUnary: ->
-    not @second
-
-  # Am I capable of
-  # [Python-style comparison chaining](http://docs.python.org/reference/expressions.html#notin)?
-  isChainable: ->
-    @operator in ['<', '>', '>=', '<=', '===', '!==']
-
-  invert: ->
-    if @isChainable() and @first.isChainable()
-      allInvertable = yes
-      curr = this
-      while curr and curr.operator
-        allInvertable and= (curr.operator of INVERSIONS)
-        curr = curr.first
-      return new Parens(this).invert() unless allInvertable
-      curr = this
-      while curr and curr.operator
-        curr.invert = !curr.invert
-        curr.operator = INVERSIONS[curr.operator]
-        curr = curr.first
-      this
-    else if op = INVERSIONS[@operator]
-      @operator = op
-      if @first.unwrap() instanceof Op
-        @first.invert()
-      this
-    else if @second
-      new Parens(this).invert()
-    else if @operator is '!' and (fst = @first.unwrap()) instanceof Op and
-                                  fst.operator in ['!', 'in', 'instanceof']
-      fst
-    else
-      new Op '!', this
-
-  unfoldSoak: (o) ->
-    @operator in ['++', '--', 'delete'] and unfoldSoak o, this, 'first'
-
-  compileNode: (o) ->
-    return @compileUnary     o if @isUnary()
-    return @compileChain     o if @isChainable() and @first.isChainable()
-    return @compileExistence o if @operator is '?'
-    @first.front = @front
-    code = @first.compile(o, LEVEL_OP) + ' ' + @operator + ' ' +
-           @second.compile(o, LEVEL_OP)
-    if o.level <= LEVEL_OP then code else "(#{code})"
-
-  # Mimic Python's chained comparisons when multiple comparison operators are
-  # used sequentially. For example:
-  #
-  #     bin/coffee -e 'console.log 50 < 65 > 10'
-  #     true
-  compileChain: (o) ->
-    [@first.second, shared] = @first.second.cache o
-    fst = @first.compile o, LEVEL_OP
-    code = "#{fst} #{if @invert then '&&' else '||'} #{ shared.compile o } #{@operator} #{ @second.compile o, LEVEL_OP }"
-    "(#{code})"
-
-  compileExistence: (o) ->
-    if @first.isComplex()
-      ref = o.scope.freeVariable 'ref'
-      fst = new Parens new Assign new Literal(ref), @first
-    else
-      fst = @first
-      ref = fst.compile o
-    new Existence(fst).compile(o) + " ? #{ref} : #{ @second.compile o, LEVEL_LIST }"
-
-  # Compile a unary **Op**.
-  compileUnary: (o) ->
-    parts = [op = @operator]
-    parts.push ' ' if op in ['new', 'typeof', 'delete'] or
-                      op in ['+', '-'] and @first instanceof Op and @first.operator is op
-    parts.push @first.compile o, LEVEL_OP
-    parts.reverse() if @flip
-    parts.join ''
-
-  toString: (idt) ->
-    super idt, @constructor.name + ' ' + @operator
-
-#### In
-exports.In = class In extends Base
-  constructor: (@object, @array) ->
-
-  children: ['object', 'array']
-
-  invert: NEGATE
-
-  compileNode: (o) ->
-    if @array instanceof Value and @array.isArray()
-      @compileOrTest o
-    else
-      @compileLoopTest o
-
-  compileOrTest: (o) ->
-    [sub, ref] = @object.cache o, LEVEL_OP
-    [cmp, cnj] = if @negated then [' !== ', ' && '] else [' === ', ' || ']
-    tests = for item, i in @array.base.objects
-      (if i then ref else sub) + cmp + item.compile o, LEVEL_OP
-    tests = tests.join cnj
-    if o.level < LEVEL_OP then tests else "(#{tests})"
-
-  compileLoopTest: (o) ->
-    [sub, ref] = @object.cache o, LEVEL_LIST
-    code = utility('indexOf') + ".call(#{ @array.compile o, LEVEL_LIST }, #{ref}) " +
-           if @negated then '< 0' else '>= 0'
-    return code if sub is ref
-    code = sub + ', ' + code
-    if o.level < LEVEL_LIST then code else "(#{code})"
-
-  toString: (idt) ->
-    super idt, @constructor.name + if @negated then '!' else ''
-
-#### Try
-
-# A classic *try/catch/finally* block.
-exports.Try = class Try extends Base
-  constructor: (@attempt, @error, @recovery, @ensure) ->
-
-  children: ['attempt', 'recovery', 'ensure']
-
-  isStatement: YES
-
-  jumps: (o) -> @attempt.jumps(o) or @recovery?.jumps(o)
-
-  makeReturn: ->
-    @attempt  = @attempt .makeReturn() if @attempt
-    @recovery = @recovery.makeReturn() if @recovery
-    this
-
-  # Compilation is more or less as you would expect -- the *finally* clause
-  # is optional, the *catch* is not.
-  compileNode: (o) ->
-    o.indent  += TAB
-    errorPart = if @error then " (#{ @error.compile o }) " else ' '
-    catchPart = if @recovery
-      " catch#{errorPart}{\n#{ @recovery.compile o, LEVEL_TOP }\n#{@tab}}"
-    else unless @ensure or @recovery
-      ' catch (_e) {}'
-    """
-    #{@tab}try {
-    #{ @attempt.compile o, LEVEL_TOP }
-    #{@tab}}#{ catchPart or '' }
-    """ + if @ensure then " finally {\n#{ @ensure.compile o, LEVEL_TOP }\n#{@tab}}" else ''
-
-#### Throw
-
-# Simple node to throw an exception.
-exports.Throw = class Throw extends Base
-  constructor: (@expression) ->
-
-  children: ['expression']
-
-  isStatement: YES
-  jumps:       NO
-
-  # A **Throw** is already a return, of sorts...
-  makeReturn: THIS
-
-  compileNode: (o) ->
-    @tab + "throw #{ @expression.compile o };"
-
-#### Existence
-
-# Checks a variable for existence -- not *null* and not *undefined*. This is
-# similar to `.nil?` in Ruby, and avoids having to consult a JavaScript truth
-# table.
-exports.Existence = class Existence extends Base
-  constructor: (@expression) ->
-
-  children: ['expression']
-
-  invert: NEGATE
-
-  compileNode: (o) ->
-    code = @expression.compile o, LEVEL_OP
-    code = if IDENTIFIER.test(code) and not o.scope.check code
-      if @negated
-        "typeof #{code} == \"undefined\" || #{code} === null"
-      else
-        "typeof #{code} != \"undefined\" && #{code} !== null"
-    else
-      sym = if @negated then '==' else '!='
-      "#{code} #{sym} null"
-    if o.level <= LEVEL_COND then code else "(#{code})"
-
-#### Parens
-
-# An extra set of parentheses, specified explicitly in the source. At one time
-# we tried to clean up the results by detecting and removing redundant
-# parentheses, but no longer -- you can put in as many as you please.
-#
-# Parentheses are a good way to force any statement to become an expression.
-exports.Parens = class Parens extends Base
-  constructor: (@body) ->
-
-  children: ['body']
-
-  unwrap    : -> @body
-  isComplex : -> @body.isComplex()
-  makeReturn: -> @body.makeReturn()
-
-  compileNode: (o) ->
-    expr = @body.unwrap()
-    if expr instanceof Value and expr.isAtomic()
-      expr.front = @front
-      return expr.compile o
-    code = expr.compile o, LEVEL_PAREN
-    bare = o.level < LEVEL_OP and (expr instanceof Op or expr instanceof Call or
-      (expr instanceof For and expr.returns))
-    if bare then code else "(#{code})"
-
-#### For
-
-# CoffeeScript's replacement for the *for* loop is our array and object
-# comprehensions, that compile into *for* loops here. They also act as an
-# expression, able to return the result of each filtered iteration.
-#
-# Unlike Python array comprehensions, they can be multi-line, and you can pass
-# the current index of the loop as a second parameter. Unlike Ruby blocks,
-# you can map and filter in a single pass.
-exports.For = class For extends Base
-  constructor: (body, source) ->
-    {@source, @guard, @step, @name, @index} = source
-    @body    = Expressions.wrap [body]
-    @own     = !!source.own
-    @object  = !!source.object
-    [@name, @index] = [@index, @name] if @object
-    throw SyntaxError 'index cannot be a pattern matching expression' if @index instanceof Value
-    @range   = @source instanceof Value and @source.base instanceof Range and not @source.properties.length
-    @pattern = @name instanceof Value
-    throw SyntaxError 'indexes do not apply to range loops' if @range and @index
-    throw SyntaxError 'cannot pattern match over range loops' if @range and @pattern
-    @returns = false
-
-  children: ['body', 'source', 'guard', 'step']
-
-  isStatement: YES
-
-  jumps: While::jumps
-
-  makeReturn: ->
-    @returns = yes
-    this
-
-  # Welcome to the hairiest method in all of CoffeeScript. Handles the inner
-  # loop, filtering, stepping, and result saving for array, object, and range
-  # comprehensions. Some of the generated code can be shared in common, and
-  # some cannot.
-  compileNode: (o) ->
-    body          = Expressions.wrap [@body]
-    lastJumps     = last(body.expressions)?.jumps()
-    @returns      = no if lastJumps and lastJumps instanceof Return
-    source        = if @range then @source.base else @source
-    scope         = o.scope
-    name          = @name  and @name.compile o, LEVEL_LIST
-    index         = @index and @index.compile o, LEVEL_LIST
-    scope.find(name,  immediate: yes) if name and not @pattern
-    scope.find(index, immediate: yes) if index
-    rvar          = scope.freeVariable 'results' if @returns
-    ivar          = (if @range then name else index) or scope.freeVariable 'i'
-    name          = ivar if @pattern
-    varPart       = ''
-    guardPart     = ''
-    defPart       = ''
-    idt1          = @tab + TAB
-    if @range
-      forPart = source.compile merge(o, {index: ivar, @step})
-    else
-      svar = @source.compile o, LEVEL_LIST
-      if (name or @own) and not IDENTIFIER.test svar
-        defPart = "#{@tab}#{ref = scope.freeVariable 'ref'} = #{svar};\n"
-        svar = ref
-      if name and not @pattern
-        namePart = "#{name} = #{svar}[#{ivar}]"
-      unless @object
-        lvar        = scope.freeVariable 'len'
-        stepPart    = if @step then "#{ivar} += #{ @step.compile(o, LEVEL_OP) }" else "#{ivar}++"
-        forPart     = "#{ivar} = 0, #{lvar} = #{svar}.length; #{ivar} < #{lvar}; #{stepPart}"
-    if @returns
-      resultPart    = "#{@tab}#{rvar} = [];\n"
-      returnResult  = "\n#{@tab}return #{rvar};"
-      body          = Push.wrap rvar, body
-    if @guard
-      body          = Expressions.wrap [new If @guard, body]
-    if @pattern
-      body.expressions.unshift new Assign @name, new Literal "#{svar}[#{ivar}]"
-    defPart         += @pluckDirectCall o, body
-    varPart         = "\n#{idt1}#{namePart};" if namePart
-    if @object
-      forPart       = "#{ivar} in #{svar}"
-      guardPart     = "\n#{idt1}if (!#{utility('hasProp')}.call(#{svar}, #{ivar})) continue;" if @own
-    body            = body.compile merge(o, indent: idt1), LEVEL_TOP
-    body            = '\n' + body + '\n' if body
-    """
-    #{defPart}#{resultPart or ''}#{@tab}for (#{forPart}) {#{guardPart}#{varPart}#{body}#{@tab}}#{returnResult or ''}
-    """
-
-  pluckDirectCall: (o, body) ->
-    defs = ''
-    for expr, idx in body.expressions
-      expr = expr.unwrapAll()
-      continue unless expr instanceof Call
-      val = expr.variable.unwrapAll()
-      continue unless (val instanceof Code) or
-                      (val instanceof Value and
-                      val.base?.unwrapAll() instanceof Code and
-                      val.properties.length is 1 and
-                      val.properties[0].name?.value in ['call', 'apply'])
-      fn    = val.base?.unwrapAll() or val
-      ref   = new Literal o.scope.freeVariable 'fn'
-      base  = new Value ref
-      if val.base
-        [val.base, base] = [base, val]
-        args.unshift new Literal 'this'
-      body.expressions[idx] = new Call base, expr.args
-      defs += @tab + new Assign(ref, fn).compile(o, LEVEL_TOP) + ';\n'
-    defs
-
-#### Switch
-
-# A JavaScript *switch* statement. Converts into a returnable expression on-demand.
-exports.Switch = class Switch extends Base
-  constructor: (@subject, @cases, @otherwise) ->
-
-  children: ['subject', 'cases', 'otherwise']
-
-  isStatement: YES
-
-  jumps: (o = {block: yes}) ->
-    for [conds, block] in @cases
-      return block if block.jumps o
-    @otherwise?.jumps o
-
-  makeReturn: ->
-    pair[1].makeReturn() for pair in @cases
-    @otherwise?.makeReturn()
-    this
-
-  compileNode: (o) ->
-    idt1 = o.indent + TAB
-    idt2 = o.indent = idt1 + TAB
-    code = @tab + "switch (#{ @subject?.compile(o, LEVEL_PAREN) or false }) {\n"
-    for [conditions, block], i in @cases
-      for cond in flatten [conditions]
-        cond  = cond.invert() unless @subject
-        code += idt1 + "case #{ cond.compile o, LEVEL_PAREN }:\n"
-      code += body + '\n' if body = block.compile o, LEVEL_TOP
-      break if i is @cases.length - 1 and not @otherwise
-      expr = @lastNonComment block.expressions
-      jumper = expr.jumps()
-      if not expr or not jumper or (jumper instanceof Literal and jumper.value is 'debugger')
-        code += idt2 + 'break;\n'
-    code += idt1 + "default:\n#{ @otherwise.compile o, LEVEL_TOP }\n" if @otherwise and @otherwise.expressions.length
-    code +  @tab + '}'
-
-#### If
-
-# *If/else* statements. Acts as an expression by pushing down requested returns
-# to the last line of each clause.
-#
-# Single-expression **Ifs** are compiled into conditional operators if possible,
-# because ternaries are already proper expressions, and don't need conversion.
-exports.If = class If extends Base
-  constructor: (condition, @body, options = {}) ->
-    @condition = if options.type is 'unless' then condition.invert() else condition
-    @elseBody  = null
-    @isChain   = false
-    {@soak}    = options
-
-  children: ['condition', 'body', 'elseBody']
-
-  bodyNode:     -> @body?.unwrap()
-  elseBodyNode: -> @elseBody?.unwrap()
-
-  # Rewrite a chain of **Ifs** to add a default case as the final *else*.
-  addElse: (elseBody) ->
-    if @isChain
-      @elseBodyNode().addElse elseBody
-    else
-      @isChain  = elseBody instanceof If
-      @elseBody = @ensureExpressions elseBody
-    this
-
-  # The **If** only compiles into a statement if either of its bodies needs
-  # to be a statement. Otherwise a conditional operator is safe.
-  isStatement: (o) ->
-    o?.level is LEVEL_TOP or
-      @bodyNode().isStatement(o) or @elseBodyNode()?.isStatement(o)
-
-  jumps: (o) -> @body.jumps(o) or @elseBody?.jumps(o)
-
-  compileNode: (o) ->
-    if @isStatement o then @compileStatement o else @compileExpression o
-
-  makeReturn: ->
-    @body     and= new Expressions [@body.makeReturn()]
-    @elseBody and= new Expressions [@elseBody.makeReturn()]
-    this
-
-  ensureExpressions: (node) ->
-    if node instanceof Expressions then node else new Expressions [node]
-
-  # Compile the **If** as a regular *if-else* statement. Flattened chains
-  # force inner *else* bodies into statement form.
-  compileStatement: (o) ->
-    child    = del o, 'chainChild'
-    cond     = @condition.compile o, LEVEL_PAREN
-    o.indent += TAB
-    body     = @ensureExpressions(@body).compile o
-    body     = "\n#{body}\n#{@tab}" if body
-    ifPart   = "if (#{cond}) {#{body}}"
-    ifPart   = @tab + ifPart unless child
-    return ifPart unless @elseBody
-    ifPart + ' else ' + if @isChain
-      o.indent = @tab
-      o.chainChild = yes
-      @elseBody.unwrap().compile o, LEVEL_TOP
-    else
-      "{\n#{ @elseBody.compile o, LEVEL_TOP }\n#{@tab}}"
-
-  # Compile the If as a conditional operator.
-  compileExpression: (o) ->
-    cond = @condition.compile o, LEVEL_COND
-    body = @bodyNode().compile o, LEVEL_LIST
-    alt  = if @elseBodyNode() then @elseBodyNode().compile(o, LEVEL_LIST) else 'void 0'
-    code = "#{cond} ? #{body} : #{alt}"
-    if o.level >= LEVEL_COND then "(#{code})" else code
-
-  unfoldSoak: ->
-    @soak and this
-
-# Faux-Nodes
-# ----------
-# Faux-nodes are never created by the grammar, but are used during code
-# generation to generate other combinations of nodes.
-
-#### Push
-
-# The **Push** creates the tree for `array.push(value)`,
-# which is helpful for recording the result arrays from comprehensions.
-Push =
-  wrap: (name, exps) ->
-    return exps if exps.isEmpty() or last(exps.expressions).jumps()
-    exps.push new Call new Value(new Literal(name), [new Access new Literal 'push']), [exps.pop()]
-
-#### Closure
-
-# A faux-node used to wrap an expressions body in a closure.
-Closure =
-
-  # 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, noReturn) ->
-    return expressions if expressions.jumps()
-    func = new Code [], Expressions.wrap [expressions]
-    args = []
-    if (mentionsArgs = expressions.contains @literalArgs) or
-       (               expressions.contains @literalThis)
-      meth = new Literal if mentionsArgs then 'apply' else 'call'
-      args = [new Literal 'this']
-      args.push new Literal 'arguments' if mentionsArgs
-      func = new Value func, [new Access meth]
-    func.noReturn = noReturn
-    call = new Call func, args
-    if statement then Expressions.wrap [call] else call
-
-  literalArgs: (node) ->
-    node instanceof Literal and node.value is 'arguments' and not node.asKey
-  literalThis: (node) ->
-    (node instanceof Literal and node.value is 'this' and not node.asKey) or
-      (node instanceof Code and node.bound)
-
-# Unfold a node's child if soak, then tuck the node under created `If`
-unfoldSoak = (o, parent, name) ->
-  return unless ifn = parent[name].unfoldSoak o
-  parent[name] = ifn.body
-  ifn.body = new Value parent
-  ifn
-
-# Constants
-# ---------
-
-UTILITIES =
-
-  # Correctly set up a prototype chain for inheritance, including a reference
-  # to the superclass for `super()` calls, and copies of any static properties.
-  extends: '''
-    function(child, parent) {
-      for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
-      function ctor() { this.constructor = child; }
-      ctor.prototype = parent.prototype;
-      child.prototype = new ctor;
-      child.__super__ = parent.prototype;
-      return child;
-    }
-  '''
-
-  # Create a function bound to the current value of "this".
-  bind: '''
-    function(fn, me){ return function(){ return fn.apply(me, arguments); }; }
-  '''
-
-  # Discover if an item is in an array.
-  indexOf: '''
-    Array.prototype.indexOf || function(item) {
-      for (var i = 0, l = this.length; i < l; i++) {
-        if (this[i] === item) return i;
-      }
-      return -1;
-    }
-  '''
-
-  # Shortcuts to speed up the lookup time for native functions.
-  hasProp: 'Object.prototype.hasOwnProperty'
-  slice  : 'Array.prototype.slice'
-
-# Levels indicates a node's position in the AST. Useful for knowing if
-# parens are necessary or superfluous.
-LEVEL_TOP    = 1  # ...;
-LEVEL_PAREN  = 2  # (...)
-LEVEL_LIST   = 3  # [...]
-LEVEL_COND   = 4  # ... ? x : y
-LEVEL_OP     = 5  # !...
-LEVEL_ACCESS = 6  # ...[0]
-
-# Tabs are two spaces for pretty printing.
-TAB = '  '
-
-# Trim out all trailing whitespace, so that the generated code plays nice
-# with Git.
-TRAILING_WHITESPACE = /[ \t]+$/gm
-
-IDENTIFIER = /^[$A-Za-z_][$\w]*$/
-SIMPLENUM  = /^[+-]?\d+$/
-
-# Is a literal value a string?
-IS_STRING = /^['"]/
-
-# Utility Functions
-# -----------------
-
-# Helper for ensuring that utility functions are assigned at the top level.
-utility = (name) ->
-  ref = "__#{name}"
-  Scope.root.assign ref, UTILITIES[name]
-  ref
-
-multident = (code, tab) ->
-  code.replace /\n/g, '$&' + tab