     super(idt, @class + ' ' + @operator)
 
   compileNode: (o) ->
+    return node.compile o if node = ValueNode.unfoldSoak o, this, 'first'
     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()


  # Grab the reference to the superclass' implementation of the current method.
  superReference: (o) ->
    throw new Error "cannot call super outside of a function" unless o.scope.method
    methname = o.scope.method.name
    meth = if o.scope.method.proto
      "#{o.scope.method.proto}.__super__.#{methname}"
    else if methname
      "#{methname}.__super__.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
    op = @tags.operation
    if @exist
      if @variable instanceof ValueNode and
         last(@variable.properties) instanceof AccessorNode
        methodAccessor = @variable.properties.pop()
        [first, meth] = @variable.compileReference o
        @first = new ValueNode(first, [methodAccessor]).compile o
        @meth = new ValueNode(meth, [methodAccessor]).compile o
      else
        [@first, @meth] = @variable.compileReference o, precompile: yes
      @first = "(typeof #{@first} === \"function\" ? "
      @last  = " : undefined)"
    else if @variable
      @meth = @variable.compile o
    for arg in @args when arg instanceof SplatNode
      code = @compileSplat(o)
    if not code
      args = for arg in @args
        arg.parenthetical = true
        arg.compile o
      code = if @isSuper
        @compileSuper(args.join(', '), o)
      else
        "#{@first}#{@prefix()}#{@meth}(#{ args.join(', ') })#{@last}"
    if op and @variable and @variable.wrapped then "(#{code})" else code

  # `super()` is converted into a call against the superclass's implementation
  # of the current function.

    return "#{first} = #{ ExistenceNode.compileTest(o, literal(firstVar))[0] } ? #{firstVar} : #{second}" if @operator is '?='
    "#{first} #{ @operator.substr(0, 2) } (#{firstVar} = #{second})"

  compileExistence: (o) ->
    if @first.isComplex()
      ref = o.scope.freeVariable 'ref'
      fst = new ParentheticalNode new AssignNode literal(ref), @first
    else
      fst = @first
      ref = fst.compile o
    new ExistenceNode(fst).compile(o) + " ? #{ref} : #{ @second.compile o }"

  # Compile a unary **OpNode**.
  compileUnary: (o) ->
