 
   # Is this node of a certain type, or does it contain the type?
   containsType: (type) ->
-    this instanceof type or @contains (n) -> n instanceof type
+    this instanceof type or @contains (node) -> node instanceof type
 
   # Convenience for the most common use of contains. Does the node contain
   # a pure statement?
   containsPureStatement: ->
-    @isPureStatement() or @contains (n) -> n.isPureStatement?()
+    @isPureStatement() or @contains (node) -> node.isPureStatement()
 
   # Perform an in-order traversal of the AST. Crosses scope boundaries.
   traverse: (block) -> @traverseChildren true, block

# Utility Functions
# -----------------

# Handy helper for a generating LiteralNode.
literal = (name) ->
  new LiteralNode(name)

# Helper for ensuring that utility functions are assigned at the top level.
utility = (name) ->

  # equivalent syntax tree and compile that, in pieces. You can see the
  # constructor, property assignments, and inheritance getting built out below.
  compileNode: (o) ->
    {variable} = this
    variable   = literal o.scope.freeVariable 'ctor' if variable.value is '__temp__'
    extension  = @parent and new ExtendsNode variable, @parent
    props      = new Expressions
    o.top      = true
    me         = null
    className  = variable.compile o
    constScope = null

    if @parent
