# `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.

# Set up for both **Node.js** and the browser, by
# including the [Scope](scope.html) class and the [helper](helpers.html) functions.
if process?
  Scope:   require('./scope').Scope
  helpers: require('./helpers').helpers
else
  this.exports: this
  helpers:      this.helpers
  Scope:        this.Scope

# Import the helpers we plan to use.
{compact, flatten, merge, del, include, indexOf, starts, ends}: helpers

#### BaseNode

# The **BaseNode** 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.BaseNode: class BaseNode

  # 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).
  #
  # If a Node is *topSensitive*, that means that it needs to compile differently
  # depending on whether it's being used as part of a larger expression, or is a
  # top-level statement within the function body.
  compile: (o) ->
    @options: merge o or {}
    @tab:     o.indent
    unless this instanceof ValueNode or this instanceof CallNode
      del @options, 'operation'
      del @options, 'chainRoot' unless this instanceof AccessorNode or this instanceof IndexNode
    top:      if @topSensitive() then @options.top else del @options, 'top'
    closure:  @isStatement() and not @isPureStatement() and not top and
              not @options.asStatement and not (this instanceof CommentNode) and
              not @containsPureStatement()
    if closure then @compileClosure(@options) else @compileNode(@options)

  # Statements converted into expressions via closure-wrapping share a scope
  # object with their parent closure, to preserve the expected lexical scope.
  compileClosure: (o) ->
    @tab: o.indent
    o.sharedScope: o.scope
    ClosureNode.wrap(this).compile 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.
  compileReference: (o, options) ->
    pair: if not ((this instanceof CallNode or @contains((n) -> n instanceof CallNode)) or
                  (this instanceof ValueNode and (not (@base instanceof LiteralNode) or @hasProperties())))
      [this, this]
    else
      reference: literal o.scope.freeVariable()
      compiled:  new AssignNode reference, this
      [compiled, reference]
    return pair unless options and options.precompile
    [pair[0].compile(o), pair[1].compile(o)]

  # Convenience method to grab the current indentation level, plus tabbing in.
  idt: (tabs) ->
    idt: @tab or ''
    num: (tabs or 0) + 1
    idt: + TAB while num: - 1
    idt

  # Construct a node that returns the current node's result.
  # Note that this is overridden for smarter behavior for
  # many statement nodes (eg IfNode, ForNode)...
  makeReturn: ->
    new ReturnNode 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: (block) ->
    contains: false
    @traverseChildren false, (node) ->
      if block(node)
        contains: true
        return false
    contains

  # Is this node of a certain type, or does it contain the type?
  containsType: (type) ->
    this instanceof type or @contains (n) -> n instanceof type

  # Convenience for the most common use of contains. Does the node contain
  # a pure statement?
  containsPureStatement: ->
    @isPureStatement() or @contains (n) -> n.isPureStatement()

  # Perform an in-order traversal of the AST. Crosses scope boundaries.
  traverse: (block) -> @traverseChildren true, block

  # `toString` representation of the node, for inspecting the parse tree.
  # This is what `coffee --nodes` prints out.
  toString: (idt, override) ->
    idt: or ''
    children: (child.toString idt + TAB for child in @collectChildren()).join('')
    '\n' + idt + (override or @class) + children

  eachChild: (func) ->
    return unless @children
    for attr in @children when this[attr]
      for child in flatten [this[attr]]
        return if func(child) is false

  collectChildren: ->
    nodes: []
    @eachChild (node) -> nodes.push node
    nodes

  traverseChildren: (crossScope, func) ->
    @eachChild (child) ->
      func.apply(this, arguments)
      child.traverseChildren(crossScope, func) if child instanceof BaseNode

  # Default implementations of the common node properties and methods. Nodes
  # will override these with custom logic, if needed.
  class:     'BaseNode'
  children: []

  unwrap:           -> this
  isStatement:      -> no
  isPureStatement:  -> no
  topSensitive:     -> 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 BaseNode

  class:         'Expressions'
  children:     ['expressions']
  isStatement: -> yes

  constructor: (nodes) ->
    @expressions: compact flatten nodes or []

  # Tack an expression on to the end of this expression list.
  push: (node) ->
    @expressions.push(node)
    this

  # 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?
  empty: ->
    @expressions.length is 0

  # An Expressions node does not return its entire body, rather it
  # ensures that the final expression is returned.
  makeReturn: ->
    idx:  @expressions.length - 1
    last: @expressions[idx]
    last: @expressions[idx: - 1] if last instanceof CommentNode
    return this if not last or last instanceof ReturnNode
    @expressions[idx]: last.makeReturn()
    this

  # A bound function uses a local `__this` variable instead of the real `this`.
  rewriteThis: ->
    @traverseChildren false, (child) ->
      if child instanceof ValueNode and child.base.value is 'this'
        child.base: literal '__this'

  # An **Expressions** is the only node that can serve as the root.
  compile: (o) ->
    o: or {}
    if o.scope then super(o) else @compileRoot(o)

  compileNode: (o) ->
    (@compileExpression(node, merge(o)) for node in @expressions).join("\n")

  # 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.noWrap then '' else TAB
    o.scope: new Scope(null, this, null)
    code: @compileWithDeclarations(o)
    code: code.replace(TRAILING_WHITESPACE, '')
    code: code.replace(DOUBLE_PARENS, '($1)')
    if o.noWrap then code else "(function() {\n$code\n})();\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: @compileNode(o)
    code: "${@tab}var ${o.scope.compiledAssignments()};\n$code"  if o.scope.hasAssignments(this)
    code: "${@tab}var ${o.scope.compiledDeclarations()};\n$code" if not o.globals and o.scope.hasDeclarations(this)
    code

  # Compiles a single expression 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.
  compileExpression: (node, o) ->
    @tab: o.indent
    compiledNode: node.compile merge o, {top: true}
    if node.isStatement() then compiledNode else "${@idt()}$compiledNode;"

