   type: 'Call'
 
   constructor: (variable, args) ->
-    @children: flatten [@variable: variable, @args: (args or [])]
+    @is_new:   false
+    @is_super: variable is 'super'
+    @variable: if @is_super then null else variable
+    @children: compact flatten [@variable, @args: (args or [])]
     @compile_splat_arguments: SplatNode.compile_mixed_array <- @, @args
-    @is_new: false
 
   # Tag this invocation as creating a new instance.
   new_instance: ->

  empty: ->
    @expressions.length is 0

  # make a copy of this node
  copy: ->
    new Expressions(@children.slice())

  # an Expressions node does not return its entire body, rather it
  # ensures that the final expression is returned
  make_return: ->
    last_expr_idx: -1
    for i in [@expressions.length-1 .. 0]
      if not (@expressions[i] instanceof CommentNode)
        last_expr_idx: i
        last_expr: @expressions[i]
        break

    if last_expr_idx < 0
      # just add a return null to ensure return is always called
      @push(new ReturnNode(literal(null)))
    else
      return this if (last_expr instanceof ReturnNode)
      @push(new ReturnNode(literal(null))) if last_expr.is_statement()

      # we still make an attempt at converting statements,
      # since many are able to be returned in some fashion
      try
        converted = last_expr.make_return()
        @expressions[last_expr_idx] = converted
      catch e
        # ignore
    return this


  # An **Expressions** is the only node that can serve as the root.
  compile: (o) ->

    @variable instanceof ValueNode

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

  is_statement: ->
    @is_value() and (@variable.is_array() or @variable.is_object())
