opal 0.3.44 → 0.4.0

data/lib/opal/lexer.rb

@@ -487,6 +487,9 @@ module Opal
           if [:expr_beg, :expr_mid, :expr_class].include? @lex_state
             @lex_state = :expr_beg
             return '::@', scanner.matched
+          elsif space_seen && @lex_state == :expr_arg
+            @lex_state = :expr_beg
+            return '::@', scanner.matched
           end
 
           @lex_state = :expr_dot
@@ -665,8 +668,7 @@ module Opal
           return [result, result]
 
         elsif scanner.scan(/\?/)
-          # FIXME: :expr_arg shouldnt really be here
-          if [:expr_end, :expr_endarg, :expr_arg].include?(@lex_state)
+          if [:expr_end, :expr_endarg].include?(@lex_state)
             @lex_state = :expr_beg
             return '?', scanner.matched
           end

data/lib/opal/parser.rb

@@ -1,10 +1,33 @@
 require 'opal/lexer'
 require 'opal/grammar'
 require 'opal/target_scope'
+require 'opal/version'
 
 module Opal
   class Parser
 
+    class Fragment
+
+      attr_reader :code
+
+      def initialize(code, sexp = nil)
+        @code = code
+        @sexp = sexp
+      end
+
+      def to_code
+        if @sexp
+          "/*:#{@sexp.line}*/#{@code}"
+        else
+          @code
+        end
+      end
+
+      def inspect
+        "fragment(#{@code.inspect})"
+      end
+    end
+
     # Generated code gets indented with two spaces on each scope
     INDENT = '  '
 
@@ -28,15 +51,10 @@ module Opal
     # Statements which should not have ';' added to them.
     STATEMENTS = [:xstr, :dxstr]
 
-    # Holds an array of paths which this file "requires".
-    # @return [Array<String>]
-    attr_reader :requires
-
     attr_reader :result
 
     def parse(source, options = {})
       @sexp = Grammar.new.parse(source, options[:file])
-      @requires = []
       @line     = 1
       @indent   = ''
       @unique   = 0
@@ -47,14 +65,32 @@ module Opal
       }
 
       # options
-      @file     = options[:file] || '(file)'
-      @method_missing = (options[:method_missing] != false)
-      @optimized_operators = (options[:optimized_operators] != false)
-      @arity_check = options[:arity_check]
-      @const_missing = (options[:const_missing] != false)
-      @dynamic_require_severity = (options[:dynamic_require_severity] || :error)
+      @file                     =  options[:file] || '(file)'
+      @source_file              =  options[:source_file] || @file
+      @method_missing           = (options[:method_missing] != false)
+      @optimized_operators      = (options[:optimized_operators] != false)
+      @arity_check              =  options[:arity_check]
+      @const_missing            = (options[:const_missing] != false)
+      @irb_vars                 = (options[:irb] == true)
+      @source_map               = (options[:source_map_enabled] != false)
+
+      fragments = self.top(@sexp).flatten
 
-      @result = top(@sexp)
+      code = @source_map ? fragments.map(&:to_code).join('') : fragments.map(&:code).join('')
+
+      @result = source_map_comment + version_comment + file_comment + code
+    end
+
+    def version_comment
+      "/* Generated by Opal #{Opal::VERSION} */\n"
+    end
+
+    def source_map_comment
+      @source_map ? "//@ sourceMappingURL=/__opal_source_maps__/#{@file}.js.map\n" : ''
+    end
+
+    def file_comment
+      @source_map ? "/*-file:#{@source_file}-*/" : ''
     end
 
     # This is called when a parsing/processing error occurs. This
@@ -101,6 +137,12 @@ module Opal
       sexp
     end
 
+    # @param [String] code the string of code
+    # @return [Fragment]
+    def fragment(code, sexp = nil)
+      Fragment.new(code, sexp)
+    end
+
     # Converts a ruby method name into its javascript equivalent for
     # a method/function call. All ruby method names get prefixed with
     # a '$', and if the name is a valid javascript identifier, it will
@@ -138,24 +180,35 @@ module Opal
     # @param [Array] sexp the sexp to process
     # @return [String]
     def top(sexp, options = {})
-      code = nil
+      code, vars = nil, nil
+
+      # empty file = nil as our top sexp
+      sexp = s(:nil) unless sexp
 
       in_scope(:top) do
         indent {
-          code = @indent + process(s(:scope, sexp), :stmt)
+          scope = s(:scope, sexp)
+          scope.line = sexp.line
+
+          code = process(scope, :stmt)
+          code.unshift fragment(@indent, sexp)
         }
 
         @scope.add_temp "self = __opal.top"
         @scope.add_temp "__scope = __opal"
-        @scope.add_temp "nil = __opal.nil"
         @scope.add_temp "$mm = __opal.mm"
-        @scope.add_temp "def = #{current_self}._klass.prototype" if @scope.defines_defn
+        @scope.add_temp "nil = __opal.nil"
+        @scope.add_temp "def = #{current_self}.constructor.prototype" if @scope.defines_defn
         @helpers.keys.each { |h| @scope.add_temp "__#{h} = __opal.#{h}" }
 
-        code = INDENT + @scope.to_vars + "\n" + code
+        vars = [fragment(INDENT, sexp), @scope.to_vars, fragment("\n", sexp)]
+
+        if @irb_vars
+          code.unshift fragment("if (!Opal.irb_vars) { Opal.irb_vars = {}; }\n", sexp)
+        end
       end
 
-      "(function(__opal) {\n#{ code }\n})(Opal);\n"
+      [fragment("(function(__opal) {\n", sexp), vars, code, fragment("\n})(Opal);\n", sexp)]
     end
 
     # Every time the parser enters a new scope, this is called with
@@ -271,7 +324,7 @@ module Opal
 
       @line = sexp.line
 
-      __send__ meth, sexp, level
+      __send__(meth, sexp, level)
     end
 
     # The last sexps in method bodies, for example, need to be returned
@@ -371,21 +424,30 @@ module Opal
       result = []
       sexp << s(:nil) if sexp.empty?
 
+      join = (@scope.class_scope? ? "\n\n#@indent" : "\n#@indent")
+
       until sexp.empty?
         stmt = sexp.shift
-        type = stmt.first
+
+        result << fragment(join, sexp) unless result.empty?
 
         # find any inline yield statements
         if yasgn = find_inline_yield(stmt)
-          result << "#{process(yasgn, level)};"
+          result << process(yasgn, level)
+          result << fragment(";", yasgn)
         end
 
         expr = expression?(stmt) and LEVEL.index(level) < LEVEL.index(:list)
+
         code = process(stmt, level)
-        result << (expr ? "#{code};" : code) unless code == ""
+
+        result << code
+        if expr
+          result << fragment(";", stmt)
+        end
       end
 
-      result.join(@scope.class_scope? ? "\n\n#@indent" : "\n#@indent")
+      result
     end
 
     # When a block sexp gets generated, any inline yields (i.e. yield
@@ -440,28 +502,30 @@ module Opal
     def process_scope(sexp, level)
       stmt = sexp.shift
       if stmt
-        stmt = returns stmt unless @scope.class_scope?
-        code = process stmt, :stmt
+        unless @scope.class_scope?
+          stmt = returns stmt
+        end
+
+        process stmt, :stmt
       else
-        code = "nil"
+        fragment("nil", sexp)
       end
-
-      code
     end
 
     # s(:js_return, sexp)
     def process_js_return(sexp, level)
-      "return #{process sexp.shift, :expr}"
+      [fragment("return ", sexp), process(sexp.shift, :expr)]
     end
 
     # s(:js_tmp, str)
     def process_js_tmp(sexp, level)
-      sexp.shift.to_s
+      fragment(sexp.shift.to_s, sexp)
     end
 
     def process_operator(sexp, level)
       meth, recv, arg = sexp
       mid = mid_to_jsid meth.to_s
+      result = []
 
       if @optimized_operators
         with_temp do |a|
@@ -469,21 +533,27 @@ module Opal
             l = process recv, :expr
             r = process arg, :expr
 
-            "(%s = %s, %s = %s, typeof(%s) === 'number' ? %s %s %s : %s%s(%s))" %
-              [a, l, b, r, a, a, meth.to_s, b, a, mid, b]
+            result << fragment("(#{a} = ", sexp)
+            result << l
+            result << fragment(", #{b} = ", sexp)
+            result << r
+            result << fragment(", typeof(#{a}) === 'number' ? #{a} #{meth} #{b} ", sexp)
+            result << fragment(": #{a}#{mid}(#{b}))", sexp)
           end
         end
       else
         "#{process recv, :recv}#{mid}(#{process arg, :expr})"
       end
