     # Note that generated nodes will have the `node.coffeeCoverage.generated` flag set,
     # and will be skipped when instrumenting code.
     #
-    insertAtStart: (attr, csSource) ->
-        child = @node[attr]
+    insertAtStart: (childName, csSource) ->
+        child = @node[childName]
 
-        if @type is 'Block' and attr is 'expressions'
+        if @type is 'Block' and childName is 'expressions'
             if !child
-                @node[attr] = [compile(csSource, @node)]
+                @node[childName] = [compile(csSource, @node)]
             else
-                @node[attr].unshift compile(csSource, @node)
+                @node[childName].unshift compile(csSource, @node)
 
         else if child?.constructor?.name is 'Block'
             child.expressions.unshift compile(csSource, child)
 
         else if !child
             # This will generate a 'Block'
-            @node[attr] = compile(csSource, @node)
+            @node[childName] = compile(csSource, @node)
 
         else
-            throw new Error "Don't know how to insert statement into #{@type}.#{attr}: #{@type[attr]}"
+            throw new Error "Don't know how to insert statement into #{@type}.#{childName}: #{@type[childName]}"
 
     toString: ->
         answer = ''
-        if @childAttr then answer += "#{@childAttr}[#{@childIndex}]:"
+        if @childName then answer += "#{@childName}[#{@childIndex}]:"
         answer += @type
         if @node.locationData? then answer += " (#{@node.locationData?.first_line + 1}:#{@node.locationData.first_column + 1})"
 

# Properties:
# * `node` - The original coffee-script node.
# * `parent` - A `NodeWrapper` object for the parent of the coffee-script node.
# * `childAttr` - A coffee-script node has multiple named children.  This is the name of the
#   attribute which contains this node in `@parent.node`.  Note that `@parent.node[childAttr]`
#   may be a single Node or it may be an array of nodes, depending on the implementation of the
#   specific node type.
# * `childIndex` - Where `@parent.node[childAttr]` is an array, this is the index of `@node`
#   in `@parent.node[childAttr]`.  Note that inserting new nodes will obviously invalidate this
#   value, so this is more of a "hint" than a hard and fast truism.
# * `depth` - The depth in the AST from the root node.
# * `type` - Copy of @node.constructor.name.

    # and will be skipped when instrumenting code.
    #
    insertBefore: (csSource) ->
        assert _.isArray @parent.node[@childName]

        compiled = compile csSource, @node

        # childIndex is more of a hint, since nodes can move around.
        if @parent.node[@childName][@childIndex] isnt @node
            childIndex = _.indexOf @parent.node[@childName], @node
            if childIndex is -1 then throw new Error "Can't find node in parent"
            @childIndex = childIndex

        @parent.node[@childName].splice(@childIndex, 0, compiled)

    # Insert a chunk of code at the start of a child of this node.  E.g. if this is a Block,
    # then `insertAtStart('expressions', 'console.log "foo"'')` would add a `console.log`