# Wrap up the given nodes as an **Expressions**, unless it already happens
# to be one.
Expressions.wrap: (nodes) ->
  return nodes[0] if nodes.length is 1 and nodes[0] instanceof Expressions
  new Expressions(nodes)

#### LiteralNode

# Literals are static values that can be passed through directly into
# JavaScript without translation, such as: strings, numbers,
# `true`, `false`, `null`...
exports.LiteralNode: class LiteralNode extends BaseNode

  class: 'LiteralNode'

  constructor: (value) ->
    @value: value

  # Break and continue must be treated as pure statements -- they lose their
  # meaning when wrapped in a closure.
  isStatement: ->
    @value is 'break' or @value is 'continue'
  isPureStatement: LiteralNode::isStatement

  compileNode: (o) ->
    idt: if @isStatement() then @idt() else ''
    end: if @isStatement() then ';' else ''
    "$idt$@value$end"

  toString: (idt) ->
    " \"$@value\""

#### ReturnNode

# A `return` is a *pureStatement* -- wrapping it in a closure wouldn't
# make sense.
exports.ReturnNode: class ReturnNode extends BaseNode

  class:               'ReturnNode'
  isStatement:       -> yes
  isPureStatement:  -> yes
  children:           ['expression']

  constructor: (expression) ->
    @expression: expression

  makeReturn: ->
    this

  compile: (o) ->
    expr: @expression.makeReturn()
    return expr.compile o unless expr instanceof ReturnNode
    super o

  compileNode: (o) ->
    o.asStatement: true if @expression.isStatement()
    "${@tab}return ${@expression.compile(o)};"

#### ValueNode

# A value, variable or literal or parenthesized, indexed or dotted into,
# or vanilla.
exports.ValueNode: class ValueNode extends BaseNode

  SOAK:     " == undefined ? undefined : "

  class:     'ValueNode'
  children: ['base', 'properties']

  # A **ValueNode** has a base and a list of property accesses.
  constructor: (base, properties) ->
    @base: base
    @properties: (properties or [])

  # 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: ->
    @base instanceof ArrayNode and not @hasProperties()

  isObject: ->
    @base instanceof ObjectNode and not @hasProperties()

  isSplice: ->
    @hasProperties() and @properties[@properties.length - 1] instanceof SliceNode

  makeReturn: ->
    if @hasProperties() 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

  # Values are considered to be statements if their base is a statement.
  isStatement: ->
    @base.isStatement and @base.isStatement() and not @hasProperties()

  isNumber: ->
    @base instanceof LiteralNode and @base.value.match NUMBER

  # Works out if the value is the start of a chain.
  isStart: (o) ->
    return true if this is o.chainRoot and @properties[0] instanceof AccessorNode
    node: o.chainRoot.base or o.chainRoot.variable
    while node instanceof CallNode then node: node.variable
    node is this

  # Override compile to unwrap the value when possible.
  compile: (o) ->
    if not o.top or @properties.length then super(o) else @base.compile(o)

  # We compile a value to JavaScript by compiling and joining each property.
  # Things get much more insteresting if the chain of properties has *soak*
  # operators `?.` interspersed. Then we have to take care not to accidentally
  # evaluate a anything twice when building the soak chain.
  compileNode: (o) ->
    only:         del o, 'onlyFirst'
    op:           del o, 'operation'
    props:        if only then @properties[0...@properties.length - 1] else @properties
    o.chainRoot:  or this
    baseline:     @base.compile o
    baseline:     "($baseline)" if @hasProperties() and (@base instanceof ObjectNode or @isNumber())
    complete:     @last: baseline

    for prop, i in props
      @source: baseline
      if prop.soakNode
        if @base instanceof CallNode or @base.contains((n) -> n instanceof CallNode) and i is 0
          temp: o.scope.freeVariable()
          complete: "(${ baseline: temp } = ($complete))"
        complete: "typeof $complete === \"undefined\" || $baseline" if i is 0 and @isStart(o)
        complete: + @SOAK + (baseline: + prop.compile(o))
      else
        part: prop.compile(o)
        baseline: + part
        complete: + part
        @last: part

    if op and @wrapped then "($complete)" else complete

#### CommentNode

# CoffeeScript passes through block comments as JavaScript block comments
# at the same position.
exports.CommentNode: class CommentNode extends BaseNode

  class: 'CommentNode'
  isStatement: -> yes

  constructor: (lines) ->
    @lines: lines

  makeReturn: ->
    this

  compileNode: (o) ->
    sep: "\n$@tab"
    "$@tab/*$sep${ @lines.join(sep) }\n$@tab*/"

#### CallNode