+
+      result
     end
 
     def js_block_given(sexp, level)
       @scope.uses_block!
       if @scope.block_name
-        "(#{@scope.block_name} !== nil)"
+        fragment("(#{@scope.block_name} !== nil)", sexp)
       else
-        "false"
+        fragment("false", sexp)
       end
     end
 
@@ -491,7 +561,7 @@ module Opal
       @scope.uses_block!
       name = @scope.block_name
 
-      reverse ? "#{ name } === nil" : "#{ name } !== nil"
+      fragment((reverse ? "#{ name } === nil" : "#{ name } !== nil"), sexp)
     end
 
     # s(:lit, 1)
@@ -500,11 +570,15 @@ module Opal
       val = sexp.shift
       case val
       when Numeric
-        level == :recv ? "(#{val.inspect})" : val.inspect
+        if level == :recv
+          fragment("(#{val.inspect})", sexp)
+        else
+          fragment(val.inspect, sexp)
+        end
       when Symbol
-        val.to_s.inspect
+        fragment(val.to_s.inspect, sexp)
       when Regexp
-        val == // ? /^/.inspect : val.inspect
+        fragment((val == // ? /^/.inspect : val.inspect), sexp)
       when Range
         @helpers[:range] = true
         "__range(#{val.begin}, #{val.end}, #{val.exclude_end?})"
@@ -514,31 +588,37 @@ module Opal
     end
 
     def process_dregx(sexp, level)
-      parts = sexp.map do |part|
+      result = []
+
+      sexp.each do |part|
+        result << fragment(" + ", sexp) unless result.empty?
+
         if String === part
-          part.inspect
+          result << fragment(part.inspect, sexp)
         elsif part[0] == :str
-          process part, :expr
+          result << process(part, :expr)
         else
-          process part[1], :expr
+          result << process(part[1], :expr)
         end
       end
 
-      "(new RegExp(#{parts.join ' + '}))"
+      [fragment("(new RegExp(", sexp), result, fragment("))", sexp)]
     end
 
     def process_dot2(sexp, level)
       lhs = process sexp[0], :expr
       rhs = process sexp[1], :expr
       @helpers[:range] = true
-      "__range(%s, %s, false)" % [lhs, rhs]
+
+      [fragment("__range(", sexp), lhs, fragment(", ", sexp), rhs, fragment(", false)", sexp)]
     end
 
     def process_dot3(sexp, level)
       lhs = process sexp[0], :expr
       rhs = process sexp[1], :expr
       @helpers[:range] = true
-      "__range(%s, %s, true)" % [lhs, rhs]
+
+      [fragment("__range(", sexp), lhs, fragment(", ", sexp), rhs, fragment(", true)", sexp)]
     end
 
     # s(:str, "string")
@@ -546,9 +626,9 @@ module Opal
       str = sexp.shift
       if str == @file
         @uses_file = true
-        @file.inspect
+        fragment(@file.inspect, sexp)
       else
-        str.inspect
+        fragment(str.inspect, sexp)
       end
     end
 
@@ -556,28 +636,30 @@ module Opal
       part = sexp[0]
       case part[0]
       when :self
-        "self".inspect
+        fragment("self".inspect, sexp)
       when :nil
-        "nil".inspect
+        fragment("nil".inspect, sexp)
       when :true
-        "true".inspect
+        fragment("true".inspect, sexp)
       when :false
-        "false".inspect
+        fragment("false".inspect, sexp)
       when :call
         mid = mid_to_jsid part[2].to_s
-        recv = part[1] ? process(part[1], :expr) : current_self
-        "(#{recv}#{mid} ? 'method' : nil)"
+        recv = part[1] ? process(part[1], :expr) : fragment(current_self, sexp)
+        [fragment("(", sexp), recv, fragment("#{mid} ? 'method' : nil)", sexp)]
       when :xstr
-        "(typeof(#{process part, :expression}) !== 'undefined')"
+        [fragment("(typeof(", sexp), process(part, :expr), fragment(") !== 'undefined')", sexp)]
       when :const
-        "(__scope.#{part[1].to_s} != null)"
+        fragment("(__scope.#{part[1].to_s} != null)", sexp)
       when :colon2
-        "false"
+        fragment("false", sexp)
       when :ivar
         ivar_name = part[1].to_s[1..-1]
         with_temp do |t|
-          "((#{t} = #{current_self}[#{ivar_name.inspect}], #{t} != null && #{t} !== nil) ? 'instance-variable' : nil)"
+          fragment("((#{t} = #{current_self}[#{ivar_name.inspect}], #{t} != null && #{t} !== nil) ? 'instance-variable' : nil)", sexp)
         end
+      when :lvar
+        fragment("local-variable", sexp)
       else
         raise "bad defined? part: #{part[0]}"
       end
@@ -586,7 +668,8 @@ module Opal
     # s(:not, sexp)
     def process_not(sexp, level)
       with_temp do |tmp|
-        "(#{tmp} = #{process(sexp.shift, :expr)}, (#{tmp} === nil || #{tmp} === false))"
+        expr = sexp.shift
+        [fragment("(#{tmp} = ", sexp), process(expr, :expr), fragment(", (#{tmp} === nil || #{tmp} === false))", sexp)]
       end
     end
 
@@ -600,10 +683,11 @@ module Opal
 
       body ||= s(:nil)
       body = returns body
-      code = ""
+      code = []
       params = nil
       scope_name = nil
       identity = nil
+      to_vars = nil
 
       args = nil if Fixnum === args # argh
       args ||= s(:masgn, s(:array))
@@ -623,20 +707,20 @@ module Opal
       indent do
         in_scope(:iter) do
           identity = @scope.identify!
-          @scope.add_temp "self = #{identity}._s || this"
+          @scope.add_temp "#{current_self} = #{identity}._s || this"
 
           args[1..-1].each do |arg|
-           arg = arg[1]
-           arg = "#{arg}$" if RESERVED.include? arg.to_s
-            code += "if (#{arg} == null) #{arg} = nil;\n"
+            arg = arg[1]
+            arg = "#{arg}$" if RESERVED.include? arg.to_s
+            code << fragment("if (#{arg} == null) #{arg} = nil;\n", sexp)
           end
 
           params = js_block_args(args[1..-1])
-          # params.unshift '_$'
 
           if splat
+            @scope.add_arg splat
             params << splat
-            code += "#{splat} = __slice.call(arguments, #{len - 1});"
+            code << fragment("#{splat} = __slice.call(arguments, #{len - 1});", sexp)
           end
 
           if block_arg
@@ -644,25 +728,30 @@ module Opal
             @scope.add_temp block_arg
             @scope.add_temp '__context'
             scope_name = @scope.identify!
-            blk = "\n%s%s = %s._p || nil, __context = %s._s, %s.p = null;\n%s" %
-              [@indent, block_arg, scope_name, block_arg, scope_name, @indent]
 
-            code = blk + code
+            blk = []
+            blk << fragment("\n#@indent#{block_arg} = #{scope_name}._p || nil, #{scope_name}.p = null;\n#@indent", sexp)
+
+            code.unshift blk
           end
 
-          code += "\n#@indent" + process(body, :stmt)
+          code << fragment("\n#@indent", sexp)
+          code << process(body, :stmt)
 
           if @scope.defines_defn
             @scope.add_temp "def = ((typeof(#{current_self}) === 'function') ? #{current_self}.prototype : #{current_self})"
           end
 
-          code = "\n#@indent#{@scope.to_vars}\n#@indent#{code}"
+          to_vars = [fragment("\n#@indent", sexp), @scope.to_vars, fragment("\n#@indent", sexp)]
         end
       end
 
-      itercode = "function(#{params.join ', '}) {\n#{code}\n#@indent}"
-      call << ("(%s = %s, %s._s = %s, %s)" % [identity, itercode, identity, current_self, identity])
+      itercode = [fragment("function(#{params.join ', '}) {\n", sexp), to_vars, code, fragment("\n#@indent}", sexp)]
 
+      itercode.unshift fragment("(#{identity} = ", sexp)
+      itercode << fragment(", #{identity}._s = #{current_self}, #{identity})", sexp)
+
+      call << itercode
       process call, level
     end
 
@@ -701,29 +790,22 @@ module Opal
       attrs.each do |attr|
         mid  = attr[1]
         ivar = "@#{mid}".to_sym
-        pre  = @scope.proto
 
         unless meth == :attr_writer
+          out << fragment(", \n#@indent") unless out.empty?
           out << process(s(:defn, mid, s(:args), s(:scope, s(:ivar, ivar))), :stmt)
         end
 
         unless meth == :attr_reader
+          out << fragment(", \n#@indent") unless out.empty?
           mid = "#{mid}=".to_sym
           out << process(s(:defn, mid, s(:args, :val), s(:scope,
                     s(:iasgn, ivar, s(:lvar, :val)))), :stmt)
         end
       end
 
-      out.join(", \n#@indent") + ', nil'
-    end
-
-    def handle_alias_native(sexp)
-      args = sexp[2]
-      meth = mid_to_jsid args[1][1].to_s
-      func = args[2][1]
-
-      @scope.methods << meth
-      "%s%s = %s.%s" % [@scope.proto, meth, @scope.proto, func]
+      out << fragment(", nil")
+      out
     end
 
     # s(:call, recv, :mid, s(:arglist))
@@ -732,21 +814,27 @@ module Opal
       recv, meth, arglist, iter = sexp
       mid = mid_to_jsid meth.to_s
 
+      # we are trying to access a lvar in irb mode
+      if @irb_vars and @scope.top? and arglist == s(:arglist) and recv == nil
+        return with_temp { |t|
+          lvar = meth.intern
+          lvar = "#{lvar}$" if RESERVED.include? lvar
+          call = s(:call, s(:self), meth.intern, s(:arglist))
+          [fragment("((#{t} = Opal.irb_vars.#{lvar}) == null ? ", sexp), process(call, :expr), fragment(" : #{t})", sexp)]
+        }
+      end
+
       case meth
       when :attr_reader, :attr_writer, :attr_accessor
         return handle_attr_optimize(meth, arglist[1..-1]) if @scope.class_scope?
       when :block_given?
         return js_block_given(sexp, level)
-      when :alias_native
-        return handle_alias_native(sexp) if @scope.class_scope?
-      when :require
-        return handle_require arglist[1]
       end
 
       splat = arglist[1..-1].any? { |a| a.first == :splat }
 
       if Array === arglist.last and arglist.last.first == :block_pass
-        block = process s(:js_tmp, process(arglist.pop, :expr)), :expr
+        block = process(arglist.pop, :expr)
       elsif iter
         block = iter
       end
@@ -767,17 +855,29 @@ module Opal
         arglist.insert 1, call_recv unless splat
         args = process arglist, :expr
 
-        dispatch = "((#{tmprecv} = #{recv_code})#{mid} || $mm('#{ meth.to_s }'))"
+        dispatch = "((#{tmprecv} = #{recv_code})#{mid} || $mm('#{meth.to_s}'))"
+        dispatch = [fragment("((#{tmprecv} = ", sexp), recv_code, fragment(")#{mid} || $mm('#{meth.to_s}'))", sexp)]
 
         if tmpfunc
-          dispatch = "(#{tmpfunc} = #{dispatch}, #{tmpfunc}._p = #{block}, #{tmpfunc})"
+          dispatch.unshift fragment("(#{tmpfunc} = ", sexp)
+          dispatch << fragment(", #{tmpfunc}._p = ", sexp)
+          dispatch << block
+          dispatch << fragment(", #{tmpfunc})", sexp)
         end
 
-        result = if splat
-          "#{dispatch}.apply(#{process call_recv, :expr}, #{args})"
+        if splat
+          dispatch << fragment(".apply(", sexp)
+          dispatch << process(call_recv, :expr)
+          dispatch << fragment(", ", sexp)
+          dispatch << args
+          dispatch << fragment(")", sexp)
         else
-          "#{dispatch}.call(#{args})"
+          dispatch << fragment(".call(", sexp)
+          dispatch.push(*args)
+          dispatch << fragment(")", sexp)
         end
+
+        result = dispatch
       else
         args = process arglist, :expr
         dispatch = tmprecv ? "(#{tmprecv} = #{recv_code})#{mid}" : "#{recv_code}#{mid}"
@@ -788,86 +888,50 @@ module Opal
       result
     end
 
-    def handle_require(sexp)
-      str = handle_require_sexp sexp
-      @requires << str unless str.nil?
-      ""
-    end
-
-    def handle_require_sexp(sexp)
-      type = sexp.shift
-
-      if type == :str
-        return sexp[0]
-      elsif type == :call
-        recv, meth, args = sexp
-        parts = args[1..-1].map { |s| handle_require_sexp s }
-
-        if recv == [:const, :File]
-          if meth == :expand_path
-            return handle_expand_path(*parts)
-          elsif meth == :join
-            return handle_expand_path parts.join("/")
-          elsif meth == :dirname
-            return handle_expand_path parts[0].split("/")[0...-1].join("/")
-          end
-        end
-      end
-
-
-      case @dynamic_require_severity
-      when :error
-        error "Cannot handle dynamic require"
-      when :warning
-        warning "Cannot handle dynamic require"
-      end
-    end
-
-    def handle_expand_path(path, base = '')
-      "#{base}/#{path}".split("/").inject([]) do |path, part|
-        if part == ''
-          # we had '//', so ignore
-        elsif part == '..'
-          path.pop
-        else
-          path << part
-        end
-
-        path
-      end.join "/"
-    end
-
     # s(:arglist, [arg [, arg ..]])
     def process_arglist(sexp, level)
-      code = ''
+      code = []
       work = []
 
       until sexp.empty?
-        splat = sexp.first.first == :splat
-        arg   = process sexp.shift, :expr
+        current = sexp.shift
+        splat = current.first == :splat
+        arg   = process current, :expr
 
         if splat
           if work.empty?
             if code.empty?
-              code += "[].concat(#{arg})"
+              code << fragment("[].concat(", sexp)
+              code << arg
+              code << fragment(")", sexp)
             else
               code += ".concat(#{arg})"
             end
           else
-            join  = "[#{work.join ', '}]"
-            code += (code.empty? ? join : ".concat(#{join})")
-            code += ".concat(#{arg})"
+            if code.empty?
+              code << [fragment("[", sexp), work, fragment("]", sexp)]
+            else
+              code << [fragment(".concat([", sexp), work, fragment("])", sexp)]
+            end
+
+            code << [fragment(".concat(", sexp), arg, fragment(")", sexp)]
           end
 
           work = []
         else
-          work.push arg
+          work << fragment(", ", current) unless work.empty?
+          work.push(*arg)
         end
       end
 
       unless work.empty?
-        join  = work.join ', '
-        code += (code.empty? ? join : ".concat([#{join}])")
+        join = work
+
+        if code.empty?
+          code = join
+        else
+          code << fragment(".concat(", sexp) << join << fragment(")", sexp)
+        end
       end
 
       code
@@ -875,9 +939,13 @@ module Opal
 
     # s(:splat, sexp)
     def process_splat(sexp, level)
-      return "[]" if sexp.first == [:nil]
-      return "[#{process sexp.first, :expr}]" if sexp.first.first == :lit
-      process sexp.first, :recv
+      if sexp.first == [:nil]
+        [fragment("[]", sexp)]
+      elsif sexp.first.first == :lit
+        [fragment("[", sexp), process(sexp.first, :expr), fragment("]", sexp)]
+      else
+        process sexp.first, :recv
+      end
     end
 
     # s(:class, cid, super, body)
@@ -886,23 +954,23 @@ module Opal
 
       body[1] = s(:nil) unless body[1]
 
-      code = nil
+      code = []
       @helpers[:klass] = true
 
       if Symbol === cid or String === cid
-        base = current_self
+        base = process(s(:self), :expr)
         name = cid.to_s
       elsif cid[0] == :colon2
         base = process(cid[1], :expr)
         name = cid[2].to_s
       elsif cid[0] == :colon3
-        base = 'Opal.Object'
+        base = process(s(:js_tmp, 'Opal.Object'), :expr)
         name = cid[1].to_s
       else
         raise "Bad receiver in class"
       end
 
-      sup = sup ? process(sup, :expr) : 'null'
+      sup = sup ? process(sup, :expr) : process(s(:js_tmp, 'null'), :expr)
 
       indent do
         in_scope(:class) do
@@ -925,8 +993,13 @@ module Opal
 
           body = returns(body)
           body = process body, :stmt
-          code = "\n#{@scope.to_donate_methods}"
-          code += @indent + @scope.to_vars + "\n\n#@indent" + body
+          code << fragment("\n", sexp)
+          code << @scope.to_donate_methods
+
+          code << fragment(@indent, sexp)
+          code << @scope.to_vars
+          code << fragment("\n\n#@indent", sexp)
+          code << body
         end
       end
 
@@ -934,43 +1007,46 @@ module Opal
       cls     = "function #{name}() {};"
       boot    = "#{name} = __klass(__base, __super, #{name.inspect}, #{name});"
 
-      "(function(__base, __super){#{spacer}#{cls}#{spacer}#{boot}\n#{code}\n#{@indent}})(#{base}, #{sup})"
+      [fragment("(function(__base, __super){#{spacer}#{cls}#{spacer}#{boot}\n", sexp),
+       code, fragment("\n#@indent})", sexp), fragment("(", sexp), base, fragment(", ", sexp), sup, fragment(")", sexp)]
     end
 
     # s(:sclass, recv, body)
     def process_sclass(sexp, level)
       recv = sexp[0]
       body = sexp[1]
-      code = nil
+      code = []
 
       in_scope(:sclass) do
         @scope.add_temp "__scope = #{current_self}._scope"
         @scope.add_temp "def = #{current_self}.prototype"
 
         body = process body, :stmt
-        code = @scope.to_vars + body
+        code << @scope.to_vars << body
       end
 
-      call = s(:call, recv, :singleton_class, s(:arglist))
-
-      "(function(){#{ code }}).call(#{ process call, :expr })"
+      result = []
+      result << fragment("(function(){", sexp) << code
+      result << fragment("}).call(__opal.singleton(", sexp)
+      result << process(recv, :expr) << fragment("))", sexp)
+      result
     end
 
     # s(:module, cid, body)
     def process_module(sexp, level)
       cid = sexp[0]
       body = sexp[1]
-      code = nil
+      code = []
       @helpers[:module] = true
 
       if Symbol === cid or String === cid
-        base = current_self
+        base = process(s(:self), :expr)
         name = cid.to_s
       elsif cid[0] == :colon2
         base = process(cid[1], :expr)
         name = cid[2].to_s
       elsif cid[0] == :colon3
-        base = 'Opal.Object'
+        base = fragment('Opal.Object', sexp)
         name = cid[1].to_s
       else
         raise "Bad receiver in class"
@@ -981,7 +1057,13 @@ module Opal
           @scope.name = name
           @scope.add_temp "#{ @scope.proto } = #{name}.prototype", "__scope = #{name}._scope"
           body = process body, :stmt
-          code = @indent + @scope.to_vars + "\n\n#@indent" + body + "\n#@indent" + @scope.to_donate_methods
+
+          code << fragment(@indent, sexp)
+          code.push(*@scope.to_vars)
+          code << fragment("\n\n#@indent", sexp)
+          code.push(*body)
+          code << fragment("\n#@ident", sexp)
+          code.push(*@scope.to_donate_methods)
         end
       end
 
@@ -989,31 +1071,35 @@ module Opal
       cls     = "function #{name}() {};"
       boot    = "#{name} = __module(__base, #{name.inspect}, #{name});"
 
-      "(function(__base){#{spacer}#{cls}#{spacer}#{boot}\n#{code}\n#{@indent}})(#{base})"
-    end
+      code.unshift fragment("(function(__base){#{spacer}#{cls}#{spacer}#{boot}\n", sexp)
+      code << fragment("\n#@indent})(", sexp)
+      code.push(*base)
+      code << fragment(")", sexp)
 
+      code
+    end
 
     # undef :foo
     # => delete MyClass.prototype.$foo
     def process_undef(sexp, level)
-      "delete #{ @scope.proto }#{ mid_to_jsid sexp[0][1].to_s }"
+      fragment("delete #{ @scope.proto }#{ mid_to_jsid sexp[0][1].to_s }", sexp)
     end
 
     # s(:defn, mid, s(:args), s(:scope))
     def process_defn(sexp, level)
       mid, args, stmts = sexp
 
-      js_def nil, mid, args, stmts, sexp.line, sexp.end_line
+      js_def nil, mid, args, stmts, sexp.line, sexp.end_line, sexp
     end
 
     # s(:defs, recv, mid, s(:args), s(:scope))
     def process_defs(sexp, level)
       recv, mid, args, stmts = sexp
 
-      js_def recv, mid, args, stmts, sexp.line, sexp.end_line
+      js_def recv, mid, args, stmts, sexp.line, sexp.end_line, sexp
     end
 
-    def js_def(recvr, mid, args, stmts, line, end_line)
+    def js_def(recvr, mid, args, stmts, line, end_line, sexp)
       jsid = mid_to_jsid mid.to_s
 
       if recvr
@@ -1025,7 +1111,7 @@ module Opal
         recv = current_self
       end
 
-      code = ''
+      code = []
       params = nil
       scope_name = nil
       uses_super = nil
@@ -1071,58 +1157,62 @@ module Opal
           @scope.block_name = yielder
 
           params = process args, :expr
-          stmt_code = "\n#@indent" + process(stmts, :stmt)
+          stmt_code = [fragment("\n#@indent", stmts), *process(stmts, :stmt)]
 
           opt[1..-1].each do |o|
             next if o[2][2] == :undefined
-            id = process s(:lvar, o[1]), :expr
-            code += ("if (%s == null) {\n%s%s\n%s}" %
-                        [id, @indent + INDENT, process(o, :expre), @indent])
+            code << fragment("if (#{o[1]} == null) {\n#{@indent + INDENT}", o)
+            code << process(o, :expr)
+            code << fragment("\n#{@indent}}", o)
           end if opt
 
-          code += "#{splat} = __slice.call(arguments, #{argc});" if splat
+          code << fragment("#{splat} = __slice.call(arguments, #{argc});", sexp) if splat
 
           scope_name = @scope.identity
 
           if @scope.uses_block?
             @scope.add_temp yielder
-            blk = "\n%s%s = %s._p || nil, %s._p = null;\n%s" % [@indent, yielder, scope_name, scope_name, @indent]
+            blk = fragment(("\n%s%s = %s._p || nil, %s._p = null;\n%s" %
+                            [@indent, yielder, scope_name, scope_name, @indent]), sexp)
           end
 
-          code += stmt_code
-          code = "#{blk}#{code}"
+          code.push(*stmt_code)
+          code.unshift blk if blk
 
           uses_super = @scope.uses_super
 
-          code = "#{arity_code}#@indent#{@scope.to_vars}" + code
+          code = [fragment("#{arity_code}#@indent", sexp), @scope.to_vars, code]
         end
       end
 
-      defcode = "#{"#{scope_name} = " if scope_name}function(#{params}) {\n#{code}\n#@indent}"
+      result = [fragment("#{"#{scope_name} = " if scope_name}function(", sexp)]
+      result.push(*params)
+      result << fragment(") {\n", sexp)
+      result.push(*code)
+      result << fragment("\n#@indent}", sexp)
 
       if recvr
         if smethod
-          "__opal.defs(#{@scope.name}, '$#{mid}', #{defcode})"
+          [fragment("__opal.defs(#{@scope.name}, '$#{mid}', ", sexp), result, fragment(")", sexp)]
         else
-          "#{ recv }#{ jsid } = #{ defcode }"
+          [recv, fragment("#{jsid} = ", sexp), result]
         end
       elsif @scope.class? and @scope.name == 'Object'
-        "#{current_self}._defn('$#{mid}', #{defcode})"
+        [fragment("#{current_self}._defn('$#{mid}', ", sexp), result, fragment(")", sexp)]
       elsif @scope.class_scope?
         @scope.methods << "$#{mid}"
         if uses_super
           @scope.add_temp uses_super
           uses_super = "#{uses_super} = #{@scope.proto}#{jsid};\n#@indent"
         end
-        "#{uses_super}#{ @scope.proto }#{jsid} = #{defcode}"
-      # elsif @scope.sclass?
-        # "#{ current_self }._defs('$#{mid}', #{defcode})"
+
+        [fragment("#{uses_super}#{@scope.proto}#{jsid} = ", sexp), result]
       elsif @scope.type == :iter
-        "def#{jsid} = #{defcode}"
+        [fragment("def#{jsid} = ", sexp), result]
       elsif @scope.type == :top
-        "#{ current_self }#{ jsid } = #{ defcode }"
+        [fragment("#{ current_self }#{ jsid } = ", sexp), *result]
       else
-        "def#{jsid} = #{defcode}"
+        [fragment("def#{jsid} = ", sexp), result]
       end
     end
 
@@ -1157,12 +1247,12 @@ module Opal
         args << a
       end
 
-      args.join ', '
+      [fragment(args.join(', '), exp)]
     end
 
     # s(:self)  # => this
     def process_self(sexp, level)
-      current_self
+      fragment(current_self, sexp)
     end
 
     # Returns the current value for 'self'. This will be native
@@ -1178,43 +1268,61 @@ module Opal
       end
     end
 
-    # s(:true)  # => true
-    # s(:false) # => false
-    # s(:nil)   # => nil
-    %w(true false nil).each do |name|
-      define_method "process_#{name}" do |exp, level|
-        name
-      end
+    def process_true(sexp, level)
+      fragment("true", sexp)
+    end
+
+    def process_false(sexp, level)
+      fragment("false", sexp)
+    end
+
+    def process_nil(sexp, level)
+      fragment("nil", sexp)
     end
 
     # s(:array [, sexp [, sexp]])
     def process_array(sexp, level)
-      return '[]' if sexp.empty?
+      return [fragment("[]", sexp)] if sexp.empty?
 
-      code = ''
+      code = []
       work = []
 
       until sexp.empty?
-        splat = sexp.first.first == :splat
-        part  = process sexp.shift, :expr
+        current = sexp.shift
+        splat = current.first == :splat
+        part  = process current, :expr
 
         if splat
           if work.empty?
-            code += (code.empty? ? part : ".concat(#{part})")
+            if code.empty?
+              code << fragment("[].concat(", sexp) << part << fragment(")", sexp)
+            else
+              code << fragment(".concat(", sexp) << part << fragment(")", sexp)
+            end
           else
-            join  = "[#{work.join ', '}]"
-            code += (code.empty? ? join : ".concat(#{join})")
-            code += ".concat(#{part})"
+            if code.empty?
+              code << fragment("[", sexp) << work << fragment("]", sexp)
+            else
+              code << fragment(".concat([", sexp) << work << fragment("])", sexp)
+            end
+
+            code << fragment(".concat(", sexp) << part << fragment(")", sexp)
           end
           work = []
         else
+          work << fragment(", ", current) unless work.empty?
           work << part
         end
       end
 
       unless work.empty?
-        join  = "[#{work.join ', '}]"
-        code += (code.empty? ? join : ".concat(#{join})")
+        join = [fragment("[", sexp), work, fragment("]", sexp)]
+
+        if code.empty?
+          code = join
+        else
+          code.push([fragment(".concat(", sexp), join, fragment(")", sexp)])
+        end
       end
 
       code
@@ -1237,18 +1345,31 @@ module Opal
         hash_obj  = {}
         hash_keys = []
         keys.size.times do |i|
-          k = process(keys[i], :expr)
+          k = keys[i][1].to_s.inspect
           hash_keys << k unless hash_obj.include? k
           hash_obj[k] = process(vals[i], :expr)
         end
 
-        map = hash_keys.map { |k| "#{k}: #{hash_obj[k]}"}
-
+        result = []
         @helpers[:hash2] = true
-        "__hash2([#{hash_keys.join ', '}], {#{map.join(', ')}})"
+
+        hash_keys.each do |k|
+          result << fragment(", ", sexp) unless result.empty?
+          result << fragment("#{k}: ", sexp)
+          result << hash_obj[k]
+        end
+
+        [fragment("__hash2([#{hash_keys.join ', '}], {", sexp), result, fragment("})", sexp)]
       else
         @helpers[:hash] = true
-        "__hash(#{sexp.map { |p| process p, :expr }.join ', '})"
+        result = []
+
+        sexp.each do |p|
+          result << fragment(", ", p) unless result.empty?
+          result << process(p, :expr)
+        end
+
+        [fragment("__hash(", sexp), result, fragment(")", sexp)]
       end
     end
 
@@ -1256,14 +1377,16 @@ module Opal
     def process_while(sexp, level)
       expr, stmt = sexp
       redo_var = @scope.new_temp
+      code = []
 
       stmt_level = if level == :expr or level == :recv
                      :stmt_closure
                     else
                       :stmt
                     end
+
+      code << js_truthy(expr) << fragment("){", sexp)
       pre = "while ("
-      code = "#{js_truthy expr}){"
 
       in_while do
         @while_loop[:closure] = true if stmt_level == :stmt_closure
@@ -1272,18 +1395,19 @@ module Opal
 
         if @while_loop[:use_redo]
           pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
-          code += "#{redo_var}=false;"
+          code << fragment("#{redo_var}=false;", sexp)
         end
 
-        code += body
+        code << body
       end
 
-      code += "}"
-      code = pre + code
+      code << fragment("}", sexp)
+      code.unshift fragment(pre, sexp)
       @scope.queue_temp redo_var
 
       if stmt_level == :stmt_closure
-        code = "(function() {#{code}; return nil;}).call(#{current_self})"
+        code.unshift fragment("(function() {", sexp)
+        code.push fragment("; return nil; }).call(#{current_self})", sexp)
       end
 
       code
@@ -1298,8 +1422,10 @@ module Opal
                    else
                      :stmt
                    end
+
+      code = []
       pre = "while (!("
-      code = "#{js_truthy expr})) {"
+      code << js_truthy(expr) << fragment(")) {", exp)
 
       in_while do
         @while_loop[:closure] = true if stmt_level == :stmt_closure
@@ -1308,18 +1434,19 @@ module Opal
 
         if @while_loop[:use_redo]
           pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
-          code += "#{redo_var}=false;"
+          code << fragment("#{redo_var}=false;", exp)
         end
 
-        code += body
+        code << body
       end
 
-      code += "}"
-      code = pre + code
+      code << fragment("}", exp)
+      code.unshift fragment(pre, exp)
       @scope.queue_temp redo_var
 
       if stmt_level == :stmt_closure
-        code = "(function() {#{code}; return nil;}).call(#{current_self})"
+        code.unshift fragment("(function() {", exp)
+        code << fragment("; return nil; }).call(#{current_self})", exp)
       end
 
       code
@@ -1334,10 +1461,10 @@ module Opal
 
       if [:class, :module].include? @scope.type
         @scope.methods << "$#{exp[0][1].to_s}"
-        "%s%s = %s%s" % [@scope.proto, new, @scope.proto, old]
+        fragment("%s%s = %s%s" % [@scope.proto, new, @scope.proto, old], exp)
       else
         current = current_self
-        "%s.prototype%s = %s.prototype%s" % [current, new, current, old]
+        fragment("%s.prototype%s = %s.prototype%s" % [current, new, current, old], exp)
       end
     end
 
@@ -1346,21 +1473,25 @@ module Opal
       rhs = sexp[1]
       tmp = @scope.new_temp
       len = 0
+      code = []
 
       # remote :array part
       lhs.shift
       if rhs[0] == :array
         len = rhs.length - 1 # we are guaranteed an array of this length
-        code  = ["#{tmp} = #{process rhs, :expr}"]
+        code << fragment("#{tmp} = ", sexp) << process(rhs, :expr)
       elsif rhs[0] == :to_ary
-        code = ["((#{tmp} = #{process rhs[1], :expr})._isArray ? #{tmp} : (#{tmp} = [#{tmp}]))"]
+        code << fragment("((#{tmp} = ", sexp) << process(rhs[1], :expr)
+        code << fragment(")._isArray ? #{tmp} : (#{tmp} = [#{tmp}]))", sexp)
       elsif rhs[0] == :splat
-        code = ["(#{tmp} = #{process(rhs[1], :expr)})['$to_a'] ? (#{tmp} = #{tmp}['$to_a']()) : (#{tmp})._isArray ? #{tmp} : (#{tmp} = [#{tmp}])"]
+        code << fragment("(#{tmp} = ", sexp) << process(rhs[1], :expr)
+        code << fragment(")['$to_a'] ? (#{tmp} = #{tmp}['$to_a']()) : (#{tmp})._isArray ?  #{tmp} : (#{tmp} = [#{tmp}])", sexp)
       else
         raise "Unsupported mlhs type"
       end
 
       lhs.each_with_index do |l, idx|
+        code << fragment(", ", sexp) unless code.empty?
 
         if l.first == :splat
           s = l[1]
@@ -1377,7 +1508,7 @@ module Opal
       end
 
       @scope.queue_temp tmp
-      code.join ', '
+      code
     end
 
     def process_svalue(sexp, level)
@@ -1389,16 +1520,33 @@ module Opal
       lvar = sexp[0]
       rhs  = sexp[1]
       lvar = "#{lvar}$".to_sym if RESERVED.include? lvar.to_s
-      @scope.add_local lvar
-      res = "#{lvar} = #{process rhs, :expr}"
-      level == :recv ? "(#{res})" : res
+
+      if @irb_vars and @scope.top?
+        [fragment("Opal.irb_vars.#{lvar} = ", sexp), process(rhs, :expr)]
+      else
+        @scope.add_local lvar
+        rhs = process(rhs, :expr)
+        result =  [fragment(lvar, sexp), fragment(" = ", sexp), rhs]
+
+        if level == :recv
+          result.unshift fragment("(", sexp)
+          result.push fragment(")", sexp)
+        end
+
+        result
+      end
     end
 
     # s(:lvar, :lvar)
-    def process_lvar(exp, level)
-      lvar = exp.shift.to_s
+    def process_lvar(sexp, level)
+      lvar = sexp.shift.to_s
       lvar = "#{lvar}$" if RESERVED.include? lvar
-      lvar
+
+      if @irb_vars and @scope.top?
+        with_temp { |t| fragment("((#{t} = Opal.irb_vars.#{lvar}) == null ? nil : #{t})", sexp) }
+      else
+        fragment(lvar, sexp)
+      end
     end
 
     # s(:iasgn, :ivar, rhs)
@@ -1407,7 +1555,7 @@ module Opal
       rhs = exp[1]
       ivar = ivar.to_s[1..-1]
       lhs = RESERVED.include?(ivar) ? "#{current_self}['#{ivar}']" : "#{current_self}.#{ivar}"
-      "#{lhs} = #{process rhs, :expr}"
+      [fragment(lhs, exp), fragment(" = ", exp), process(rhs, :expr)]
     end
 
     # s(:ivar, :ivar)
@@ -1415,18 +1563,18 @@ module Opal
       ivar = exp.shift.to_s[1..-1]
       part = RESERVED.include?(ivar) ? "['#{ivar}']" : ".#{ivar}"
       @scope.add_ivar part
-      "#{current_self}#{part}"
+      fragment("#{current_self}#{part}", exp)
     end
 
     # s(:gvar, gvar)
     def process_gvar(sexp, level)
       gvar = sexp.shift.to_s[1..-1]
       @helpers['gvars'] = true
-      "__gvars[#{gvar.inspect}]"
+      fragment("__gvars[#{gvar.inspect}]", sexp)
     end
- 
+
     def process_nth_ref(sexp, level)
-      "nil"
+      fragment("nil", sexp)
     end
 
     # s(:gasgn, :gvar, rhs)
@@ -1434,7 +1582,7 @@ module Opal
       gvar = sexp[0].to_s[1..-1]
       rhs  = sexp[1]
       @helpers['gvars'] = true
-      "__gvars[#{gvar.to_s.inspect}] = #{process rhs, :expr}"
+      [fragment("__gvars[#{gvar.to_s.inspect}] = ", sexp), process(rhs, :expr)]
     end
 
     # s(:const, :const)
@@ -1443,17 +1591,17 @@ module Opal
 
       if @const_missing
         with_temp do |t|
-          "((#{t} = __scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})"
+          fragment("((#{t} = __scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})", sexp)
         end
       else
-        "__scope.#{cname}"
+        fragment("__scope.#{cname}", sexp)
       end
     end
 
     # s(:cdecl, :const, rhs)
     def process_cdecl(sexp, level)
       const, rhs = sexp
-      "__scope.#{const} = #{process rhs, :expr}"
+      [fragment("__scope.#{const} = ", sexp), process(rhs, :expr)]
     end
 
     # s(:return [val])
@@ -1461,67 +1609,91 @@ module Opal
       val = process(sexp.shift || s(:nil), :expr)
 
       raise SyntaxError, "void value expression: cannot return as an expression" unless level == :stmt
-      "return #{val}"
+      [fragment("return ", sexp), val]
     end
 
     # s(:xstr, content)
     def process_xstr(sexp, level)
       code = sexp.first.to_s
       code += ";" if level == :stmt and !code.include?(';')
-      level == :recv ? "(#{code})" : code
+
+      result = fragment(code, sexp)
+
+      level == :recv ? [fragment("(", sexp), result, fragment(")", sexp)] : result
     end
 
     # s(:dxstr, parts...)
     def process_dxstr(sexp, level)
-      code = sexp.map do |p|
+      result = []
+      needs_sc = false
+
+      sexp.each do |p|
         if String === p
-          p.to_s
+          result << fragment(p.to_s, sexp)
+          needs_sc = true if level == :stmt and !p.to_s.include?(';')
         elsif p.first == :evstr
-          process p.last, :stmt
+          result.push(*process(p.last, :stmt))
         elsif p.first == :str
-          p.last.to_s
+          result << fragment(p.last.to_s, p)
+          needs_sc = true if level == :stmt and !p.last.to_s.include?(';')
         else
           raise "Bad dxstr part"
         end
-      end.join
+      end
 
-      code += ";" if level == :stmt and !code.include?(';')
-      code = "(#{code})" if level == :recv
-      code
+      result << fragment(";", sexp) if needs_sc
+
+      if level == :recv
+        [fragment("(", sexp), result, fragment(")", sexp)]
+      else
+        result
+      end
     end
 
     # s(:dstr, parts..)
     def process_dstr(sexp, level)
-      parts = sexp.map do |p|
+      result = []
+
+      sexp.each do |p|
+        result << fragment(" + ", sexp) unless result.empty?
         if String === p
-          p.inspect
+          result << fragment(p.inspect, sexp)
         elsif p.first == :evstr
-          "(" + process(p.last, :expr) + ")"
+          result << fragment("(", p)
+          result << process(p.last, :expr)
+          result << fragment(")", p)
         elsif p.first == :str
-          p.last.inspect
+          result << fragment(p.last.inspect, p)
         else
           raise "Bad dstr part"
         end
       end
 
-      res = parts.join ' + '
-      level == :recv ? "(#{res})" : res
+      if level == :recv
+        [fragment("(", sexp), result, fragment(")", sexp)]
+      else
+        result
+      end
     end
 
     def process_dsym(sexp, level)
-      parts = sexp.map do |p|
+      result = []
+
+      sexp.each do |p|
+        result << fragment(" + ", sexp) unless result.empty?
+
         if String === p
-          p.inspect
+          result << fragment(p.inspect, sexp)
         elsif p.first == :evstr
-          process(s(:call, p.last, :to_s, s(:arglist)), :expr)
+          result << process(s(:call, p.last, :to_s, s(:arglist)), :expr)
         elsif p.first == :str
-          p.last.inspect
+          result << fragment(p.last.inspect, sexp)
         else
           raise "Bad dsym part"
         end
       end
 
-      "(#{parts.join '+'})"
+      [fragment("(", sexp), result, fragment(")", sexp)]
     end
 
     # s(:if, test, truthy, falsy)
@@ -1543,14 +1715,21 @@ module Opal
         check = js_truthy test
       end
 
-      code = "if (#{check}) {\n"
-      indent { code += @indent + process(truthy, :stmt) } if truthy
-      indent { code += "\n#@indent} else {\n#@indent#{process falsy, :stmt}" } if falsy
-      code += "\n#@indent}"
+      result = [fragment("if (", sexp), check, fragment(") {\n", sexp)]
 
-      code = "(function() { #{code}; return nil; }).call(#{current_self})" if returnable
+      indent { result.push(fragment(@indent, sexp), process(truthy, :stmt)) } if truthy
 
-      code
+      outdent = @indent
+      indent { result.push(fragment("\n#{outdent}} else {\n#@indent", sexp), process(falsy, :stmt)) } if falsy
+
+      result << fragment("\n#@indent}", sexp)
+
+      if returnable
+        result.unshift fragment("(function() { ", sexp)
+        result.push fragment("; return nil; }).call(#{current_self})", sexp)
+      end
+
+      result
     end
 
     def js_truthy_optimize(sexp)
@@ -1564,8 +1743,7 @@ module Opal
           return process sexp, :expr
         end
       elsif [:lvar, :self].include? sexp.first
-        name = process sexp, :expr
-        "#{name} !== false && #{name} !== nil"
+        [process(sexp.dup, :expr), fragment(" !== false && ", sexp), process(sexp.dup, :expr), fragment(" !== nil", sexp)]
       end
     end
 
@@ -1575,7 +1753,7 @@ module Opal
       end
 
       with_temp do |tmp|
-        "(%s = %s) !== false && %s !== nil" % [tmp, process(sexp, :expr), tmp]
+        [fragment("(#{tmp} = ", sexp), process(sexp, :expr), fragment(") !== false && #{tmp} !== nil", sexp)]
       end
     end
 
@@ -1588,7 +1766,11 @@ module Opal
       end
 
       with_temp do |tmp|
-        "(%s = %s) === false || %s === nil" % [tmp, process(sexp, :expr), tmp]
+        result = []
+        result << fragment("(#{tmp} = ", sexp)
+        result << process(sexp, :expr)
+        result << fragment(") === false || #{tmp} === nil", sexp)
+        result
       end
     end
 
@@ -1599,26 +1781,30 @@ module Opal
       tmp = @scope.new_temp
 
       if t = js_truthy_optimize(lhs)
-        return "((#{tmp} = #{t}) ? #{process rhs, :expr} : #{tmp})".tap {
-          @scope.queue_temp tmp
-        }
+        result = []
+        result << fragment("((#{tmp} = ", sexp) << t
+        result << fragment(") ? ", sexp) << process(rhs, :expr)
+        result << fragment(" : #{tmp})", sexp)
+        @scope.queue_temp tmp
+
+        return result
       end
 
       @scope.queue_temp tmp
 
-      "(%s = %s, %s !== false && %s !== nil ? %s : %s)" %
-        [tmp, process(lhs, :expr), tmp, tmp, process(rhs, :expr), tmp]
+      [fragment("(#{tmp} = ", sexp), process(lhs, :expr), fragment(", #{tmp} !== false && #{tmp} !== nil ? ", sexp), process(rhs, :expr), fragment(" : #{tmp})", sexp)]
+
     end
 
     # s(:or, lhs, rhs)
     def process_or(sexp, level)
       lhs = sexp[0]
       rhs = sexp[1]
-      t = nil
 
       with_temp do |tmp|
-        "((%s = %s), %s !== false && %s !== nil ? %s : %s)" %
-          [tmp, process(lhs, :expr), tmp, tmp, tmp, process(rhs, :expr)]
+        lhs = process lhs, :expr
+        rhs = process rhs, :expr
+      [fragment("(#{tmp} = ", sexp), lhs, fragment(", #{tmp} !== false && #{tmp} !== nil ? #{tmp} : ", sexp), rhs, fragment(")", sexp)]
       end
     end
 
@@ -1627,10 +1813,10 @@ module Opal
       call = handle_yield_call sexp, level
 
       if level == :stmt
-        "if (#{call} === __breaker) return __breaker.$v"
+        [fragment("if (", sexp), call, fragment(" === __breaker) return __breaker.$v")]
       else
         with_temp do |tmp|
-          "(((#{tmp} = #{call}) === __breaker) ? __breaker.$v : #{tmp})"
+          [fragment("(((#{tmp} = ", sexp), call, fragment(") === __breaker) ? __breaker.$v : #{tmp})", sexp)]
         end
       end
     end
@@ -1643,7 +1829,8 @@ module Opal
     # s(:yasgn, :a, s(:yield, arg1, arg2))
     def process_yasgn(sexp, level)
       call = handle_yield_call s(*sexp[1][1..-1]), :stmt
-      "if ((%s = %s) === __breaker) return __breaker.$v" % [sexp[0], call]
+
+      [fragment("if ((#{sexp[0]} = ", sexp), call, fragment(") === __breaker) return __breaker.$v", sexp)]
     end
 
     # Created by `#returns()` for when a yield statement should return
@@ -1652,8 +1839,8 @@ module Opal
       call = handle_yield_call sexp, level
 
       with_temp do |tmp|
-        "return %s = %s, %s === __breaker ? %s : %s" %
-          [tmp, call, tmp, tmp, tmp]
+        [fragment("return #{tmp} = ", sexp), call,
+                    fragment(", #{tmp} === __breaker ? #{tmp} : #{tmp}")]
       end
     end
 
@@ -1666,16 +1853,20 @@ module Opal
 
       y = @scope.block_name || '__yield'
 
-      splat ? "#{y}.apply(null, #{args})" : "#{y}.call(#{args})"
+      if splat
+        [fragment("#{y}.apply(null, ", sexp), args, fragment(")", sexp)]
+      else
+        [fragment("#{y}.call(", sexp), args, fragment(")", sexp)]
+      end
     end
 
-    def process_break(exp, level)
-      val = exp.empty? ? 'nil' : process(exp.shift, :expr)
+    def process_break(sexp, level)
+      val = sexp.empty? ? fragment('nil', sexp) : process(sexp.shift, :expr)
       if in_while?
-        @while_loop[:closure] ? "return #{ val };" : "break;"
+        @while_loop[:closure] ? [fragment("return ", sexp), val, fragment("", sexp)] : fragment("break;", sexp)
       elsif @scope.iter?
         error "break must be used as a statement" unless level == :stmt
-        "return (__breaker.$v = #{ val }, __breaker)"
+        [fragment("return (__breaker.$v = ", sexp), val, fragment(", __breaker)", sexp)]
       else
         error "void value expression: cannot use break outside of iter/while"
       end
@@ -1683,6 +1874,7 @@ module Opal
 
     # s(:case, expr, when1, when2, ..)
     def process_case(exp, level)
+      pre = []
       code = []
       @scope.add_local "$case"
       expr = process exp.shift, :expr
@@ -1690,24 +1882,31 @@ module Opal
       returnable = level != :stmt
       done_else = false
 
+      pre << fragment("$case = ", exp) << expr << fragment(";", exp)
+
       until exp.empty?
         wen = exp.shift
         if wen and wen.first == :when
           returns(wen) if returnable
           wen = process(wen, :stmt)
-          wen = "else #{wen}" unless code.empty?
+          code << fragment("else ", exp) unless code.empty?
           code << wen
         elsif wen # s(:else)
           done_else = true
           wen = returns(wen) if returnable
-          code << "else {#{process wen, :stmt}}"
+          code << fragment("else {", exp) << process(wen, :stmt) << fragment("}", exp)
         end
       end
 
-      code << "else {return nil}" if returnable and !done_else
+      code << fragment("else { return nil }", exp) if returnable and !done_else
+
+      code.unshift pre
+
+      if returnable
+        code.unshift fragment("(function() { ", exp)
+        code << fragment(" }).call(#{current_self})", exp)
+      end
 
-      code = "$case = #{expr};#{code.join @space}"
-      code = "(function() { #{code} }).call(#{current_self})" if returnable
       code
     end
 
@@ -1717,30 +1916,32 @@ module Opal
     # s(:when, s(:array, foo), bar)
     def process_when(exp, level)
       arg = exp.shift[1..-1]
-      body = exp.shift
-      body = process body, level if body
+      body = exp.shift || s(:nil)
+      #body = process body, level if body
+      body = process body, level
 
       test = []
       until arg.empty?
+        test << fragment(" || ", exp) unless test.empty?
         a = arg.shift
 
         if a.first == :splat # when inside another when means a splat of values
-          call  = s(:call, s(:js_tmp, "$splt[i]"), :===, s(:arglist, s(:js_tmp, "$case")))
-          splt  = "(function($splt) {for(var i = 0; i < $splt.length; i++) {"
-          splt += "if (#{process call, :expr}) { return true; }"
-          splt += "} return false; }).call(#{current_self}, #{process a[1], :expr})"
+          call = s(:call, s(:js_tmp, "$splt[i]"), :===, s(:arglist, s(:js_tmp, "$case")))
+          splt = [fragment("(function($splt) { for(var i = 0; i < $splt.length; i++) {", exp)]
+          splt << fragment("if (", exp) << process(call, :expr) << fragment(") { return true; }", exp)
+          splt << fragment("} return false; }).call(#{current_self}, ", exp)
+          splt << process(a[1], :expr) << fragment(")", exp)
 
           test << splt
         else
           call = s(:call, a, :===, s(:arglist, s(:js_tmp, "$case")))
           call = process call, :expr
-          # call = "else " unless test.empty?
 
           test << call
         end
       end
 
-      "if (%s) {%s%s%s}" % [test.join(' || '), @space, body, @space]
+      [fragment("if (", exp), test, fragment(") {#@space", exp), body, fragment("#@space}", exp)]
     end
 
     # lhs =~ rhs
@@ -1758,8 +1959,8 @@ module Opal
     # s(:cvar, name)
     def process_cvar(exp, level)
       with_temp do |tmp|
-        "((%s = Opal.cvars[%s]) == null ? nil : %s)" %
-          [tmp, exp.shift.to_s.inspect, tmp]
+        fragment(("((%s = Opal.cvars[%s]) == null ? nil : %s)" %
+          [tmp, exp.shift.to_s.inspect, tmp]), exp)
       end
     end
 
@@ -1771,7 +1972,7 @@ module Opal
     end
 
     def process_cvdecl(exp, level)
-      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expr})"
+      [fragment("(Opal.cvars[#{exp.shift.to_s.inspect}] = ", exp), process(exp.shift, :expr), fragment(")", exp)]
     end
 
     # BASE::NAME
@@ -1780,22 +1981,28 @@ module Opal
     def process_colon2(sexp, level)
       base = sexp[0]
       cname = sexp[1].to_s
+      result = []
 
       if @const_missing
         with_temp do |t|
-        base = process base, :expr
-          "((#{t} = (#{base})._scope).#{cname} == null ? #{t}.cm(#{cname.inspect}) : #{t}.#{cname})"
+          base = process base, :expr
+
+          result << fragment("((#{t} = (", sexp) << base << fragment(")._scope).", sexp)
+          result << fragment("#{cname} == null ? #{t}.cm(#{cname.inspect}) : #{t}.#{cname})", sexp)
         end
       else
         base = process base, :expr
-        "(#{base})._scope.#{cname}"
+
+        result <<  fragment("(", sexp) << base << fragment(")._scope.#{cname}", sexp)
       end
+
+      result
     end
 
     def process_colon3(exp, level)
       with_temp do |t|
         cname = exp.shift.to_s
-        "((#{t} = __opal.Object._scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})"
+        fragment("((#{t} = __opal.Object._scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})", exp)
       end
     end
 
@@ -1805,42 +2012,45 @@ module Opal
     def process_super(sexp, level)
       args = []
       until sexp.empty?
+        args << fragment(", ", sexp) unless args.empty?
         args << process(sexp.shift, :expr)
       end
 
-      js_super "[#{ args.join ', ' }]"
+      js_super [fragment("[", sexp), args, fragment("]", sexp)], sexp
     end
 
     # super
     #
     # s(:zsuper)
     def process_zsuper(exp, level)
-      js_super "__slice.call(arguments)"
+      js_super fragment("__slice.call(arguments)", exp), exp
     end
 
-    def js_super args
+    def js_super args, sexp
       if @scope.def_in_class?
         mid = @scope.mid.to_s
         sid = "super_#{unique_temp}"
 
         @scope.uses_super = sid
-        "#{sid}.apply(#{current_self}, #{ args })"
+
+
+        [fragment("#{sid}.apply(#{current_self}, ", sexp), args, fragment(")", sexp)]
 
       elsif @scope.type == :def
-        identity = @scope.identify!
-        cls_name = @scope.parent.name || "#{current_self}._klass.prototype"
+        @scope.identify!
+        cls_name = @scope.parent.name || "#{current_self}.constructor.prototype"
         jsid     = mid_to_jsid @scope.mid.to_s
 
         if @scope.defs
-          "%s._super%s.apply(this, %s)" % [cls_name, jsid, args]
+          [fragment(("%s._super%s.apply(this, " % [cls_name, jsid]), sexp), args, fragment(")", sexp)]
         else
-          "#{current_self}._klass._super.prototype%s.apply(#{current_self}, %s)" % [jsid, args]
+          [fragment("#{current_self}.constructor._super.prototype#{jsid}.apply(#{current_self}, ", sexp), args, fragment(")", sexp)]
         end
 
       elsif @scope.type == :iter
         chain, defn, mid = @scope.get_super_chain
         trys = chain.map { |c| "#{c}._sup" }.join ' || '
-        "(#{trys} || #{current_self}._klass._super.prototype[#{mid}]).apply(#{current_self}, #{args})"
+        [fragment("(#{trys} || #{current_self}.constructor._super.prototype[#{mid}]).apply(#{current_self}, ", sexp), args, fragment(")", sexp)]
       else
         raise "Cannot call super() from outside a method block"
       end
@@ -1875,7 +2085,11 @@ module Opal
           aset = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
           orop = s(:or, aref, aset)
 
-          "(#{a} = #{args}, #{r} = #{recv}, #{process orop, :expr})"
+          result = []
+          result << fragment("(#{a} = ", sexp) << args << fragment(", #{r} = ", sexp)
+          result << recv << fragment(", ", sexp) << process(orop, :expr)
+          result << fragment(")", sexp)
+          result
         end
       end
     end
@@ -1883,11 +2097,11 @@ module Opal
     # lhs.b += rhs
     #
     # s(:op_asgn2, lhs, :b=, :+, rhs)
-    def process_op_asgn2(exp, level)
-      lhs = process exp.shift, :expr
-      mid = exp.shift.to_s[0..-2]
-      op  = exp.shift
-      rhs = exp.shift
+    def process_op_asgn2(sexp, level)
+      lhs = process sexp.shift, :expr
+      mid = sexp.shift.to_s[0..-2]
+      op  = sexp.shift
+      rhs = sexp.shift
 
       if op.to_s == "||"
         with_temp do |temp|
@@ -1895,7 +2109,7 @@ module Opal
           asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, rhs))
           orop = s(:or, getr, asgn)
 
