     right = @build right_obj
 
     if n.isThis and n.isPrototype
-      "@::"
+      @l(n)+"@::"
     else if n.isThis
-      "@#{right}"
+      @l(n)+"@#{right}"
     else if n.isPrototype
-      "#{left}::"
+      @l(n)+"#{left}::"
     else if n.left().isPrototype
-      "#{left}#{right}"
-    else
-      "#{left}.#{right}"
+      @l(n)+"#{left}#{right}"
+    else
+      @l(n)+"#{left}.#{right}"
 
   'try': (n) ->
-    c = new Code @,n
-    c.add 'try',n
-    c.scope @body(n.tryBlock),1,n.tryBlock # TODO: write comments test
+    c = new Code
+    c.add 'try'
+    c.scope @body(n.tryBlock)
 
     _.each n.catchClauses, (clause) =>
       c.add @build(clause)
 
     if n.finallyBlock?
-      c.add "finally",n.finallyBlock
+      c.add "finally"
       c.scope @body(n.finallyBlock),1,n.finallyBlock
 
-    c
+    @l(n)+c
 
   'catch': (n) ->
     body_ = @body(n.block)
     return '' if trim(body_).length == 0
 
-    c = new Code @,n
+    c = new Code
 
     if n.varName?
-      c.add "catch #{n.varName}",n
-    else
-      c.add 'catch',n
+      c.add "catch #{n.varName}"
+    else
+      c.add 'catch'
 
     c.scope @body(n.block),1,n.block
-    c
+    @l(n)+c
 
   # `?` (ternary operator)  
   # For `a ? b : c`. Note that these will always be parenthesized, as (I
   # believe) the order of operations in JS is different in CS.
 
   '?': (n) ->
-    "(if #{@build n.left()} then #{@build n.children[1]} else #{@build n.children[2]})"
+    @l(n)+"(if #{@build n.left()} then #{@build n.children[1]} else #{@build n.children[2]})"
 
   'for': (n) ->
-    c = new Code @,n
+    c = new Code
 
     if n.setup?
-      c.add "#{@build n.setup}#{@nl(n.setup)}",n.setup
+      c.add "#{@build n.setup}\n"
 
     if n.condition?
-      c.add "while #{@build n.condition}#{@nl(n.condition)}"
+      c.add "while #{@build n.condition}\n"
     else
       c.add "loop"
 
-    c.scope @body(n.body),1,n.body
-    c.scope @body(n.update),1,n.update  if n.update?
-    c
+    c.scope @body(n.body)
+    c.scope @body(n.update)  if n.update?
+    @l(n)+c
 
   'for_in': (n) ->
-    c = new Code @,n
+    c = new Code
 
     c.add "for #{@build n.iterator} of #{@build n.object}"
     c.scope @body(n.body)
-    c
+    @l(n)+c
 
   'while': (n) ->
-    c = new Code @,n
+    c = new Code
 
     keyword   = if n.positive then "while" else "until"
     body_     = @body(n.body)

    # sometimes. They should be ignored.

    unless n.expression?
      ""

    else if n.expression.typeName() == 'object_init'

      src = @object_init(n.expression)
      if n.parenthesized
        src
      else
        "#{unshift(blockTrim(src))}#{@line_comment(n.lineno)}#{@nl(n)}"

    else
      @build(n.expression) + "#{@nl(n)}"

  # `new` + `new_with_args`  
  # For `new X` and `new X(y)` respctively.

  'new': (n) -> "new #{@build n.left()}"
  'new_with_args': (n) -> "new #{@build n.left()}(#{@build n.right()})"

  # ### Unary operators



  'increment_decrement': (n, sign) ->
    if n.postfix
      @l(n)+"#{@build n.left()}#{sign}"
    else
      @l(n)+"#{sign}#{@build n.left()}"

  # `=` (aka, assignment)  
  # For `a = b` (but not `var a = b`: that's `var`).