# Node for a function invocation. Takes care of converting `super()` calls into
# calls against the prototype's function of the same name.
exports.CallNode: class CallNode extends BaseNode

  class:     'CallNode'
  children: ['variable', 'args']

  constructor: (variable, args) ->
    @isNew:     false
    @isSuper:   variable is 'super'
    @variable:  if @isSuper then null else variable
    @args:      (args or [])
    @compileSplatArguments: (o) ->
      SplatNode.compileSplattedArray.call(this, @args, o)

  # Tag this invocation as creating a new instance.
  newInstance: ->
    @isNew: true
    this

  prefix: ->
    if @isNew then 'new ' else ''

  # Grab the reference to the superclass' implementation of the current method.
  superReference: (o) ->
    methname: o.scope.method.name
    meth: if o.scope.method.proto
      "${o.scope.method.proto}.__superClass__.$methname"
    else if methname
      "${methname}.__superClass__.constructor"
    else throw new Error "cannot call super on an anonymous function."

  # Compile a vanilla function call.
  compileNode: (o) ->
    o.chainRoot: this unless o.chainRoot
    for arg in @args when arg instanceof SplatNode
      compilation: @compileSplat(o)
    unless compilation
      args: (arg.compile(o) for arg in @args).join(', ')
      compilation: if @isSuper then @compileSuper(args, o)
      else "${@prefix()}${@variable.compile(o)}($args)"
    if o.operation and @wrapped then "($compilation)" else compilation

  # `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) ->
    meth: if @variable then @variable.compile(o) else @superReference(o)
    obj:  @variable and @variable.source or 'this'
    if obj.match(/\(/)
      temp: o.scope.freeVariable()
      obj:  temp
      meth: "($temp = ${ @variable.source })${ @variable.last }"
    if @isNew
      utility 'extends'
      """
      (function() {
      ${@idt(1)}var ctor = function(){};
      ${@idt(1)}__extends(ctor, $meth);
      ${@idt(1)}return ${meth}.apply(new ctor, ${ @compileSplatArguments(o) });
      $@tab}).call(this)
      """
    else
      "${@prefix()}${meth}.apply($obj, ${ @compileSplatArguments(o) })"

#### ExtendsNode

# 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.ExtendsNode: class ExtendsNode extends BaseNode

  class:     'ExtendsNode'
  children: ['child', 'parent']

  constructor: (child, parent) ->
    @child: child
    @parent: parent

  # Hooks one constructor into another's prototype chain.
  compileNode: (o) ->
    ref:  new ValueNode literal utility 'extends'
    (new CallNode ref, [@child, @parent]).compile o

#### AccessorNode

# A `.` accessor into a property of a value, or the `::` shorthand for
# an accessor into the object's prototype.
exports.AccessorNode: class AccessorNode extends BaseNode

  class:     'AccessorNode'
  children: ['name']

  constructor: (name, tag) ->
    @name: name
    @prototype: if tag is 'prototype' then '.prototype' else ''
    @soakNode: tag is 'soak'

  compileNode: (o) ->
    name: @name.compile o
    o.chainRoot.wrapped: or @soakNode
    namePart: if name.match(IS_STRING) then "[$name]" else ".$name"
    @prototype + namePart

#### IndexNode

# A `[ ... ]` indexed accessor into an array or object.
exports.IndexNode: class IndexNode extends BaseNode

  class:     'IndexNode'
  children: ['index']

  constructor: (index) ->
    @index:     index

  compileNode: (o) ->
    o.chainRoot.wrapped: or @soakNode
    idx: @index.compile o
    prefix: if @proto then '.prototype' else ''
    "$prefix[$idx]"

#### RangeNode

# 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.RangeNode: class RangeNode extends BaseNode

  class:     'RangeNode'
  children: ['from', 'to']

  constructor: (from, to, exclusive) ->
    @from: from
    @to: to
    @exclusive: !!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.compileReference o, {precompile: yes}
    [@to, @toVar]:      @to.compileReference o, {precompile: yes}
    [@fromNum, @toNum]: [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]
    parts: []
    parts.push @from if @from isnt @fromVar
    parts.push @to if @to isnt @toVar
    if parts.length then "${parts.join('; ')}; " else ''

  # 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) ->
    return    @compileArray(o)  unless o.index
    return    @compileSimple(o) if @fromNum and @toNum
    idx:      del o, 'index'
    step:     del o, 'step'
    vars:     "$idx = $@fromVar"
    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]: [parseInt(@fromNum, 10), parseInt(@toNum, 10)]
    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) ->
    idt:    @idt 1
    vars:   @compileVariables(merge(o, {indent: idt}))
    result: o.scope.freeVariable()
    i:      o.scope.freeVariable()
    pre:    "\n${idt}${result} = []; ${vars}"
    if @fromNum and @toNum
      o.index: i
      body: @compileSimple o
    else
      clause: "$@fromVar <= $@toVar ?"
      body:   "var $i = $@fromVar; $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)"

#### SliceNode

# 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.SliceNode: class SliceNode extends BaseNode

  class:     'SliceNode'
  children: ['range']

  constructor: (range) ->
    @range: range

  compileNode: (o) ->
    from:       @range.from.compile(o)
    to:         @range.to.compile(o)
    plusPart:  if @range.exclusive then '' else ' + 1'
    ".slice($from, $to$plusPart)"

#### ObjectNode

# An object literal, nothing fancy.
exports.ObjectNode: class ObjectNode extends BaseNode

  class:     'ObjectNode'
  children: ['properties']

  constructor: (props) ->
    @objects: @properties: props or []

  compileNode: (o) ->
    o.indent: @idt 1
    nonComments: prop for prop in @properties when not (prop instanceof CommentNode)
    lastNoncom:  nonComments[nonComments.length - 1]
    props: for prop, i in @properties
      join:   ",\n"
      join:   "\n" if (prop is lastNoncom) or (prop instanceof CommentNode)
      join:   '' if i is @properties.length - 1
      indent: if prop instanceof CommentNode then '' else @idt 1
      prop:   new AssignNode prop, prop, 'object' unless prop instanceof AssignNode or prop instanceof CommentNode
      indent + prop.compile(o) + join
    props: props.join('')
    inner: if props then '\n' + props + '\n' + @idt() else ''
    "{$inner}"

