   # Compile a vanilla function call.
   compileNode: (o) ->
     @variable?.front = @front
-    if code = Splat.compileSplattedArray o, @args, true
-      return @compileSplat o, code
+    compiledArray = Splat.compileSplattedArray o, @args, true
+    if compiledArray.length
+      return @compileSplat o, compiledArray
     args = @filterImplicitObjects @args
-    args = (arg.compile o, LEVEL_LIST for arg in args).join ', '
+    compiledArgs = []
+    for arg, argIndex in args
+      if argIndex then compiledArgs.push @makeCode ", "
+      compiledArgs.push (arg.compileToFragments o, LEVEL_LIST)...
+
+    fragments = []
     if @isSuper
-      @superReference(o) + ".call(#{@superThis(o)}#{ 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.
-  # TODO: This looks like it is never called?
-  compileSuper: (args, o) ->
-    "#{@superReference(o)}.call(#{@superThis(o)}#{ if args.length then ', ' else '' }#{args})"
+      preface = @superReference(o) + ".call(#{@superThis(o)}"
+      if compiledArgs.length then preface += ", "
+      fragments.push @makeCode preface
+    else
+      if @isNew then fragments.push @makeCode 'new '
+      fragments.push (@variable.compileToFragments(o, LEVEL_ACCESS))...
+      fragments.push @makeCode "("
+    fragments.push compiledArgs...
+    fragments.push @makeCode ")"
+    fragments
 
   # 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.
+  #
+  # splatArgs is an array of CodeFragments to put into the 'apply'.
   compileSplat: (o, splatArgs) ->
-    return "#{ @superReference o }.apply(#{@superThis(o)}, #{splatArgs})" if @isSuper
+    if @isSuper
+      return [].concat @makeCode("#{ @superReference o }.apply(#{@superThis(o)}, "),
+        splatArgs, @makeCode(")")
+
     if @isNew
       idt = @tab + TAB
-      return """
+      return [].concat @makeCode("""
         (function(func, args, ctor) {
         #{idt}ctor.prototype = func.prototype;
         #{idt}var child = new ctor, result = func.apply(child, args);
         #{idt}return Object(result) === result ? result : child;
-        #{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function(){})
-      """
+        #{@tab}})("""),
+        (@variable.compileToFragments o, LEVEL_LIST),
+        @makeCode(", "), splatArgs, @makeCode(", function(){})")
+
+    answer = []
     base = Value.wrap @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
-      fun = "(#{fun})" if SIMPLENUM.test fun
+      answer = answer.concat @makeCode("(#{ref} = "),
+        (base.compileToFragments o, LEVEL_LIST),
+        @makeCode(")"),
+        name.compileToFragments(o)
+    else
+      fun = base.compileToFragments o, LEVEL_ACCESS
+      fun = @wrapInBraces fun if SIMPLENUM.test fragmentsToText fun
       if name
-        ref = fun
-        fun += name.compile o
+        ref = fragmentsToText fun
+        fun.push (name.compileToFragments o)...
       else
         ref = 'null'
-    "#{fun}.apply(#{ref}, #{splatArgs})"
+      answer = answer.concat fun
+    answer = answer.concat @makeCode(".apply(#{ref}, "), splatArgs, @makeCode(")")
 
 #### Extends
 

    post   = "{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}"
    hasArgs = (node) -> node?.contains (n) -> n instanceof Literal and n.value is 'arguments' and not n.asKey
    args   = ', arguments' if hasArgs(@from) or hasArgs(@to)
    "(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this#{args ? ''})"

#### Slice


    else
      to = "9e9"
    [valDef, valRef] = @value.cache o, LEVEL_LIST
    answer = [].concat @makeCode("[].splice.apply(#{name}, [#{fromDecl}, #{to}].concat("), valDef, @makeCode(")), "), valRef
    if o.level > LEVEL_TOP then @wrapInBraces answer else answer

#### Code