-          "(#{temp} = #{lhs}, #{process orop, :expr})"
+          [fragment("(#{temp} = ", sexp), lhs, fragment(", ", sexp), process(orop, :expr), fragment(")", sexp)]
         end
       elsif op.to_s == '&&'
         with_temp do |temp|
@@ -1903,7 +2117,7 @@ module Opal
           asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, rhs))
           andop = s(:and, getr, asgn)
 
-          "(#{temp} = #{lhs}, #{process andop, :expr})"
+          [fragment("(#{temp} = ", sexp), lhs, fragment(", ", sexp), process(andop, :expr), fragment(")", sexp)]
         end
       else
         with_temp do |temp|
@@ -1911,7 +2125,7 @@ module Opal
           oper = s(:call, getr, op, s(:arglist, rhs))
           asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, oper))
 
-          "(#{temp} = #{lhs}, #{process asgn, :expr})"
+          [fragment("(#{temp} = ", sexp), lhs, fragment(", ", sexp), process(asgn, :expr), fragment(")", sexp)]
         end
       end
     end
@@ -1924,14 +2138,20 @@ module Opal
         begn = returns begn
       end
 
+      result = []
       body = process begn, level
       ensr = exp.shift || s(:nil)
       ensr = process ensr, level
-      body = "try {\n#{body}}" unless body =~ /^try \{/
 
-      res = "#{body}#{@space}finally {#{@space}#{ensr}}"
-      res = "(function() { #{res}; }).call(#{current_self})" if retn
-      res
+      body = [fragment("try {\n", exp), body, fragment("}", exp)]
+
+      result << body << fragment("#{@space}finally {#@space", exp) << ensr << fragment("}", exp)
+
+      if retn
+        [fragment("(function() { ", exp), result, fragment("; }).call(#{current_self})", exp)]
+      else
+        result
+      end
     end
 
     def process_rescue(exp, level)
@@ -1943,14 +2163,27 @@ module Opal
       until exp.empty?
         handled_else = true unless exp.first.first == :resbody
         part = indent { process exp.shift, level }
-        part = "else " + part unless parts.empty?
+
+        unless parts.empty?
+          parts << fragment("else ", exp)
+        end
+
         parts << part
       end
       # if no rescue statement captures our error, we should rethrow
-      parts << indent { "else { throw $err; }" } unless handled_else
+      parts << indent { fragment("else { throw $err; }", exp) } unless handled_else
+
+      code = []
+      code << fragment("try {#@space#{INDENT}", exp)
+      code << body
+      code << fragment("#@space} catch ($err) {#@space", exp)
+      code << parts
+      code << fragment("#@space}", exp)
 
-      code = "try {#@space#{INDENT}#{body}#@space} catch ($err) {#@space#{parts.join @space}#{@space}}"
-      code = "(function() { #{code} }).call(#{current_self})" if level == :expr
+      if level == :expr
+        code.unshift fragment("(function() { ", exp)
+        code << fragment(" }).call(#{current_self})", exp)
+      end
 
       code
     end
@@ -1963,41 +2196,51 @@ module Opal
       types = args[1..-1]
       types.pop if types.last and types.last.first != :const
 
-      err = types.map { |t|
+      err = []
+      types.each do |t|
+        err << fragment(", ", exp) unless err.empty?
         call = s(:call, t, :===, s(:arglist, s(:js_tmp, "$err")))
         a = process call, :expr
-        a
-      }.join ', '
-      err = "true" if err.empty?
+        err << a
+      end
+      err << fragment("true", exp) if err.empty?
 
       if Array === args.last and [:lasgn, :iasgn].include? args.last.first
         val = args.last
         val[2] = s(:js_tmp, "$err")
-        val = process(val, :expr) + ";"
+        val = [process(val, :expr) , fragment(";", exp)]
       end
 
-      "if (#{err}) {#{@space}#{val}#{body}}"
+      val = [] unless val
+
+      [fragment("if (", exp), err, fragment("){#@space", exp), val, body, fragment("}", exp)]
     end
 
     # FIXME: Hack.. grammar should remove top level begin.
     def process_begin(exp, level)
-      process exp[0], level
+      result = process exp[0], level
     end
 
     def process_next(exp, level)
       if in_while?
-        "continue;"
+        fragment("continue;", exp)
       else
-        "return #{ exp.empty? ? 'nil' : process(exp.shift, :expr) };"
+        result = []
+        result << fragment("return ", exp)
+
+        result << (exp.empty? ? fragment('nil', exp) : process(exp.shift, :expr))
+        result << fragment(";", exp)
+
+        result
       end
     end
 
     def process_redo(exp, level)
       if in_while?
         @while_loop[:use_redo] = true
-        "#{@while_loop[:redo_var]} = true"
+        fragment("#{@while_loop[:redo_var]} = true", exp)
       else
-        "REDO()"
+        fragment("REDO()", exp)
       end
     end
   end