#### ArrayNode

# An array literal.
exports.ArrayNode: class ArrayNode extends BaseNode

  class:     'ArrayNode'
  children: ['objects']

  constructor: (objects) ->
    @objects: objects or []
    @compileSplatLiteral: (o) ->
      SplatNode.compileSplattedArray.call(this, @objects, o)

  compileNode: (o) ->
    o.indent: @idt 1
    objects: []
    for obj, i in @objects
      code: obj.compile(o)
      if obj instanceof SplatNode
        return @compileSplatLiteral o
      else if obj instanceof CommentNode
        objects.push "\n$code\n$o.indent"
      else if i is @objects.length - 1
        objects.push code
      else
        objects.push "$code, "
    objects: objects.join('')
    if indexOf(objects, '\n') >= 0
      "[\n${@idt(1)}$objects\n$@tab]"
    else
      "[$objects]"

#### ClassNode

# The CoffeeScript class definition.
exports.ClassNode: class ClassNode extends BaseNode

  class:        'ClassNode'
  children:     ['variable', 'parent', 'properties']
  isStatement:  -> yes

  # Initialize a **ClassNode** with its name, an optional superclass, and a
  # list of prototype property assignments.
  constructor: (variable, parent, props) ->
    @variable: variable
    @parent: parent
    @properties: props or []
    @returns:  false

  makeReturn: ->
    @returns: true
    this

  # 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) ->
    extension:  @parent and new ExtendsNode(@variable, @parent)
    props:      new Expressions
    o.top:      true
    me:         null
    className:  @variable.compile o
    constScope: null

    if @parent
      applied: new ValueNode(@parent, [new AccessorNode(literal('apply'))])
      constructor: new CodeNode([], new Expressions([
        new CallNode(applied, [literal('this'), literal('arguments')])
      ]))
    else
      constructor: new CodeNode

    for prop in @properties
      [pvar, func]: [prop.variable, prop.value]
      if pvar and pvar.base.value is 'constructor' and func instanceof CodeNode
        throw new Error "cannot define a constructor as a bound function." if func.bound
        func.name: className
        func.body.push new ReturnNode literal 'this'
        @variable: new ValueNode @variable
        @variable.namespaced: include func.name, '.'
        constructor: func
        continue
      if func instanceof CodeNode and func.bound
        func.bound: false
        constScope: or new Scope(o.scope, constructor.body, constructor)
        me: or constScope.freeVariable()
        pname: pvar.compile(o)
        constructor.body.push    new ReturnNode literal 'this' if constructor.body.empty()
        constructor.body.unshift literal "this.${pname} = function(){ return ${className}.prototype.${pname}.apply($me, arguments); }"
      if pvar
        access: if prop.context is 'this' then pvar.base.properties[0] else new AccessorNode(pvar, 'prototype')
        val:    new ValueNode(@variable, [access])
        prop:   new AssignNode(val, func)
      props.push prop

    constructor.body.unshift literal "$me = this" if me
    construct: @idt() + (new AssignNode(@variable, constructor)).compile(merge o, {sharedScope: constScope}) + ';'
    props:     if !props.empty() then '\n' + props.compile(o)                     else ''
    extension: if extension      then '\n' + @idt() + extension.compile(o) + ';'  else ''
    returns:   if @returns       then '\n' + new ReturnNode(@variable).compile(o) else ''
    "$construct$extension$props$returns"

#### AssignNode

# The **AssignNode** is used to assign a local variable to value, or to set the
# property of an object -- including within object literals.
exports.AssignNode: class AssignNode extends BaseNode

  # Matchers for detecting prototype assignments.
  PROTO_ASSIGN: /^(\S+)\.prototype/
  LEADING_DOT:  /^\.(prototype\.)?/

  class:     'AssignNode'
  children: ['variable', 'value']

  constructor: (variable, value, context) ->
    @variable: variable
    @value: value
    @context: context

  topSensitive: ->
    true

  isValue: ->
    @variable instanceof ValueNode

  makeReturn: ->
    return new Expressions [this, new ReturnNode(@variable)]

  isStatement: ->
    @isValue() and (@variable.isArray() or @variable.isObject())

  # 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) ->
    top:    del o, 'top'
    return  @compilePatternMatch(o) if @isStatement()
    return  @compileSplice(o) if @isValue() and @variable.isSplice()
    stmt:   del o, 'asStatement'
    name:   @variable.compile(o)
    last:   if @isValue() then @variable.last.replace(@LEADING_DOT, '') else name
    match:  name.match(@PROTO_ASSIGN)
    proto:  match and match[1]
    if @value instanceof CodeNode
      @value.name:  last  if last.match(IDENTIFIER)
      @value.proto: proto if proto
    val: @value.compile o
    return "$name: $val" if @context is 'object'
    o.scope.find name unless @isValue() and (@variable.hasProperties() or @variable.namespaced)
    val: "$name = $val"
    return "$@tab$val;" if stmt
    if top 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) ->
    valVar: o.scope.freeVariable()
    value: if @value.isStatement() then ClosureNode.wrap(@value) else @value
    assigns: ["$@tab$valVar = ${ value.compile(o) };"]
    o.top: true
    o.asStatement: true
    splat: false
    for obj, i in @variable.base.objects
      # A regular array pattern-match.
      idx: i
      if @variable.isObject()
        if obj instanceof AssignNode
          # A regular object pattern-match.
          [obj, idx]: [obj.value, obj.variable.base]
        else
          # A shorthand `{a, b, c}: val` pattern-match.
          idx: obj
      if not (obj instanceof ValueNode or obj instanceof SplatNode)
        throw new Error 'pattern matching must use only identifiers on the left-hand side.'
      isString: idx.value and idx.value.match IS_STRING
      accessClass: if isString or @variable.isArray() then IndexNode else AccessorNode
      if obj instanceof SplatNode and not splat
        val: literal(obj.compileValue(o, valVar,
          (oindex: indexOf(@variable.base.objects, obj)),
          (olength: @variable.base.objects.length) - oindex - 1))
        splat: true
      else
        idx: literal(if splat then "${valVar}.length - ${olength - idx}" else idx) if typeof idx isnt 'object'
        val: new ValueNode(literal(valVar), [new accessClass(idx)])
      assigns.push(new AssignNode(obj, val).compile(o))
    code: assigns.join("\n")
    code

  # Compile the assignment from an array splice literal, using JavaScript's
  # `Array#splice` method.
  compileSplice: (o) ->
    name:   @variable.compile merge o, {onlyFirst: true}
    l:      @variable.properties.length
    range:  @variable.properties[l - 1].range
    plus:   if range.exclusive then '' else ' + 1'
    from:   range.from.compile(o)
    to:     range.to.compile(o) + ' - ' + from + plus
    val:    @value.compile(o)
    "${name}.splice.apply($name, [$from, $to].concat($val))"

