       else
         new Op $2, $1, $3
 
-    o 'SimpleAssignable COMPOUND_ASSIGN Expression', -> new Assign $1, $3, $2
-    o 'SimpleAssignable COMPOUND_ASSIGN INDENT Expression OUTDENT', -> new Assign $1, $4, $2
+    o 'SimpleAssignable COMPOUND_ASSIGN
+       Expression',                             -> new Assign $1, $3, $2
+    o 'SimpleAssignable COMPOUND_ASSIGN
+       INDENT Expression OUTDENT',              -> new Assign $1, $4, $2
   ]
 
 


  # A return statement from a function body.
  Return: [
    o "RETURN Expression",                      -> new Return $2
    o "RETURN",                                 -> new Return
  ]

  # A block comment.
  Comment: [
    o "HERECOMMENT",                            -> new Comment $1
  ]

  # [The existential operator](http://jashkenas.github.com/coffee-script/#existence).
  Existence: [
    o "Expression ?",                           -> new Existence $1
  ]

  # The **Code** node is the function literal. It's defined by an indented block
  # of **Expressions** preceded by a function arrow, with an optional parameter
  # list.
  Code: [
    o "PARAM_START ParamList PARAM_END FuncGlyph Block", -> new Code $2, $5, $4
    o "FuncGlyph Block",                        -> new Code [], $2, $1
  ]

  # CoffeeScript has two different symbols for functions. `->` is for ordinary
  # functions, and `=>` is for functions bound to the current value of *this*.
  FuncGlyph: [
    o "->",                                     -> 'func'
    o "=>",                                     -> 'boundfunc'
  ]

  # An optional, trailing comma.

  # The types of things that can be treated as values -- assigned to, invoked
  # as functions, indexed into, named as a class, etc.
  Value: [
    o 'Assignable'
    o 'Literal',                                -> new Value $1
    o 'Parenthetical',                          -> new Value $1
    o 'This'
  ]

  # The general group of accessors into an object, by property, by prototype
  # or by array index or slice.
  Accessor: [
    o 'PROPERTY_ACCESS Identifier',             -> new Accessor $2
    o 'PROTOTYPE_ACCESS Identifier',            -> new Accessor $2, 'prototype'
    o '::',                                     -> new Accessor new Literal 'prototype'
    o 'SOAK_ACCESS Identifier',                 -> new Accessor $2, 'soak'
    o 'Index'
  ]

  # Indexing into an object or array using bracket notation.
  Index: [
    o 'INDEX_START Expression INDEX_END',       -> new Index $2
    o 'INDEX_SOAK  Index',                      -> extend $2, soakNode: yes
    o 'INDEX_PROTO Index',                      -> extend $2, proto: yes
  ]

  # In CoffeeScript, an object literal is simply a list of assignments.
  Object: [
    o '{ AssignList OptComma }',                -> new Obj $2
  ]

  # Assignment of properties within an object literal can be separated by
  # comma, as in JavaScript, or simply by newline.
  AssignList: [
    o '',                                                       -> []
    o 'AssignObj',                                              -> [$1]
    o 'AssignList , AssignObj',                                 -> $1.concat $3
    o 'AssignList OptComma TERMINATOR AssignObj',               -> $1.concat $4
    o 'AssignList OptComma INDENT AssignList OptComma OUTDENT', -> $1.concat $4
  ]

  # Class definitions have optional bodies of prototype property assignments,
  # and optional references to the superclass.
  Class: [
    o 'CLASS SimpleAssignable',               -> new Class $2
    o 'CLASS SimpleAssignable EXTENDS Value', -> new Class $2, $4
    o 'CLASS SimpleAssignable
       INDENT ClassBody OUTDENT',             -> new Class $2, null, $4
    o 'CLASS SimpleAssignable EXTENDS Value
       INDENT ClassBody OUTDENT',             -> new Class $2, $4, $6
    o 'CLASS INDENT ClassBody OUTDENT',       -> new Class null, null, $3
    o 'CLASS',                                -> new Class null, null, new Expressions
    o 'CLASS EXTENDS Value',                  -> new Class null, $3  , new Expressions
    o 'CLASS EXTENDS Value
       INDENT ClassBody OUTDENT',             -> new Class null, $3, $5
  ]

  # Assignments that can happen directly inside a class declaration.
  ClassAssign: [
    o 'AssignObj',                                -> $1
    o 'ThisProperty : Expression',                -> new Assign new Value($1), $3, 'this'
    o 'ThisProperty : INDENT Expression OUTDENT', -> new Assign new Value($1), $4, 'this'
  ]

  # A list of assignments to a class.
  ClassBody: [
    o '',                                       -> []
    o 'ClassAssign',                            -> [$1]
    o 'ClassBody TERMINATOR ClassAssign',       -> $1.concat $3
    o '{ ClassBody }',                          -> $2
  ]

  # Extending an object by setting its prototype chain to reference a parent
  # object.
  Extends: [
    o 'SimpleAssignable EXTENDS Value',         -> new Extends $1, $3
  ]

  # Ordinary function invocation, or a chained series of calls.
  Invocation: [
    o 'Value OptFuncExist Arguments',           -> new Call $1, $3, $2
    o 'Invocation OptFuncExist Arguments',      -> new Call $1, $3, $2
    o 'SUPER',                                  ->
      new Call 'super', [new Splat new Literal 'arguments']
    o 'SUPER Arguments',                        ->
      new Call 'super', $2
  ]

  # An optional existence check on a function.
  OptFuncExist: [
    o '',                                       -> no
    o 'FUNC_EXIST',                             -> yes
  ]

  # The list of arguments to a function call.
  Arguments: [
    o 'CALL_START CALL_END',                    -> []
    o 'CALL_START ArgList OptComma CALL_END',   -> $2
  ]

  # A reference to the *this* current object.
  This: [
    o 'THIS',                                   -> new Value new Literal 'this'
    o '@',                                      -> new Value new Literal 'this'
  ]

  # A reference to a property on *this*.
  ThisProperty: [
    o '@ Identifier', -> new Value new Literal('this'), [new Accessor($2)], 'this'
  ]

  # The array literal.
  Array: [
    o '[ ]',                                    -> new Arr []
    o '[ ArgList OptComma ]',                   -> new Arr $2
  ]

  # The **ArgList** is both the list of objects passed into a function call,
  # as well as the contents of an array literal
  # (i.e. comma-separated expressions). Newlines work as well.
  ArgList: [
    o 'Arg',                                              -> [$1]
    o 'ArgList , Arg',                                    -> $1.concat $3
    o 'ArgList OptComma TERMINATOR Arg',                  -> $1.concat $4
    o 'INDENT ArgList OptComma OUTDENT',                  -> $2
    o 'ArgList OptComma INDENT ArgList OptComma OUTDENT', -> $1.concat $4
  ]

  # Valid arguments are Expressions or Splats.
  Arg: [
    o 'Expression'
    o 'Splat'
  ]

  # Just simple, comma-separated, required arguments (no fancy syntax). We need
  # this to be separate from the **ArgList** for use in **Switch** blocks, where
  # having the newlines wouldn't make sense.
  SimpleArgs: [
    o 'Expression'
    o 'SimpleArgs , Expression',                -> [].concat $1, $3
  ]

  # The variants of *try/catch/finally* exception handling blocks.
  Try: [
    o 'TRY Block',                              -> new Try $2
    o 'TRY Block Catch',                        -> new Try $2, $3[0], $3[1]
    o 'TRY Block FINALLY Block',                -> new Try $2, null, null, $4
    o 'TRY Block Catch FINALLY Block',          -> new Try $2, $3[0], $3[1], $5
  ]

  # A catch clause names its error and runs a block of code.
  Catch: [
    o 'CATCH Identifier Block',                 -> [$2, $3]
  ]

  # Throw an exception object.
  Throw: [
    o 'THROW Expression',                       -> new Throw $2
  ]

  # Parenthetical expressions. Note that the **Parenthetical** is a **Value**,
