   empty: ->
     @expressions.length is 0
 
-  # make a copy of this node
+  # 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
+    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
-
+    idx:  @expressions.length - 1
+    last: @expressions[idx]
+    last: @expressions[idx -= 1] if last instanceof CommentNode
+    return this if not last or last instanceof ReturnNode
+    @expressions[idx]: last.make_return() unless last.contains_pure_statement()
+    this
 
   # An **Expressions** is the only node that can serve as the root.
   compile: (o) ->

  # statement, ask the statement to do so.
  compile_expression: (node, o) ->
    @tab: o.indent
    stmt:    node.is_statement()
    compiled_node = node.compile(merge(o, {top:true}))
    return compiled_node if stmt
    return "${@idt()}${compiled_node};"

# Wrap up the given nodes as an **Expressions**, unless it already happens
# to be one.

  is_statement: ->
    @expression.is_statement()

  make_return: ->
    @expression.make_return()

  compile_node: (o) ->
    code: @expression.compile(o)