#### CodeNode

# 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 CodeNode
# has no *children* -- they're within the inner scope.
exports.CodeNode: class CodeNode extends BaseNode

  class:     'CodeNode'
  children: ['params', 'body']

  constructor: (params, body, tag) ->
    @params:  params or []
    @body:    body or new Expressions
    @bound:   tag is 'boundfunc'

  # 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) ->
    sharedScope:  del o, 'sharedScope'
    top:          del o, 'top'
    o.scope:      sharedScope or new Scope(o.scope, @body, this)
    o.top:        true
    o.indent:     @idt(if @bound then 2 else 1)
    del o, 'noWrap'
    del o, 'globals'
    i: 0
    splat: undefined
    params: []
    for param in @params
      if param instanceof SplatNode and not splat?
        splat: param
        splat.index: i
        splat.trailings: []
        splat.arglength: @params.length
        @body.unshift(splat)
      else if splat?
        splat.trailings.push(param)
      else
        params.push(param)
      i: + 1
    params: (param.compile(o) for param in params)
    @body.makeReturn()
    @body.rewriteThis() if @bound
    (o.scope.parameter(param)) for param in params
    code: if @body.expressions.length then "\n${ @body.compileWithDeclarations(o) }\n" else ''
    func: "function(${ params.join(', ') }) {$code${ code and @idt(if @bound then 1 else 0) }}"
    func: "($func)" if top and not @bound
    return func unless @bound
    "(function(__this) {\n${@idt(1)}return $func;\n$@tab})(this)"

  topSensitive: ->
    true

  # Short-circuit traverseChildren method to prevent it from crossing scope boundaries
  # unless crossScope is true
  traverseChildren: (crossScope, func) -> super(crossScope, func) if crossScope

  toString: (idt) ->
    idt: or ''
    children: (child.toString(idt + TAB) for child in @collectChildren()).join('')
    "\n$idt$children"

#### SplatNode

# A splat, either as a parameter to a function, an argument to a call,
# or as part of a destructuring assignment.
exports.SplatNode: class SplatNode extends BaseNode

  class:     'SplatNode'
  children: ['name']

  constructor: (name) ->
    name: literal(name) unless name.compile
    @name: name

  compileNode: (o) ->
    if @index? then @compileParam(o) else @name.compile(o)

  # Compiling a parameter splat means recovering the parameters that succeed
  # the splat in the parameter list, by slicing the arguments object.
  compileParam: (o) ->
    name: @name.compile(o)
    o.scope.find name
    len: o.scope.freeVariable()
    o.scope.assign len, "arguments.length"
    variadic: o.scope.freeVariable()
    o.scope.assign variadic, "$len >= $@arglength"
    for trailing, idx in @trailings
      pos: @trailings.length - idx
      o.scope.assign(trailing.compile(o), "arguments[$variadic ? $len - $pos : ${@index + idx}]")
    "$name = ${utility('slice')}.call(arguments, $@index, $len - ${@trailings.length})"

  # A compiling a splat as a destructuring assignment means slicing arguments
  # from the right-hand-side's corresponding array.
  compileValue: (o, name, index, trailings) ->
    trail: if trailings then ", ${name}.length - $trailings" else ''
    "${utility 'slice'}.call($name, $index$trail)"

  # Utility function that converts arbitrary number of elements, mixed with
  # splats, to a proper array
  @compileSplattedArray: (list, o) ->
    args: []
    for arg, i in list
      code: arg.compile o
      prev: args[last: args.length - 1]
      if not (arg instanceof SplatNode)
        if prev and starts(prev, '[') and ends(prev, ']')
          args[last]: "${prev.substr(0, prev.length - 1)}, $code]"
          continue
        else if prev and starts(prev, '.concat([') and ends(prev, '])')
          args[last]: "${prev.substr(0, prev.length - 2)}, $code])"
          continue
        else
          code: "[$code]"
      args.push(if i is 0 then code else ".concat($code)")
    args.join('')

#### WhileNode

# 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.WhileNode: class WhileNode extends BaseNode

  class:         'WhileNode'
  children:     ['condition', 'guard', 'body']
  isStatement: -> yes

  constructor: (condition, opts) ->
    if opts and opts.invert
      condition: new ParentheticalNode condition if condition instanceof OpNode
      condition: new OpNode('!', condition)
    @condition: condition
    @guard: opts and opts.guard

  addBody: (body) ->
    @body: body
    this

  makeReturn: ->
    @returns: true
    this

  topSensitive: ->
    true

  # 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) ->
    top:        del(o, 'top') and not @returns
    o.indent:   @idt 1
    o.top:      true
    cond:       @condition.compile(o)
    set:        ''
    unless top
      rvar:     o.scope.freeVariable()
      set:      "$@tab$rvar = [];\n"
      @body:    PushNode.wrap(rvar, @body) if @body
    pre:        "$set${@tab}while ($cond)"
    @body:      Expressions.wrap([new IfNode(@guard, @body)]) if @guard
    if @returns
      post: '\n' + new ReturnNode(literal(rvar)).compile(merge(o, {indent: @idt()}))
    else
      post: ''
    "$pre {\n${ @body.compile(o) }\n$@tab}$post"

#### OpNode

# Simple Arithmetic and logical operations. Performs some conversion from
# CoffeeScript operations into their JavaScript equivalents.
exports.OpNode: class OpNode extends BaseNode

  # The map of conversions from CoffeeScript to JavaScript symbols.
  CONVERSIONS: {
    '==': '==='
    '!=': '!=='
  }

  # The list of operators for which we perform
  # [Python-style comparison chaining](http://docs.python.org/reference/expressions.html#notin).
  CHAINABLE:        ['<', '>', '>=', '<=', '===', '!==']

  # Our assignment operators that have no JavaScript equivalent.
  ASSIGNMENT:       ['||=', '&&=', '?=']

  # Operators must come before their operands with a space.
  PREFIX_OPERATORS: ['typeof', 'delete']

  class:     'OpNode'
  children: ['first', 'second']

  constructor: (operator, first, second, flip) ->
    @first: first
    @second: second
    @operator: @CONVERSIONS[operator] or operator
    @flip: !!flip

  isUnary: ->
    not @second

  isChainable: ->
    indexOf(@CHAINABLE, @operator) >= 0

  toString: (idt) ->
    super(idt, @class + ' ' + @operator)

  compileNode: (o) ->
    o.operation: true
    return @compileChain(o)      if @isChainable() and @first.unwrap() instanceof OpNode and @first.unwrap().isChainable()
    return @compileAssignment(o) if indexOf(@ASSIGNMENT, @operator) >= 0
    return @compileUnary(o)      if @isUnary()
    return @compileExistence(o)  if @operator is '?'
    [@first.compile(o), @operator, @second.compile(o)].join ' '

  # Mimic Python's chained comparisons when multiple comparison operators are
  # used sequentially. For example:
  #
  #     bin/coffee -e "puts 50 < 65 > 10"
  #     true
  compileChain: (o) ->
    shared: @first.unwrap().second
    [@first.second, shared]: shared.compileReference(o) if shared.containsType CallNode
    [first, second, shared]: [@first.compile(o), @second.compile(o), shared.compile(o)]
    "($first) && ($shared $@operator $second)"

  # 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.
  compileAssignment: (o) ->
    [first, second]: [@first.compile(o), @second.compile(o)]
    o.scope.find(first) if first.match(IDENTIFIER)
    return "$first = ${ ExistenceNode.compileTest(o, @first) } ? $first : $second" if @operator is '?='
    "$first = $first ${ @operator.substr(0, 2) } $second"

  # If this is an existence operator, we delegate to `ExistenceNode.compileTest`
  # to give us the safe references for the variables.
  compileExistence: (o) ->
    [first, second]: [@first.compile(o), @second.compile(o)]
    test: ExistenceNode.compileTest(o, @first)
    "$test ? $first : $second"

  # Compile a unary **OpNode**.
  compileUnary: (o) ->
    space: if indexOf(@PREFIX_OPERATORS, @operator) >= 0 then ' ' else ''
    parts: [@operator, space, @first.compile(o)]
    parts: parts.reverse() if @flip
    parts.join('')

#### InNode
exports.InNode: class InNode extends BaseNode

  class:    'InNode'
  children: ['object', 'array']

  constructor: (object, array) ->
    @object: object
    @array: array

  isArray: ->
    @array instanceof ValueNode and @array.isArray()

  compileNode: (o) ->
    [@obj1, @obj2]: @object.compileReference o, {precompile: yes}
    if @isArray() then @compileOrTest(o) else @compileLoopTest(o)

  compileOrTest: (o) ->
    tests: for item, i in @array.base.objects
      "${item.compile(o)} === ${if i then @obj2 else @obj1}"
    "(${tests.join(' || ')})"

  compileLoopTest: (o) ->
    [@arr1, @arr2]: @array.compileReference o, {precompile: yes}
    [i, l]: [o.scope.freeVariable(), o.scope.freeVariable()]
    prefix: if @obj1 isnt @obj2 then @obj1 + '; ' else ''
    "!!(function(){ ${prefix}for (var $i=0, $l=${@arr1}.length; $i<$l; $i++) if (${@arr2}[$i] === $@obj2) return true; }).call(this)"

#### TryNode

# A classic *try/catch/finally* block.
exports.TryNode: class TryNode extends BaseNode

  class:        'TryNode'
  children:     ['attempt', 'recovery', 'ensure']
  isStatement:  -> yes

  constructor: (attempt, error, recovery, ensure) ->
    @attempt: attempt
    @recovery: recovery
    @ensure: ensure
    @error: error

  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:     @idt 1
    o.top:        true
    attemptPart: @attempt.compile(o)
    errorPart:   if @error then " (${ @error.compile(o) }) " else ' '
    catchPart:   if @recovery then " catch$errorPart{\n${ @recovery.compile(o) }\n$@tab}" else ''
    finallyPart: (@ensure or '') and ' finally {\n' + @ensure.compile(merge(o)) + "\n$@tab}"
    "${@tab}try {\n$attemptPart\n$@tab}$catchPart$finallyPart"

#### ThrowNode

# Simple node to throw an exception.
exports.ThrowNode: class ThrowNode extends BaseNode

  class:         'ThrowNode'
  children:     ['expression']
  isStatement: -> yes

  constructor: (expression) ->
    @expression: expression

  # A **ThrowNode** is already a return, of sorts...
  makeReturn: ->
    return this

  compileNode: (o) ->
    "${@tab}throw ${@expression.compile(o)};"

#### ExistenceNode

# 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.ExistenceNode: class ExistenceNode extends BaseNode

  class:     'ExistenceNode'
  children: ['expression']

  constructor: (expression) ->
    @expression: expression

  compileNode: (o) ->
    ExistenceNode.compileTest(o, @expression)

  # The meat of the **ExistenceNode** is in this static `compileTest` method
  # because other nodes like to check the existence of their variables as well.
  # Be careful not to double-evaluate anything.
  @compileTest: (o, variable) ->
    [first, second]: variable.compileReference o
    "(typeof ${first.compile(o)} !== \"undefined\" && ${second.compile(o)} !== null)"

#### ParentheticalNode

# 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.ParentheticalNode: class ParentheticalNode extends BaseNode

  class:     'ParentheticalNode'
  children: ['expression']

  constructor: (expression) ->
    @expression: expression

  isStatement: ->
    @expression.isStatement()

  makeReturn: ->
    @expression.makeReturn()

  topSensitive: ->
    yes

  compileNode: (o) ->
    top:  del o, 'top'
    code: @expression.compile(o)
    if @isStatement()
      return (if top then "$@tab$code;" else code)
    l:    code.length
    code: code.substr(o, l-1) if code.substr(l-1, 1) is ';'
    if @expression instanceof AssignNode then code else "($code)"

#### ForNode

# 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.ForNode: class ForNode extends BaseNode

  class:         'ForNode'
  children:     ['body', 'source', 'guard']
  isStatement: -> yes

  constructor: (body, source, name, index) ->
    @body:    body
    @name:    name
    @index:   index or null
    @source:  source.source
    @guard:   source.guard
    @step:    source.step
    @raw:     !!source.raw
    @object:  !!source.object
    [@name, @index]: [@index, @name] if @object
    @pattern: @name instanceof ValueNode
    throw new Error('index cannot be a pattern matching expression') if @index instanceof ValueNode
    @returns: false

  topSensitive: ->
    true

  makeReturn: ->
    @returns: true
    this

  compileReturnValue: (val, o) ->
    return '\n' + new ReturnNode(literal(val)).compile(o) if @returns
    return '\n' + val if val
    ''

  # 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) ->
    topLevel:       del(o, 'top') and not @returns
    range:          @source instanceof ValueNode and @source.base instanceof RangeNode and not @source.properties.length
    source:         if range then @source.base else @source
    codeInBody:     @body.contains (n) -> n instanceof CodeNode
    scope:          o.scope
    name:           @name and @name.compile o
    index:          @index and @index.compile o
    scope.find name  if name and not @pattern and not codeInBody
    scope.find index if index
    rvar:           scope.freeVariable() unless topLevel
    ivar:           if range then name else if codeInBody then scope.freeVariable() else index or scope.freeVariable()
    varPart:        ''
    guardPart:      ''
    body:           Expressions.wrap([@body])
    if range
      sourcePart:   source.compileVariables(o)
      forPart:      source.compile merge o, {index: ivar, step: @step}
    else
      svar:         scope.freeVariable()
      sourcePart:   "$svar = ${ @source.compile(o) };"
      if @pattern
        namePart:   new AssignNode(@name, literal("$svar[$ivar]")).compile(merge o, {indent: @idt(1), top: true}) + '\n'
      else
        namePart:   "$name = $svar[$ivar]" if name
      unless @object
        lvar:       scope.freeVariable()
        stepPart:   if @step then "$ivar += ${ @step.compile(o) }" else "$ivar++"
        forPart:    "$ivar = 0, $lvar = ${svar}.length; $ivar < $lvar; $stepPart"
    sourcePart:     (if rvar then "$rvar = []; " else '') + sourcePart
    sourcePart:     if sourcePart then "$@tab$sourcePart\n$@tab" else @tab
    returnResult:   @compileReturnValue(rvar, o)

    body:           PushNode.wrap(rvar, body) unless topLevel
    if @guard
      body:         Expressions.wrap([new IfNode(@guard, body)])
    if codeInBody
      body.unshift  literal "var $namePart" if namePart
      body.unshift  literal "var $index = $ivar" if index
      body:         ClosureNode.wrap(body, true)
    else
      varPart:      (namePart or '') and (if @pattern then namePart else "${@idt(1)}$namePart;\n")
    if @object
      forPart:      "$ivar in $svar"
      guardPart:    "\n${@idt(1)}if (!${utility('hasProp')}.call($svar, $ivar)) continue;" unless @raw
    body:           body.compile(merge(o, {indent: @idt(1), top: true}))
    vars:           if range then name else "$name, $ivar"
    "${sourcePart}for ($forPart) {$guardPart\n$varPart$body\n$@tab}$returnResult"

#### IfNode

# *If/else* statements. Our *switch/when* will be compiled into this. Acts as an
# expression by pushing down requested returns to the last line of each clause.
#
# Single-expression **IfNodes** are compiled into ternary operators if possible,
# because ternaries are already proper expressions, and don't need conversion.
exports.IfNode: class IfNode extends BaseNode

  class:     'IfNode'
  children: ['condition', 'switchSubject', 'body', 'elseBody', 'assigner']

  constructor: (condition, body, tags) ->
    @condition: condition
    @body:      body
    @tags:      tags or {}
    if @tags.invert
      @condition: new OpNode('!', new ParentheticalNode(@condition))
    else if @condition instanceof OpNode and @condition.operator is 'instanceof'
      @condition: new ParentheticalNode(@condition)
    @elseBody:  null
    @isChain:   false

  bodyNode: -> @body?.unwrap()
  elseBodyNode: -> @elseBody?.unwrap()

  forceStatement: ->
    @tags.statement: true
    this

  # Tag a chain of **IfNodes** with their object(s) to switch on for equality
  # tests. `rewriteSwitch` will perform the actual change at compile time.
  switchesOver: (expression) ->
    @switchSubject: expression
    this

  # Rewrite a chain of **IfNodes** with their switch condition for equality.
  # Ensure that the switch expression isn't evaluated more than once.
  rewriteSwitch: (o) ->
    @assigner: @switchSubject
    unless (@switchSubject.unwrap() instanceof LiteralNode)
      variable: literal(o.scope.freeVariable())
      @assigner: new AssignNode(variable, @switchSubject)
      @switchSubject: variable
    @condition: for cond, i in flatten [@condition]
      cond: new ParentheticalNode(cond) if cond instanceof OpNode
      new OpNode('==', (if i is 0 then @assigner else @switchSubject), cond)
    @elseBodyNode().switchesOver(@switchSubject) if @isChain
    # prevent this rewrite from happening again
    @switchSubject: undefined
    this

  # Rewrite a chain of **IfNodes** to add a default case as the final *else*.
  addElse: (elseBody, statement) ->
    if @isChain
      @elseBodyNode().addElse elseBody, statement
    else
      @isChain: elseBody instanceof IfNode
      @elseBody: @ensureExpressions elseBody
    this

  # The **IfNode** only compiles into a statement if either of its bodies needs
  # to be a statement. Otherwise a ternary is safe.
  isStatement: ->
    @statement: or !!(@tags.statement or @bodyNode().isStatement() or (@elseBody and @elseBodyNode().isStatement()))

  compileCondition: (o) ->
    (cond.compile(o) for cond in flatten([@condition])).join(' || ')

  compileNode: (o) ->
    if @isStatement() then @compileStatement(o) else @compileTernary(o)

  makeReturn: ->
    if @isStatement()
      @body:      and @ensureExpressions(@body.makeReturn())
      @elseBody:  and @ensureExpressions(@elseBody.makeReturn())
      this
    else
      new ReturnNode this

  ensureExpressions: (node) ->
    if node instanceof Expressions then node else new Expressions [node]

  # Compile the **IfNode** as a regular *if-else* statement. Flattened chains
  # force inner *else* bodies into statement form.
  compileStatement: (o) ->
    @rewriteSwitch(o) if @switchSubject
    child:        del o, 'chainChild'
    condO:       merge o
    o.indent:     @idt 1
    o.top:        true
    ifDent:      if child then '' else @idt()
    comDent:     if child then @idt() else ''
    body:         @body.compile(o)
    ifPart:      "${ifDent}if (${ @compileCondition(condO) }) {\n$body\n$@tab}"
    return ifPart unless @elseBody
    elsePart: if @isChain
      ' else ' + @elseBodyNode().compile(merge(o, {indent: @idt(), chainChild: true}))
    else
      " else {\n${ @elseBody.compile(o) }\n$@tab}"
    "$ifPart$elsePart"

  # Compile the IfNode as a ternary operator.
  compileTernary: (o) ->
    o.operation: true
    ifPart:      @condition.compile(o) + ' ? ' + @bodyNode().compile(o)
    elsePart:    if @elseBody then @elseBodyNode().compile(o) else 'null'
    "$ifPart : $elsePart"

# 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.__superClass__ = parent.prototype;
              }
            """

  # 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: '  '

# Trim out all trailing whitespace, so that the generated code plays nice
# with Git.
TRAILING_WHITESPACE: /[ \t]+$/gm

# Obvious redundant parentheses should be removed.
DOUBLE_PARENS: /\(\(([^\(\)\n]*)\)\)/g

# Keep these identifier regexes in sync with the Lexer.
IDENTIFIER: /^[a-zA-Z\$_](\w|\$)*$/
NUMBER    : /^(((\b0(x|X)[0-9a-fA-F]+)|((\b[0-9]+(\.[0-9]+)?|\.[0-9]+)(e[+\-]?[0-9]+)?)))\b$/i
SIMPLENUM : /^-?\d+/

# Is a literal value a string?
IS_STRING: /^['"]/

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

# Handy helper for a generating LiteralNode.
literal: (name) ->
  new LiteralNode(name)

# Helper for ensuring that utility functions are assigned at the top level.
utility: (name) ->
  ref: "__$name"
  Scope.root.assign ref, UTILITIES[name]
  ref