opal 0.4.3 → 0.4.4

data/lib/opal/parser.rb

@@ -6,15 +6,21 @@ require 'opal/version'
 module Opal
   class Parser
 
+    # A fragment holds a string of generated javascript that will be written
+    # to the destination. It also keeps hold of the original sexp from which
+    # it was generated. Using this sexp, when writing fragments in order, a
+    # mapping can be created of the original location => target location,
+    # aka, source-maps!
     class Fragment
-
+      # String of javascript this fragment holds
       attr_reader :code
 
       def initialize(code, sexp = nil)
-        @code = code
+        @code = code.to_s
         @sexp = sexp
       end
 
+      # In debug mode we may wish to include the original line as a comment
       def to_code
         if @sexp
           "/*:#{@sexp.line}*/#{@code}"
@@ -23,8 +29,13 @@ module Opal
         end
       end
 
+      # inspect the contents of this fragment, f("fooo")
       def inspect
-        "fragment(#{@code.inspect})"
+        "f(#{@code.inspect})"
+      end
+
+      def line
+        @sexp.line if @sexp
       end
     end
 
@@ -51,8 +62,16 @@ module Opal
     # Statements which should not have ';' added to them.
     STATEMENTS = [:xstr, :dxstr]
 
+    # Final generated javascript for this parser
     attr_reader :result
 
+    # generated fragments as an array
+    attr_reader :fragments
+
+    # Parse some ruby code to a string.
+    #
+    #     Opal::Parser.new.parse("1 + 2")
+    #     # => "(function() {....})()"
     def parse(source, options = {})
       @sexp = Grammar.new.parse(source, options[:file])
       @line     = 1
@@ -68,29 +87,45 @@ module Opal
       @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
+      @method_calls = {}
 
-      code = @source_map ? fragments.map(&:to_code).join('') : fragments.map(&:code).join('')
+      @fragments = self.top(@sexp).flatten
 
-      @result = source_map_comment + version_comment + file_comment + code
+      @fragments.unshift f(version_comment)
+
+      @result = @fragments.map(&:code).join('')
     end
 
+    # Always at top of generated file to show current opal version
     def version_comment
       "/* Generated by Opal #{Opal::VERSION} */\n"
     end
 
-    def source_map_comment
-      @source_map ? "//@ sourceMappingURL=/__opal_source_maps__/#{@file}.js.map\n" : ''
+    def source_map
+      Opal::SourceMap.new(@fragments, '(file)')
     end
 
-    def file_comment
-      @source_map ? "/*-file:#{@source_file}-*/" : ''
+    def extract_parser_options(content)
+      result = {}
+
+      if /^#\ opal\:(.*)/ =~ content
+        $~[1].split(',').map(&:strip).each do |opt|
+          next if opt == ""
+          opt = opt.gsub('-', '_')
+
+          if opt =~ /no_/
+            result[opt.sub(/no_/, '').to_sym] = false
+          else
+            result[opt.to_sym] = true
+          end
+        end
+      end
+
+      result
     end
 
     # This is called when a parsing/processing error occurs. This
@@ -139,10 +174,12 @@ module Opal
 
     # @param [String] code the string of code
     # @return [Fragment]
-    def fragment(code, sexp = nil)
+    def f(code, sexp = nil)
       Fragment.new(code, sexp)
     end
 
+    alias_method :fragment, :f
+
     # 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
@@ -164,6 +201,13 @@ module Opal
       end
     end
 
+    # Converts a ruby lvar/arg name to a js identifier. Not all ruby names
+    # are valid in javascript. A $ suffix is added to non-valid names.
+    def lvar_to_js(var)
+      var = "#{var}$" if RESERVED.include? var.to_s
+      var.to_sym
+    end
+
     # Used to generate a unique id name per file. These are used
     # mainly to name method bodies for methods that use blocks.
     #
@@ -192,24 +236,29 @@ module Opal
 
           code = process(scope, :stmt)
           code = [code] unless code.is_a? Array
-          code.unshift fragment(@indent, sexp)
+          code.unshift f(@indent, sexp)
         }
 
-        @scope.add_temp "self = __opal.top"
-        @scope.add_temp "__scope = __opal"
-        @scope.add_temp "$mm = __opal.mm"
-        @scope.add_temp "nil = __opal.nil"
-        @scope.add_temp "def = __opal.Object._proto" if @scope.defines_defn
-        @helpers.keys.each { |h| @scope.add_temp "__#{h} = __opal.#{h}" }
+        @scope.add_temp "self = $opal.top"
+        @scope.add_temp "$scope = $opal"
+        @scope.add_temp "nil = $opal.nil"
+        @scope.add_temp "def = $opal.Object._proto" if @scope.defines_defn
+        @helpers.keys.each { |h| @scope.add_temp "$#{h} = $opal.#{h}" }
 
-        vars = [fragment(INDENT, sexp), @scope.to_vars, fragment("\n", sexp)]
+        vars = [f(INDENT, sexp), @scope.to_vars, f("\n", sexp)]
 
         if @irb_vars
-          code.unshift fragment("if (!Opal.irb_vars) { Opal.irb_vars = {}; }\n", sexp)
+          code.unshift f("if (!$opal.irb_vars) { $opal.irb_vars = {}; }\n", sexp)
         end
       end
 
-      [fragment("(function(__opal) {\n", sexp), vars, code, fragment("\n})(Opal);\n", sexp)]
+      if @method_missing
+        stubs = f("\n#{INDENT}$opal.add_stubs([" + @method_calls.keys.map { |k| "'$#{k}'" }.join(", ") + "]);\n", sexp)
+      else
+        stubs = []
+      end
+
+      [f("(function($opal) {\n", sexp), vars, stubs, code, f("\n})(Opal);\n", sexp)]
     end
 
     # Every time the parser enters a new scope, this is called with
@@ -296,6 +345,14 @@ module Opal
       result
     end
 
+    def in_case
+      return unless block_given?
+      old = @case_stmt
+      @case_stmt = {}
+      yield
+      @case_stmt = old
+    end
+
     # Returns true if the parser is curently handling a while sexp,
     # false otherwise.
     #
@@ -318,7 +375,7 @@ module Opal
     # @param [Array] sexp the sexp to process
     # @param [Symbol] level the level to process (see `LEVEL`)
     # @return [String]
-    def process(sexp, level)
+    def process(sexp, level = :expr)
       type = sexp.shift
       meth = "process_#{type}"
       raise "Unsupported sexp: #{type}" unless respond_to? meth
@@ -373,6 +430,10 @@ module Opal
         sexp
       when :rescue
         sexp[1] = returns sexp[1]
+
+        if sexp[2] and sexp[2][0] == :resbody and sexp[2][2]
+          sexp[2][2] = returns sexp[2][2]
+        end
         sexp
       when :ensure
         sexp[1] = returns sexp[1]
@@ -422,30 +483,23 @@ module Opal
     #
     # @return [String]
     def process_block(sexp, level)
-      result = []
-      sexp << s(:nil) if sexp.empty?
+      return process s(:nil) if sexp.empty?
 
+      result = []
       join = (@scope.class_scope? ? "\n\n#@indent" : "\n#@indent")
 
-      until sexp.empty?
-        stmt = sexp.shift
-
-        result << fragment(join, sexp) unless result.empty?
+      sexp.each do |stmt|
+        result << f(join, sexp) unless result.empty?
 
         # find any inline yield statements
         if yasgn = find_inline_yield(stmt)
-          result << process(yasgn, level)
-          result << fragment(";", yasgn)
+          result << process(yasgn, level) << f(";", yasgn)
         end
 
         expr = expression?(stmt) and LEVEL.index(level) < LEVEL.index(:list)
 
-        code = process(stmt, level)
-
-        result << code
-        if expr
-          result << fragment(";", stmt)
-        end
+        result << process(stmt, level)
+        result << f(";", stmt) if expr
       end
 
       result
@@ -476,12 +530,14 @@ module Opal
       found = nil
       case stmt.first
       when :js_return
-        found = find_inline_yield stmt[1]
+        if found = find_inline_yield(stmt[1])
+          found = found[2]
+        end
       when :array
         stmt[1..-1].each_with_index do |el, idx|
           if el.first == :yield
             found = el
-            stmt[idx+1] = s(:js_tmp, '__yielded')
+            stmt[idx+1] = s(:js_tmp, '$yielded')
           end
         end
       when :call
@@ -489,72 +545,42 @@ module Opal
         arglist[1..-1].each_with_index do |el, idx|
           if el.first == :yield
             found = el
-            arglist[idx+1] = s(:js_tmp, '__yielded')
+            arglist[idx+1] = s(:js_tmp, '$yielded')
           end
         end
       end
 
       if found
-        @scope.add_temp '__yielded' unless @scope.has_temp? '__yielded'
-        s(:yasgn, '__yielded', found)
+        @scope.add_temp '$yielded' unless @scope.has_temp? '$yielded'
+        s(:yasgn, '$yielded', found)
       end
     end
 
     def process_scope(sexp, level)
-      stmt = sexp.shift
-      if stmt
-        unless @scope.class_scope?
-          stmt = returns stmt
-        end
+      stmt = sexp[0] || s(:nil)
+      stmt = returns stmt unless @scope.class_scope?
 
-        process stmt, :stmt
-      else
-        fragment("nil", sexp)
-      end
+      process stmt, :stmt
     end
 
     # s(:js_return, sexp)
     def process_js_return(sexp, level)
-      [fragment("return ", sexp), process(sexp.shift, :expr)]
+      [f("return ", sexp), process(sexp[0])]
     end
 
     # s(:js_tmp, str)
     def process_js_tmp(sexp, level)
-      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|
-          with_temp do |b|
-            l = process recv, :expr
-            r = process arg, :expr
-
-            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
+      f(sexp[0].to_s, sexp)
     end
 
     def js_block_given(sexp, level)
       @scope.uses_block!
       if @scope.block_name
-        fragment("(#{@scope.block_name} !== nil)", sexp)
+        f("(#{@scope.block_name} !== nil)", sexp)
+      elsif scope = @scope.find_parent_def and scope.block_name
+        f("(#{scope.block_name} !== nil)", sexp)
       else
-        fragment("false", sexp)
+        f("false", sexp)
       end
     end
 
@@ -562,127 +588,124 @@ module Opal
       @scope.uses_block!
       name = @scope.block_name
 
-      fragment((reverse ? "#{ name } === nil" : "#{ name } !== nil"), sexp)
+      f((reverse ? "#{ name } === nil" : "#{ name } !== nil"), sexp)
     end
 
     def process_sym(sexp, level)
-      fragment(sexp[0].to_s.inspect, sexp)
+      f(sexp[0].to_s.inspect, sexp)
     end
 
+    # Process integers. Wrap in parens if a receiver of method call
     def process_int(sexp, level)
-      handle_number sexp, level
+      f((level == :recv ? "(#{sexp[0]})" : sexp[0].to_s), sexp)
     end
 
-    def process_float(sexp, level)
-      handle_number sexp, level
-    end
-
-    def handle_number(sexp, level)
-      if level == :recv
-        fragment("(#{sexp[0]})", sexp)
-      else
-        fragment(sexp[0].to_s, sexp)
-      end
-    end
+    # Floats generated just like integers
+    alias_method :process_float, :process_int
 
+    # Regexp literals. Convert to empty js regexp if empty (not compatible)
     def process_regexp(sexp, level)
       val = sexp[0]
-      fragment((val == // ? /^/.inspect : val.inspect), sexp)
+      f((val == // ? /^/.inspect : val.inspect), sexp)
     end
 
+    # Dynamic regexps with interpolation
+    # s(:dregx, parts...) => new Regexp("...")
     def process_dregx(sexp, level)
       result = []
 
       sexp.each do |part|
-        result << fragment(" + ", sexp) unless result.empty?
+        result << f(" + ", sexp) unless result.empty?
 
         if String === part
-          result << fragment(part.inspect, sexp)
+          result << f(part.inspect, sexp)
         elsif part[0] == :str
-          result << process(part, :expr)
+          result << process(part)
         else
-          result << process(part[1], :expr)
+          result << process(part[1])
         end
       end
 
-      [fragment("(new RegExp(", sexp), result, fragment("))", sexp)]
+      [f("(new RegExp(", sexp), result, f("))", sexp)]
     end
 
+    # Exclusive range, uses opal __range helper.
+    # s(:dot3, start, end) => __range(start, end, false)
     def process_dot2(sexp, level)
-      lhs = process sexp[0], :expr
-      rhs = process sexp[1], :expr
       @helpers[:range] = true
 
-      [fragment("__range(", sexp), lhs, fragment(", ", sexp), rhs, fragment(", false)", sexp)]
+      [f("$range(", sexp), process(sexp[0]), f(", ", sexp), process(sexp[1]), f(", false)", sexp)]
     end
 
+    # Inclusive range, uses __range helper
+    # s(:dot3, start, end) => __range(start, end, true)
     def process_dot3(sexp, level)
-      lhs = process sexp[0], :expr
-      rhs = process sexp[1], :expr
       @helpers[:range] = true
 
-      [fragment("__range(", sexp), lhs, fragment(", ", sexp), rhs, fragment(", true)", sexp)]
+      [f("$range(", sexp), process(sexp[0]), f(", ", sexp), process(sexp[1]), f(", true)", sexp)]
     end
 
-    # s(:str, "string")
+    # Simple strings, no interpolation.
+    # s(:str, "string") => "string"
     def process_str(sexp, level)
-      str = sexp.shift
-      if str == @file
-        @uses_file = true
-        fragment(@file.inspect, sexp)
-      else
-        fragment(str.inspect, sexp)
-      end
+      f sexp[0].inspect, sexp
     end
 
+    # defined?(x) => various
     def process_defined(sexp, level)
       part = sexp[0]
       case part[0]
       when :self
-        fragment("self".inspect, sexp)
+        f("'self'", sexp)
       when :nil
-        fragment("nil".inspect, sexp)
+        f("'nil'", sexp)
       when :true
-        fragment("true".inspect, sexp)
+        f("'true'", sexp)
       when :false
-        fragment("false".inspect, sexp)
+        f("'false'", sexp)
       when :call
         mid = mid_to_jsid part[2].to_s
-        recv = part[1] ? process(part[1], :expr) : fragment(current_self, sexp)
-        [fragment("(", sexp), recv, fragment("#{mid} ? 'method' : nil)", sexp)]
-      when :xstr
-        [fragment("(typeof(", sexp), process(part, :expr), fragment(") !== 'undefined')", sexp)]
+        recv = part[1] ? process(part[1]) : f(current_self, sexp)
+        [f("(", sexp), recv, f("#{mid} ? 'method' : nil)", sexp)]
+      when :xstr, :dxstr
+        [f("(typeof(", sexp), process(part), f(") !== 'undefined')", sexp)]
       when :const
-        fragment("(__scope.#{part[1].to_s} != null)", sexp)
+        f("($scope.#{part[1].to_s} != null)", sexp)
+      when :cvar
+        f("($opal.cvars[#{part[1].to_s.inspect}] != null ? 'class-variable' : nil)", sexp)
       when :colon2
-        fragment("false", sexp)
+        f("false", sexp)
       when :colon3
-        fragment("(__opal.Object._scope.#{sexp[0][1]} == null ? nil : 'constant')", sexp)
+        f("($opal.Object._scope.#{sexp[0][1]} == null ? nil : 'constant')", sexp)
       when :ivar
         ivar_name = part[1].to_s[1..-1]
         with_temp do |t|
-          fragment("((#{t} = #{current_self}[#{ivar_name.inspect}], #{t} != null && #{t} !== nil) ? 'instance-variable' : nil)", sexp)
+          f("((#{t} = #{current_self}[#{ivar_name.inspect}], #{t} != null && #{t} !== nil) ? 'instance-variable' : nil)", sexp)
         end
       when :lvar
-        fragment("local-variable", sexp)
+        f("local-variable", sexp)
       else
         raise "bad defined? part: #{part[0]}"
       end
     end
 
-    # s(:not, sexp)
+    # not keyword or '!' operand
+    # s(:not, value) => (tmp = value, (tmp === nil || tmp === false))
     def process_not(sexp, level)
       with_temp do |tmp|
-        expr = sexp.shift
-        [fragment("(#{tmp} = ", sexp), process(expr, :expr), fragment(", (#{tmp} === nil || #{tmp} === false))", sexp)]
+        expr = sexp[0]
+        [f("(#{tmp} = ", sexp), process(expr), f(", (#{tmp} === nil || #{tmp} === false))", sexp)]
       end
     end
 
+    # A block pass '&foo' syntax
+    # s(:block_pass, value) => value.$to_proc()
     def process_block_pass(exp, level)
-      process(s(:call, exp.shift, :to_proc, s(:arglist)), :expr)
+      process s(:call, exp[0], :to_proc, s(:arglist))
     end
 
-    # s(:iter, call, block_args [, body)
+    # A block/iter with embeded call. Compiles into function
+    # s(:iter, call, block_args [, body) => (function() { ... })
     def process_iter(sexp, level)
       call, args, body = sexp
 
@@ -698,6 +721,12 @@ module Opal
       args ||= s(:masgn, s(:array))
       args = args.first == :lasgn ? s(:array, args) : args[1]
 
+      # opt args are last, if present, and are a [:block]
+      if args.last.is_a?(Array) and args.last[0] == :block
+        opt_args = args.pop
+        opt_args.shift
+      end
+
       if args.last.is_a?(Array) and args.last[0] == :block_pass
         block_arg = args.pop
         block_arg = block_arg[1][1].to_sym
@@ -717,7 +746,12 @@ module Opal
           args[1..-1].each do |arg|
             arg = arg[1]
             arg = "#{arg}$" if RESERVED.include? arg.to_s
-            code << fragment("if (#{arg} == null) #{arg} = nil;\n", sexp)
+
+            if opt_args and current_opt = opt_args.find { |s| s[1] == arg.to_sym }
+              code << [f("if (#{arg} == null) #{arg} = ", sexp), process(current_opt[2]), f(";\n", sexp)]
+            else
+              code << f("if (#{arg} == null) #{arg} = nil;\n", sexp)
+            end
           end
 
           params = js_block_args(args[1..-1])
@@ -725,47 +759,47 @@ module Opal
           if splat
             @scope.add_arg splat
             params << splat
-            code << fragment("#{splat} = __slice.call(arguments, #{len - 1});", sexp)
+            code << f("#{splat} = $slice.call(arguments, #{len - 1});", sexp)
           end
 
           if block_arg
             @scope.block_name = block_arg
             @scope.add_temp block_arg
-            @scope.add_temp '__context'
             scope_name = @scope.identify!
 
             blk = []
-            blk << fragment("\n#@indent#{block_arg} = #{scope_name}._p || nil, #{scope_name}.p = null;\n#@indent", sexp)
+            blk << f("\n#@indent#{block_arg} = #{scope_name}._p || nil, #{scope_name}.p = null;\n#@indent", sexp)
 
             code.unshift blk
           end
 
-          code << fragment("\n#@indent", sexp)
+          code << f("\n#@indent", sexp)
           code << process(body, :stmt)
 
           if @scope.defines_defn
             @scope.add_temp "def = ((#{current_self}._isClass) ? #{current_self}._proto : #{current_self})"
           end
 
-          to_vars = [fragment("\n#@indent", sexp), @scope.to_vars, fragment("\n#@indent", sexp)]
+          to_vars = [f("\n#@indent", sexp), @scope.to_vars, f("\n#@indent", sexp)]
         end
       end
 
-      itercode = [fragment("function(#{params.join ', '}) {\n", sexp), to_vars, code, fragment("\n#@indent}", sexp)]
+      itercode = [f("function(#{params.join ', '}) {\n", sexp), to_vars, code, f("\n#@indent}", sexp)]
 
-      itercode.unshift fragment("(#{identity} = ", sexp)
-      itercode << fragment(", #{identity}._s = #{current_self}, #{identity})", sexp)
+      itercode.unshift f("(#{identity} = ", sexp)
+      itercode << f(", #{identity}._s = #{current_self}, #{identity})", sexp)
 
       call << itercode
       process call, level
     end
 
+    # Maps block args into array of jsid. Adds $ suffix to invalid js
+    # identifiers.
+    #
+    # s(:args, parts...) => ["a", "b", "break$"]
     def js_block_args(sexp)
       sexp.map do |arg|
-        a = arg[1].to_sym
-        a = "#{a}$".to_sym if RESERVED.include? a.to_s
-        @scope.add_arg a
-        a
+        @scope.add_arg lvar_to_js(arg[1])
       end
     end
 
@@ -778,60 +812,25 @@ module Opal
       process s(:call, recv, mid, arglist), level
     end
 
-    # Used to generate optimized attr_reader, attr_writer and
-    # attr_accessor methods. These are optimized to avoid the added
-    # cost of converting the method id's into jsid's at runtime.
-    #
-    # This method will only be called if all the given ids are strings
-    # or symbols. Any dynamic arguments will default to being called
-    # using the Module#attr_* methods as expected.
-    #
-    # @param [Symbol] meth :attr_{reader,writer,accessor}
-    # @param [Array<Sexp>] attrs array of s(:sym) or s(:str)
-    # @return [String] precompiled attr methods
-    def handle_attr_optimize(meth, attrs)
-      out = []
-
-      attrs.each do |attr|
-        mid  = attr[1]
-        ivar = "@#{mid}".to_sym
-
-        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 << fragment(", nil")
-      out
-    end
-
     # s(:call, recv, :mid, s(:arglist))
     # s(:call, nil, :mid, s(:arglist))
     def process_call(sexp, level)
       recv, meth, arglist, iter = sexp
       mid = mid_to_jsid meth.to_s
 
+      @method_calls[meth.to_sym] = true
+
       # 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)]
+          [f("((#{t} = $opal.irb_vars.#{lvar}) == null ? ", sexp), process(call), f(" : #{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)
       end
@@ -839,7 +838,7 @@ module Opal
       splat = arglist[1..-1].any? { |a| a.first == :splat }
 
       if Array === arglist.last and arglist.last.first == :block_pass
-        block = process(arglist.pop, :expr)
+        block = process(arglist.pop)
       elsif iter
         block = iter
       end
@@ -850,54 +849,35 @@ module Opal
         tmpfunc = @scope.new_temp
       end
 
-      tmprecv = @scope.new_temp
+      tmprecv = @scope.new_temp if splat || tmpfunc
       args      = ""
 
       recv_code = process recv, :recv
 
-      if @method_missing
-        call_recv = s(:js_tmp, tmprecv || recv_code)
-        arglist.insert 1, call_recv unless splat
-        args = process arglist, :expr
-
-        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.unshift fragment("(#{tmpfunc} = ", sexp)
-          dispatch << fragment(", #{tmpfunc}._p = ", sexp)
-          dispatch << block
-          dispatch << fragment(", #{tmpfunc})", sexp)
-        end
+      call_recv = s(:js_tmp, tmprecv || recv_code)
+      arglist.insert 1, call_recv if tmpfunc and !splat
+      args = process arglist
 
-        if splat
-          dispatch << fragment(".apply(", sexp)
-          dispatch << process(call_recv, :expr)
-          dispatch << fragment(", ", sexp)
-          dispatch << args
-          dispatch << fragment(")", sexp)
-        else
-          dispatch << fragment(".call(", sexp)
-          dispatch.push(*args)
-          dispatch << fragment(")", sexp)
-        end
-
-        result = dispatch
+      dispatch = if tmprecv
+        [f("(#{tmprecv} = "), recv_code, f(")#{mid}")]
       else
-        args = process arglist, :expr
+        [recv_code, f(mid)]
+      end
 
-        dispatch = if tmprecv
-          [fragment("(#{tmprecv} = ", sexp), recv_code, fragment(")#{mid}", sexp)]
-        else
-          [recv_code, fragment(mid, sexp)]
-        end
+      if tmpfunc
+        dispatch.unshift f("(#{tmpfunc} = ")
+        dispatch << f(", #{tmpfunc}._p = ")
+        dispatch << block
+        dispatch << f(", #{tmpfunc})")
+      end
 
-        result = if splat
-          [dispatch, fragment(".apply(", sexp), (tmprecv ? fragment(tmprecv, sexp) : recv_code),
-           fragment(", ", sexp), args, fragment(")", sexp)]
-        else
-          [dispatch, fragment("(", sexp), args, fragment(")", sexp)]
-        end
+      result = if splat
+        [dispatch, f(".apply("), (tmprecv ? f(tmprecv) : recv_code),
+         f(", "), args, f(")")]
+      elsif tmpfunc
+        [dispatch, f(".call("), args, f(")")]
+      else
+        [dispatch, f("("), args, f(")")]
       end
 
       @scope.queue_temp tmpfunc if tmpfunc
@@ -906,37 +886,35 @@ module Opal
 
     # s(:arglist, [arg [, arg ..]])
     def process_arglist(sexp, level)
-      code = []
-      work = []
+      code, work = [], []
 
-      until sexp.empty?
-        current = sexp.shift
+      sexp.each do |current|
         splat = current.first == :splat
-        arg   = process current, :expr
+        arg   = process current
 
         if splat
           if work.empty?
             if code.empty?
-              code << fragment("[].concat(", sexp)
+              code << f("[].concat(", sexp)
               code << arg
-              code << fragment(")", sexp)
+              code << f(")")
             else
               code += ".concat(#{arg})"
             end
           else
             if code.empty?
-              code << [fragment("[", sexp), work, fragment("]", sexp)]
+              code << [f("["), work, f("]")]
             else
-              code << [fragment(".concat([", sexp), work, fragment("])", sexp)]
+              code << [f(".concat(["), work, f("])")]
             end
 
-            code << [fragment(".concat(", sexp), arg, fragment(")", sexp)]
+            code << [f(".concat("), arg, f(")")]
           end
 
           work = []
         else
-          work << fragment(", ", current) unless work.empty?
-          work.push(*arg)
+          work << f(", ") unless work.empty?
+          work << arg
         end
       end
 
@@ -946,7 +924,7 @@ module Opal
         if code.empty?
           code = join
         else
-          code << fragment(".concat(", sexp) << join << fragment(")", sexp)
+          code << f(".concat(") << join << f(")")
         end
       end
 
@@ -956,9 +934,9 @@ module Opal
     # s(:splat, sexp)
     def process_splat(sexp, level)
       if sexp.first == [:nil]
-        [fragment("[]", sexp)]
+        [f("[]")]
       elsif sexp.first.first == :sym
-        [fragment("[", sexp), process(sexp.first, :expr), fragment("]", sexp)]
+        [f("["), process(sexp[0]), f("]")]
       else
         process sexp.first, :recv
       end
@@ -974,24 +952,24 @@ module Opal
       @helpers[:klass] = true
 
       if Symbol === cid or String === cid
-        base = process(s(:self), :expr)
+        base = process s(:self)
         name = cid.to_s
       elsif cid[0] == :colon2
-        base = process(cid[1], :expr)
+        base = process(cid[1])
         name = cid[2].to_s
       elsif cid[0] == :colon3
-        base = process(s(:js_tmp, 'Opal.Object'), :expr)
+        base = process(s(:js_tmp, '$opal.Object'))
         name = cid[1].to_s
       else
         raise "Bad receiver in class"
       end
 
-      sup = sup ? process(sup, :expr) : process(s(:js_tmp, 'null'), :expr)
+      sup = sup ? process(sup) : process(s(:js_tmp, 'null'))
 
       indent do
         in_scope(:class) do
           @scope.name = name
-          @scope.add_temp "#{ @scope.proto } = #{name}._proto", "__scope = #{name}._scope"
+          @scope.add_temp "#{ @scope.proto } = #{name}._proto", "$scope = #{name}._scope"
 
           if Array === body.last
             # A single statement will need a block
@@ -1007,62 +985,54 @@ module Opal
             end
           end
 
-          body = returns(body)
-          body = process body, :stmt
-          code << fragment("\n", sexp)
+          body = process(returns(body), :stmt)
+          code << f("\n")
           code << @scope.to_donate_methods
 
-          code << fragment(@indent, sexp)
+          code << f(@indent)
           code << @scope.to_vars
-          code << fragment("\n\n#@indent", sexp)
+          code << f("\n\n#@indent")
           code << body
         end
       end
 
       spacer  = "\n#{@indent}#{INDENT}"
       cls     = "function #{name}() {};"
-      boot    = "#{name} = __klass(__base, __super, #{name.inspect}, #{name});"
+      boot    = "#{name} = $klass($base, $super, #{name.inspect}, #{name});"
 
-      [fragment("(function(__base, __super){#{spacer}#{cls}#{spacer}#{boot}\n", sexp),
-       code, fragment("\n#@indent})", sexp), fragment("(", sexp), base, fragment(", ", sexp), sup, fragment(")", sexp)]
+      [f("(function($base, $super){#{spacer}#{cls}#{spacer}#{boot}\n", sexp),
+       code, f("\n#@indent})", sexp), f("(", sexp), base, f(", ", sexp), sup, f(")", sexp)]
     end
 
-    # s(:sclass, recv, body)
+    # Singleton class syntax. Runs body in context of singleton_class.
+    # s(:sclass, recv, body) => (function() { ... }).call(recv.$singleton_class())
     def process_sclass(sexp, level)
-      recv = sexp[0]
-      body = sexp[1]
-      code = []
+      recv, body, code = sexp[0], sexp[1], []
 
       in_scope(:sclass) do
-        @scope.add_temp "__scope = #{current_self}._scope"
+        @scope.add_temp "$scope = #{current_self}._scope"
         @scope.add_temp "def = #{current_self}._proto"
 
-        body = process body, :stmt
-        code << @scope.to_vars << body
+        code << @scope.to_vars << process(body, :stmt)
       end
 
-      result = []
-      result << fragment("(function(){", sexp) << code
-      result << fragment("}).call(__opal.singleton(", sexp)
-      result << process(recv, :expr) << fragment("))", sexp)
-      result
+      [f("(function(){"), code, f("}).call("), process(recv, :recv), f(".$singleton_class())")]
     end
 
     # s(:module, cid, body)
     def process_module(sexp, level)
-      cid = sexp[0]
-      body = sexp[1]
+      cid, body = sexp
       code = []
       @helpers[:module] = true
 
       if Symbol === cid or String === cid
-        base = process(s(:self), :expr)
+        base = process(s(:self))
         name = cid.to_s
       elsif cid[0] == :colon2
-        base = process(cid[1], :expr)
+        base = process(cid[1])
         name = cid[2].to_s
       elsif cid[0] == :colon3
-        base = fragment('Opal.Object', sexp)
+        base = f('$opal.Object', sexp)
         name = cid[1].to_s
       else
         raise "Bad receiver in class"
@@ -1071,34 +1041,35 @@ module Opal
       indent do
         in_scope(:module) do
           @scope.name = name
-          @scope.add_temp "#{ @scope.proto } = #{name}._proto", "__scope = #{name}._scope"
+          @scope.add_temp "#{ @scope.proto } = #{name}._proto", "$scope = #{name}._scope"
           body = process body, :stmt
 
-          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)
+          code << f(@indent)
+          code << @scope.to_vars
+          code << f("\n\n#@indent")
+          code << body
+          code << f("\n#@ident")
+          code << @scope.to_donate_methods
         end
       end
 
       spacer  = "\n#{@indent}#{INDENT}"
       cls     = "function #{name}() {};"
-      boot    = "#{name} = __module(__base, #{name.inspect}, #{name});"
+      boot    = "#{name} = $module($base, #{name.inspect}, #{name});"
 
-      code.unshift fragment("(function(__base){#{spacer}#{cls}#{spacer}#{boot}\n", sexp)
-      code << fragment("\n#@indent})(", sexp)
-      code.push(*base)
-      code << fragment(")", sexp)
+      code.unshift f("(function($base){#{spacer}#{cls}#{spacer}#{boot}\n", sexp)
+      code << f("\n#@indent})(")
+      code << base
+      code << f(")")
 
       code
     end
 
     # undef :foo
     # => delete MyClass.prototype.$foo
+    # FIXME: we should be setting method to a stub method here
     def process_undef(sexp, level)
-      fragment("delete #{ @scope.proto }#{ mid_to_jsid sexp[0][1].to_s }", sexp)
+      f("delete #{ @scope.proto }#{ mid_to_jsid sexp[0][1].to_s }", sexp)
     end
 
     # s(:defn, mid, s(:args), s(:scope))
@@ -1121,7 +1092,7 @@ module Opal
       if recvr
         @scope.defines_defs = true
         smethod = true if @scope.class_scope? && recvr.first == :self
-        recv = process(recvr, :expr)
+        recv = process(recvr)
       else
         @scope.defines_defn = true
         recv = current_self
@@ -1167,54 +1138,64 @@ module Opal
 
           if block_name
             @scope.uses_block!
+            @scope.add_arg block_name
           end
 
-          yielder = block_name || '__yield'
+          yielder = block_name || '$yield'
           @scope.block_name = yielder
 
-          params = process args, :expr
-          stmt_code = [fragment("\n#@indent", stmts), *process(stmts, :stmt)]
+          params = process args
+          stmt_code = [f("\n#@indent"), process(stmts, :stmt)]
 
           opt[1..-1].each do |o|
             next if o[2][2] == :undefined
-            code << fragment("if (#{o[1]} == null) {\n#{@indent + INDENT}", o)
-            code << process(o, :expr)
-            code << fragment("\n#{@indent}}", o)
+            code << f("if (#{o[1]} == null) {\n#{@indent + INDENT}", o)
+            code << process(o)
+            code << f("\n#{@indent}}", o)
           end if opt
 
-          code << fragment("#{splat} = __slice.call(arguments, #{argc});", sexp) if splat
+          code << f("#{splat} = $slice.call(arguments, #{argc});", sexp) if splat
 
           scope_name = @scope.identity
 
           if @scope.uses_block?
-            @scope.add_temp yielder
-            blk = fragment(("\n%s%s = %s._p || nil, %s._p = null;\n%s" %
-                            [@indent, yielder, scope_name, scope_name, @indent]), sexp)
+            @scope.add_temp "$iter = #{scope_name}._p"
+            @scope.add_temp "#{yielder} = $iter || nil"
+
+            code.unshift f("#{scope_name}._p = null;", sexp)
           end
 
           code.push(*stmt_code)
-          code.unshift blk if blk
 
           uses_super = @scope.uses_super
 
-          code = [fragment("#{arity_code}#@indent", sexp), @scope.to_vars, code]
+          code = [f("#{arity_code}#@indent", sexp), @scope.to_vars, code]
+
+          if @scope.uses_zuper
+            code.unshift f("var $zuper = $slice.call(arguments, 0);", sexp)
+          end
+
+          if @scope.catch_return
+            code.unshift f("try {\n", sexp)
+            code.push f("\n} catch($returner) { if ($returner === $opal.returner) { return $returner.$v; } throw $returner; }", sexp)
+          end
         end
       end
 
-      result = [fragment("#{"#{scope_name} = " if scope_name}function(", sexp)]
+      result = [f("#{"#{scope_name} = " if scope_name}function(", sexp)]
       result.push(*params)
-      result << fragment(") {\n", sexp)
+      result << f(") {\n", sexp)
       result.push(*code)
-      result << fragment("\n#@indent}", sexp)
+      result << f("\n#@indent}", sexp)
 
       if recvr
         if smethod
-          [fragment("#{@scope.name}.constructor.prototype['$#{mid}'] = ", sexp), result]
+          [f("#{@scope.name}.constructor.prototype['$#{mid}'] = ", sexp), result]
         else
-          [recv, fragment("#{jsid} = ", sexp), result]
+          [recv, f("#{jsid} = ", sexp), result]
         end
       elsif @scope.class? and @scope.name == 'Object'
-        [fragment("#{current_self}._defn('$#{mid}', ", sexp), result, fragment(")", sexp)]
+        [f("#{current_self}._defn('$#{mid}', ", sexp), result, f(")", sexp)]
       elsif @scope.class_scope?
         @scope.methods << "$#{mid}"
         if uses_super
@@ -1222,13 +1203,9 @@ module Opal
           uses_super = "#{uses_super} = #{@scope.proto}#{jsid};\n#@indent"
         end
 
-        [fragment("#{uses_super}#{@scope.proto}#{jsid} = ", sexp), result]
-      elsif @scope.type == :iter
-        [fragment("def#{jsid} = ", sexp), result]
-      elsif @scope.type == :top
-        [fragment("def#{ jsid } = ", sexp), *result]
-      else
-        [fragment("def#{jsid} = ", sexp), result]
+        [f("#{uses_super}#{@scope.proto}#{jsid} = ", sexp), result]
+      else # :top, :iter
+        [f("def#{jsid} = ", sexp), result]
       end
     end
 
@@ -1246,34 +1223,35 @@ module Opal
       aritycode = "var $arity = arguments.length;"
 
       if arity < 0 # splat or opt args
-        aritycode + "if ($arity < #{-(arity + 1)}) { __opal.ac($arity, #{arity}, this, #{meth}); }"
+        aritycode + "if ($arity < #{-(arity + 1)}) { $opal.ac($arity, #{arity}, this, #{meth}); }"
       else
-        aritycode + "if ($arity !== #{arity}) { __opal.ac($arity, #{arity}, this, #{meth}); }"
+        aritycode + "if ($arity !== #{arity}) { $opal.ac($arity, #{arity}, this, #{meth}); }"
       end
     end
 
     def process_args(exp, level)
       args = []
 
-      until exp.empty?
-        a = exp.shift.to_sym
+      exp.each do |a|
+        a = a.to_sym
         next if a.to_s == '*'
-        a = "#{a}$".to_sym if RESERVED.include? a.to_s
+        a = lvar_to_js a
         @scope.add_arg a
         args << a
       end
 
-      [fragment(args.join(', '), exp)]
+      f(args.join(', '), exp)
     end
 
     # s(:self)  # => this
     def process_self(sexp, level)
-      fragment(current_self, sexp)
+      f(current_self, sexp)
     end
 
     # Returns the current value for 'self'. This will be native
     # 'this' for methods and blocks, and the class name for class
     # and module bodies.
+    # s(:self) => self or this or class name
     def current_self
       if @scope.class_scope?
         @scope.name
@@ -1284,60 +1262,64 @@ module Opal
       end
     end
 
+    # true literal
+    # s(:true) => true
     def process_true(sexp, level)
-      fragment("true", sexp)
+      f "true", sexp
     end
 
+    # false literal
+    # s(:false) => false
     def process_false(sexp, level)
-      fragment("false", sexp)
+       f "false", sexp
     end
 
+    # nil literal
+    # s(:nil) => nil
     def process_nil(sexp, level)
-      fragment("nil", sexp)
+      f "nil", sexp
     end
 
-    # s(:array [, sexp [, sexp]])
+    # s(:array [, sexp [, sexp]]) => [...]
     def process_array(sexp, level)
-      return [fragment("[]", sexp)] if sexp.empty?
+      return [f("[]", sexp)] if sexp.empty?
 
-      code = []
-      work = []
+      code, work = [], []
 
-      until sexp.empty?
-        current = sexp.shift
+      sexp.each do |current|
         splat = current.first == :splat
-        part  = process current, :expr
+        part  = process current
 
         if splat
           if work.empty?
             if code.empty?
-              code << fragment("[].concat(", sexp) << part << fragment(")", sexp)
+              code << f("[].concat(", sexp) << part << f(")", sexp)
             else
-              code << fragment(".concat(", sexp) << part << fragment(")", sexp)
+              code << f(".concat(", sexp) << part << f(")", sexp)
             end
           else
             if code.empty?
-              code << fragment("[", sexp) << work << fragment("]", sexp)
+              code << f("[", sexp) << work << f("]", sexp)
             else
-              code << fragment(".concat([", sexp) << work << fragment("])", sexp)
+              code << f(".concat([", sexp) << work << f("])", sexp)
             end
 
-            code << fragment(".concat(", sexp) << part << fragment(")", sexp)
+            code << f(".concat(", sexp) << part << f(")", sexp)
           end
           work = []
         else
-          work << fragment(", ", current) unless work.empty?
+          work << f(", ", current) unless work.empty?
           work << part
         end
       end
 
       unless work.empty?
-        join = [fragment("[", sexp), work, fragment("]", sexp)]
+        join = [f("[", sexp), work, f("]", sexp)]
 
         if code.empty?
           code = join
         else
-          code.push([fragment(".concat(", sexp), join, fragment(")", sexp)])
+          code.push([f(".concat(", sexp), join, f(")", sexp)])
         end
       end
 
@@ -1363,29 +1345,29 @@ module Opal
         keys.size.times do |i|
           k = keys[i][1].to_s.inspect
           hash_keys << k unless hash_obj.include? k
-          hash_obj[k] = process(vals[i], :expr)
+          hash_obj[k] = process(vals[i])
         end
 
         result = []
         @helpers[:hash2] = true
 
         hash_keys.each do |k|
-          result << fragment(", ", sexp) unless result.empty?
-          result << fragment("#{k}: ", sexp)
+          result << f(", ", sexp) unless result.empty?
+          result << f("#{k}: ", sexp)
           result << hash_obj[k]
         end
 
-        [fragment("__hash2([#{hash_keys.join ', '}], {", sexp), result, fragment("})", sexp)]
+        [f("$hash2([#{hash_keys.join ', '}], {", sexp), result, f("})", sexp)]
       else
         @helpers[:hash] = true
         result = []
 
         sexp.each do |p|
-          result << fragment(", ", p) unless result.empty?
-          result << process(p, :expr)
+          result << f(", ", p) unless result.empty?
+          result << process(p)
         end
 
-        [fragment("__hash(", sexp), result, fragment(")", sexp)]
+        [f("$hash(", sexp), result, f(")", sexp)]
       end
     end
 
@@ -1401,7 +1383,7 @@ module Opal
                       :stmt
                     end
 
-      code << js_truthy(expr) << fragment("){", sexp)
+      code << js_truthy(expr) << f("){", sexp)
       pre = "while ("
 
       in_while do
@@ -1411,27 +1393,26 @@ module Opal
 
         if @while_loop[:use_redo]
           pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
-          code << fragment("#{redo_var}=false;", sexp)
+          code << f("#{redo_var}=false;", sexp)
         end
 
         code << body
       end
 
-      code << fragment("}", sexp)
-      code.unshift fragment(pre, sexp)
+      code << f("}", sexp)
+      code.unshift f(pre, sexp)
       @scope.queue_temp redo_var
 
       if stmt_level == :stmt_closure
-        code.unshift fragment("(function() {", sexp)
-        code.push fragment("; return nil; }).call(#{current_self})", sexp)
+        code.unshift f("(function() {", sexp)
+        code.push f("; return nil; }).call(#{current_self})", sexp)
       end
 
       code
     end
 
     def process_until(exp, level)
-      expr = exp[0]
-      stmt = exp[1]
+      expr, stmt = exp
       redo_var   = @scope.new_temp
       stmt_level = if level == :expr or level == :recv
                      :stmt_closure
@@ -1441,7 +1422,7 @@ module Opal
 
       code = []
       pre = "while (!("
-      code << js_truthy(expr) << fragment(")) {", exp)
+      code << js_truthy(expr) << f(")) {", exp)
 
       in_while do
         @while_loop[:closure] = true if stmt_level == :stmt_closure
@@ -1450,19 +1431,19 @@ module Opal
 
         if @while_loop[:use_redo]
           pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
-          code << fragment("#{redo_var}=false;", exp)
+          code << f("#{redo_var}=false;", exp)
         end
 
         code << body
       end
 
-      code << fragment("}", exp)
-      code.unshift fragment(pre, exp)
+      code << f("}", exp)
+      code.unshift f(pre, exp)
       @scope.queue_temp redo_var
 
       if stmt_level == :stmt_closure
-        code.unshift fragment("(function() {", exp)
-        code << fragment("; return nil; }).call(#{current_self})", exp)
+        code.unshift f("(function() {", exp)
+        code << f("; return nil; }).call(#{current_self})", exp)
       end
 
       code
@@ -1477,50 +1458,59 @@ module Opal
 
       if [:class, :module].include? @scope.type
         @scope.methods << "$#{exp[0][1].to_s}"
-        fragment("%s%s = %s%s" % [@scope.proto, new, @scope.proto, old], exp)
+        f("%s%s = %s%s" % [@scope.proto, new, @scope.proto, old], exp)
       else
         current = current_self
-        fragment("%s._proto%s = %s._proto%s" % [current, new, current, old], exp)
+        f("%s._proto%s = %s._proto%s" % [current, new, current, old], exp)
       end
     end
 
     def process_masgn(sexp, level)
-      lhs = sexp[0]
-      rhs = sexp[1]
+      lhs, rhs = sexp
       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 << fragment("#{tmp} = ", sexp) << process(rhs, :expr)
+        code << f("#{tmp} = ", sexp) << process(rhs)
       elsif rhs[0] == :to_ary
-        code << fragment("((#{tmp} = ", sexp) << process(rhs[1], :expr)
-        code << fragment(")._isArray ? #{tmp} : (#{tmp} = [#{tmp}]))", sexp)
+        code << f("((#{tmp} = ", sexp) << process(rhs[1])
+        code << f(")._isArray ? #{tmp} : (#{tmp} = [#{tmp}]))", sexp)
       elsif rhs[0] == :splat
-        code << fragment("(#{tmp} = ", sexp) << process(rhs[1], :expr)
-        code << fragment(")['$to_a'] ? (#{tmp} = #{tmp}['$to_a']()) : (#{tmp})._isArray ?  #{tmp} : (#{tmp} = [#{tmp}])", sexp)
+        code << f("(#{tmp} = ", sexp) << process(rhs[1])
+        code << f(")['$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?
+      lhs[1..-1].each_with_index do |l, idx|
+        code << f(", ", sexp) unless code.empty?
 
         if l.first == :splat
           if s = l[1]
-            s << s(:js_tmp, "__slice.call(#{tmp}, #{idx})")
-            code << process(s, :expr)
+            s << s(:js_tmp, "$slice.call(#{tmp}, #{idx})")
+            code << process(s)
           end
         else
           if idx >= len
-            l << s(:js_tmp, "(#{tmp}[#{idx}] == null ? nil : #{tmp}[#{idx}])")
+            assign = s(:js_tmp, "(#{tmp}[#{idx}] == null ? nil : #{tmp}[#{idx}])")
+          else
+            assign = s(:js_tmp, "#{tmp}[#{idx}]")
+          end
+
+          if l[0] == :lasgn or l[0] == :iasgn or l[0] == :lvar
+            l << assign
+          elsif l[0] == :call
+            l[2] = "#{l[2]}=".to_sym
+            l.last << assign
+          elsif l[0] == :attrasgn
+            l.last << assign
           else
-            l << s(:js_tmp, "#{tmp}[#{idx}]")
+            raise "bad lhs for masgn: #{l.inspect}"
           end
-          code << process(l, :expr)
+
+          code << process(l)
         end
       end
 
@@ -1529,7 +1519,7 @@ module Opal
     end
 
     def process_svalue(sexp, level)
-      process sexp.shift, level
+      process sexp[0], level
     end
 
     # s(:lasgn, :lvar, rhs)
@@ -1539,15 +1529,15 @@ module Opal
       lvar = "#{lvar}$".to_sym if RESERVED.include? lvar.to_s
 
       if @irb_vars and @scope.top?
-        [fragment("Opal.irb_vars.#{lvar} = ", sexp), process(rhs, :expr)]
+        [f("$opal.irb_vars.#{lvar} = ", sexp), process(rhs)]
       else
         @scope.add_local lvar
-        rhs = process(rhs, :expr)
-        result =  [fragment(lvar, sexp), fragment(" = ", sexp), rhs]
+        rhs = process(rhs)
+        result =  [f(lvar, sexp), f(" = ", sexp), rhs]
 
         if level == :recv
-          result.unshift fragment("(", sexp)
-          result.push fragment(")", sexp)
+          result.unshift f("(", sexp)
+          result.push f(")", sexp)
         end
 
         result
@@ -1556,42 +1546,41 @@ module Opal
 
     # s(:lvar, :lvar)
     def process_lvar(sexp, level)
-      lvar = sexp.shift.to_s
+      lvar = sexp[0].to_s
       lvar = "#{lvar}$" if RESERVED.include? lvar
 
       if @irb_vars and @scope.top?
-        with_temp { |t| fragment("((#{t} = Opal.irb_vars.#{lvar}) == null ? nil : #{t})", sexp) }
+        with_temp { |t| f("((#{t} = $opal.irb_vars.#{lvar}) == null ? nil : #{t})", sexp) }
       else
-        fragment(lvar, sexp)
+        f(lvar, sexp)
       end
     end
 
     # s(:iasgn, :ivar, rhs)
     def process_iasgn(exp, level)
-      ivar = exp[0]
-      rhs = exp[1]
+      ivar, rhs = exp
       ivar = ivar.to_s[1..-1]
       lhs = RESERVED.include?(ivar) ? "#{current_self}['#{ivar}']" : "#{current_self}.#{ivar}"
-      [fragment(lhs, exp), fragment(" = ", exp), process(rhs, :expr)]
+      [f(lhs, exp), f(" = ", exp), process(rhs)]
     end
 
     # s(:ivar, :ivar)
     def process_ivar(exp, level)
-      ivar = exp.shift.to_s[1..-1]
+      ivar = exp[0].to_s[1..-1]
       part = RESERVED.include?(ivar) ? "['#{ivar}']" : ".#{ivar}"
       @scope.add_ivar part
-      fragment("#{current_self}#{part}", exp)
+      f("#{current_self}#{part}", exp)
     end
 
     # s(:gvar, gvar)
     def process_gvar(sexp, level)
-      gvar = sexp.shift.to_s[1..-1]
+      gvar = sexp[0].to_s[1..-1]
       @helpers['gvars'] = true
-      fragment("__gvars[#{gvar.inspect}]", sexp)
+      f("$gvars[#{gvar.inspect}]", sexp)
     end
 
     def process_nth_ref(sexp, level)
-      fragment("nil", sexp)
+      f("nil", sexp)
     end
 
     # s(:gasgn, :gvar, rhs)
@@ -1599,34 +1588,53 @@ module Opal
       gvar = sexp[0].to_s[1..-1]
       rhs  = sexp[1]
       @helpers['gvars'] = true
-      [fragment("__gvars[#{gvar.to_s.inspect}] = ", sexp), process(rhs, :expr)]
+      [f("$gvars[#{gvar.to_s.inspect}] = ", sexp), process(rhs)]
     end
 
     # s(:const, :const)
     def process_const(sexp, level)
-      cname = sexp.shift.to_s
+      cname = sexp[0].to_s
 
       if @const_missing
         with_temp do |t|
-          fragment("((#{t} = __scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})", sexp)
+          f("((#{t} = $scope.#{cname}) == null ? $opal.cm(#{cname.inspect}) : #{t})", sexp)
         end
       else
-        fragment("__scope.#{cname}", sexp)
+        f("$scope.#{cname}", sexp)
       end
     end
 
     # s(:cdecl, :const, rhs)
     def process_cdecl(sexp, level)
       const, rhs = sexp
-      [fragment("__scope.#{const} = ", sexp), process(rhs, :expr)]
+      [f("$scope.#{const} = ", sexp), process(rhs)]
+    end
+
+    # s(:casgn, s(:const, ::A), :B, val)
+    # A::B = 100
+    def process_casgn(sexp, level)
+      lhs, const, rhs = sexp
+      [process(lhs), f("._scope.#{const} = ", sexp), process(rhs)]
     end
 
     # s(:return [val])
     def process_return(sexp, level)
-      val = process(sexp.shift || s(:nil), :expr)
+      val = process(sexp[0] || s(:nil))
+
+      if @scope.iter? and parent_def = @scope.find_parent_def
+        parent_def.catch_return = true
+        [f("$opal.$return(", sexp), val, f(")", sexp)]
 
-      raise SyntaxError, "void value expression: cannot return as an expression" unless level == :stmt
-      [fragment("return ", sexp), val]
+      elsif level == :expr and @scope.def?
+        @scope.catch_return = true
+        [f("$opal.$return(", sexp), val, f(")", sexp)]
+
+      elsif level == :stmt
+        [f("return ", sexp), val]
+
+      else
+        raise SyntaxError, "void value expression: cannot return as an expression"
+      end
     end
 
     # s(:xstr, content)
@@ -1634,9 +1642,9 @@ module Opal
       code = sexp.first.to_s
       code += ";" if level == :stmt and !code.include?(';')
 
-      result = fragment(code, sexp)
+      result = f(code, sexp)
 
-      level == :recv ? [fragment("(", sexp), result, fragment(")", sexp)] : result
+      level == :recv ? [f("(", sexp), result, f(")", sexp)] : result
     end
 
     # s(:dxstr, parts...)
@@ -1646,22 +1654,22 @@ module Opal
 
       sexp.each do |p|
         if String === p
-          result << fragment(p.to_s, sexp)
+          result << f(p.to_s, sexp)
           needs_sc = true if level == :stmt and !p.to_s.include?(';')
         elsif p.first == :evstr
           result.push(*process(p.last, :stmt))
         elsif p.first == :str
-          result << fragment(p.last.to_s, p)
+          result << f(p.last.to_s, p)
           needs_sc = true if level == :stmt and !p.last.to_s.include?(';')
         else
           raise "Bad dxstr part"
         end
       end
 
-      result << fragment(";", sexp) if needs_sc
+      result << f(";", sexp) if needs_sc
 
       if level == :recv
-        [fragment("(", sexp), result, fragment(")", sexp)]
+        [f("(", sexp), result, f(")", sexp)]
       else
         result
       end
@@ -1672,22 +1680,22 @@ module Opal
       result = []
 
       sexp.each do |p|
-        result << fragment(" + ", sexp) unless result.empty?
+        result << f(" + ", sexp) unless result.empty?
         if String === p
-          result << fragment(p.inspect, sexp)
+          result << f(p.inspect, sexp)
         elsif p.first == :evstr
-          result << fragment("(", p)
-          result << process(p.last, :expr)
-          result << fragment(")", p)
+          result << f("(", p)
+          result << process(p.last)
+          result << f(")", p)
         elsif p.first == :str
-          result << fragment(p.last.inspect, p)
+          result << f(p.last.inspect, p)
         else
           raise "Bad dstr part"
         end
       end
 
       if level == :recv
-        [fragment("(", sexp), result, fragment(")", sexp)]
+        [f("(", sexp), result, f(")", sexp)]
       else
         result
       end
@@ -1697,20 +1705,20 @@ module Opal
       result = []
 
       sexp.each do |p|
-        result << fragment(" + ", sexp) unless result.empty?
+        result << f(" + ", sexp) unless result.empty?
 
         if String === p
-          result << fragment(p.inspect, sexp)
+          result << f(p.inspect, sexp)
         elsif p.first == :evstr
-          result << process(s(:call, p.last, :to_s, s(:arglist)), :expr)
+          result << process(s(:call, p.last, :to_s, s(:arglist)))
         elsif p.first == :str
-          result << fragment(p.last.inspect, sexp)
+          result << f(p.last.inspect, sexp)
         else
           raise "Bad dsym part"
         end
       end
 
-      [fragment("(", sexp), result, fragment(")", sexp)]
+      [f("(", sexp), result, f(")", sexp)]
     end
 
     # s(:if, test, truthy, falsy)
@@ -1732,18 +1740,18 @@ module Opal
         check = js_truthy test
       end
 
-      result = [fragment("if (", sexp), check, fragment(") {\n", sexp)]
+      result = [f("if (", sexp), check, f(") {\n", sexp)]
 
-      indent { result.push(fragment(@indent, sexp), process(truthy, :stmt)) } if truthy
+      indent { result.push(f(@indent, sexp), process(truthy, :stmt)) } if truthy
 
       outdent = @indent
-      indent { result.push(fragment("\n#{outdent}} else {\n#@indent", sexp), process(falsy, :stmt)) } if falsy
+      indent { result.push(f("\n#{outdent}} else {\n#@indent", sexp), process(falsy, :stmt)) } if falsy
 
-      result << fragment("\n#@indent}", sexp)
+      result << f("\n#@indent}", sexp)
 
       if returnable
-        result.unshift fragment("(function() { ", sexp)
-        result.push fragment("; return nil; }).call(#{current_self})", sexp)
+        result.unshift f("(function() { ", sexp)
+        result.push f("; return nil; }).call(#{current_self})", sexp)
       end
 
       result
@@ -1753,14 +1761,14 @@ module Opal
       if sexp.first == :call
         mid = sexp[2]
         if mid == :block_given?
-          return process sexp, :expr
+          return process sexp
         elsif COMPARE.include? mid.to_s
-          return process sexp, :expr
+          return process sexp
         elsif mid == :"=="
-          return process sexp, :expr
+          return process sexp
         end
       elsif [:lvar, :self].include? sexp.first
-        [process(sexp.dup, :expr), fragment(" !== false && ", sexp), process(sexp.dup, :expr), fragment(" !== nil", sexp)]
+        [process(sexp.dup), f(" !== false && ", sexp), process(sexp.dup), f(" !== nil", sexp)]
       end
     end
 
@@ -1770,7 +1778,7 @@ module Opal
       end
 
       with_temp do |tmp|
-        [fragment("(#{tmp} = ", sexp), process(sexp, :expr), fragment(") !== false && #{tmp} !== nil", sexp)]
+        [f("(#{tmp} = ", sexp), process(sexp), f(") !== false && #{tmp} !== nil", sexp)]
       end
     end
 
@@ -1784,9 +1792,9 @@ module Opal
 
       with_temp do |tmp|
         result = []
-        result << fragment("(#{tmp} = ", sexp)
-        result << process(sexp, :expr)
-        result << fragment(") === false || #{tmp} === nil", sexp)
+        result << f("(#{tmp} = ", sexp)
+        result << process(sexp)
+        result << f(") === false || #{tmp} === nil", sexp)
         result
       end
     end
@@ -1799,9 +1807,9 @@ module Opal
 
       if t = js_truthy_optimize(lhs)
         result = []
-        result << fragment("((#{tmp} = ", sexp) << t
-        result << fragment(") ? ", sexp) << process(rhs, :expr)
-        result << fragment(" : #{tmp})", sexp)
+        result << f("((#{tmp} = ", sexp) << t
+        result << f(") ? ", sexp) << process(rhs)
+        result << f(" : #{tmp})", sexp)
         @scope.queue_temp tmp
 
         return result
@@ -1809,19 +1817,18 @@ module Opal
 
       @scope.queue_temp tmp
 
-      [fragment("(#{tmp} = ", sexp), process(lhs, :expr), fragment(", #{tmp} !== false && #{tmp} !== nil ? ", sexp), process(rhs, :expr), fragment(" : #{tmp})", sexp)]
+      [f("(#{tmp} = ", sexp), process(lhs), f(", #{tmp} !== false && #{tmp} !== nil ? ", sexp), process(rhs), f(" : #{tmp})", sexp)]
 
     end
 
     # s(:or, lhs, rhs)
     def process_or(sexp, level)
-      lhs = sexp[0]
-      rhs = sexp[1]
+      lhs, rhs = sexp
 
       with_temp do |tmp|
-        lhs = process lhs, :expr
-        rhs = process rhs, :expr
-        [fragment("(((#{tmp} = ", sexp), lhs, fragment(") !== false && #{tmp} !== nil) ? #{tmp} : ", sexp), rhs, fragment(")", sexp)]
+        lhs = process lhs
+        rhs = process rhs
+        [f("(((#{tmp} = ", sexp), lhs, f(") !== false && #{tmp} !== nil) ? #{tmp} : ", sexp), rhs, f(")", sexp)]
       end
     end
 
@@ -1830,10 +1837,10 @@ module Opal
       call = handle_yield_call sexp, level
 
       if level == :stmt
-        [fragment("if (", sexp), call, fragment(" === __breaker) return __breaker.$v")]
+        [f("if (", sexp), call, f(" === $breaker) return $breaker.$v")]
       else
         with_temp do |tmp|
-          [fragment("(((#{tmp} = ", sexp), call, fragment(") === __breaker) ? __breaker.$v : #{tmp})", sexp)]
+          [f("(((#{tmp} = ", sexp), call, f(") === $breaker) ? $breaker.$v : #{tmp})", sexp)]
         end
       end
     end
@@ -1847,7 +1854,7 @@ module Opal
     def process_yasgn(sexp, level)
       call = handle_yield_call s(*sexp[1][1..-1]), :stmt
 
-      [fragment("if ((#{sexp[0]} = ", sexp), call, fragment(") === __breaker) return __breaker.$v", sexp)]
+      [f("if ((#{sexp[0]} = ", sexp), call, f(") === $breaker) return $breaker.$v", sexp)]
     end
 
     # Created by `#returns()` for when a yield statement should return
@@ -1856,8 +1863,8 @@ module Opal
       call = handle_yield_call sexp, level
 
       with_temp do |tmp|
-        [fragment("return #{tmp} = ", sexp), call,
-                    fragment(", #{tmp} === __breaker ? #{tmp} : #{tmp}")]
+        [f("return #{tmp} = ", sexp), call,
+                    f(", #{tmp} === $breaker ? #{tmp} : #{tmp}")]
       end
     end
 
@@ -1865,25 +1872,28 @@ module Opal
       @scope.uses_block!
 
       splat = sexp.any? { |s| s.first == :splat }
-      sexp.unshift s(:js_tmp, 'null') unless splat    # self
-      args = process_arglist sexp, level
 
-      y = @scope.block_name || '__yield'
+      if !splat and sexp.size == 1
+        return [f("$opal.$yield1(#{@scope.block_name || '$yield'}, "), process(sexp[0]), f(")")]
+      end
+
+      args = process_arglist sexp, level
+      y = @scope.block_name || '$yield'
 
       if splat
-        [fragment("#{y}.apply(null, ", sexp), args, fragment(")", sexp)]
+        [f("$opal.$yieldX(#{y}, ", sexp), args, f(")")]
       else
-        [fragment("#{y}.call(", sexp), args, fragment(")", sexp)]
+        [f("$opal.$yieldX(#{y}, [", sexp), args, f("])")]
       end
     end
 
     def process_break(sexp, level)
-      val = sexp.empty? ? fragment('nil', sexp) : process(sexp.shift, :expr)
+      val = sexp.empty? ? f('nil', sexp) : process(sexp[0])
       if in_while?
-        @while_loop[:closure] ? [fragment("return ", sexp), val, fragment("", sexp)] : fragment("break;", sexp)
+        @while_loop[:closure] ? [f("return ", sexp), val, f("", sexp)] : f("break;", sexp)
       elsif @scope.iter?
         error "break must be used as a statement" unless level == :stmt
-        [fragment("return (__breaker.$v = ", sexp), val, fragment(", __breaker)", sexp)]
+        [f("return ($breaker.$v = ", sexp), val, f(", $breaker)", sexp)]
       else
         error "void value expression: cannot use break outside of iter/while"
       end
@@ -1891,37 +1901,41 @@ module Opal
 
     # s(:case, expr, when1, when2, ..)
     def process_case(exp, level)
-      pre = []
-      code = []
-      @scope.add_local "$case"
-      expr = process exp.shift, :expr
+      pre, code = [], []
+
       # are we inside a statement_closure
       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)
-          code << fragment("else ", exp) unless code.empty?
-          code << wen
-        elsif wen # s(:else)
-          done_else = true
-          wen = returns(wen) if returnable
-          code << fragment("else {", exp) << process(wen, :stmt) << fragment("}", exp)
+      in_case do
+        if cond = exp[0]
+          @case_stmt[:cond] = true
+          @scope.add_local "$case"
+          expr = process cond
+          pre << f("$case = ", exp) << expr << f(";", exp)
+        end
+
+        exp[1..-1].each do |wen|
+          if wen and wen.first == :when
+            returns(wen) if returnable
+            wen = process(wen, :stmt)
+            code << f("else ", exp) unless code.empty?
+            code << wen
+          elsif wen # s(:else)
+            done_else = true
+            wen = returns(wen) if returnable
+            code << f("else {", exp) << process(wen, :stmt) << f("}", exp)
+          end
         end
       end
 
-      code << fragment("else { return nil }", exp) if returnable and !done_else
+      code << f("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)
+        code.unshift f("(function() { ", exp)
+        code << f(" }).call(#{current_self})", exp)
       end
 
       code
@@ -1932,43 +1946,41 @@ module Opal
     #
     # s(:when, s(:array, foo), bar)
     def process_when(exp, level)
-      arg = exp.shift[1..-1]
-      body = exp.shift || s(:nil)
-      #body = process body, level if body
+      arg = exp[0][1..-1]
+      body = exp[1] || s(:nil)
       body = process body, level
 
       test = []
-      until arg.empty?
-        test << fragment(" || ", exp) unless test.empty?
-        a = arg.shift
+      arg.each do |a|
+        test << f(" || ") unless test.empty?
 
         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 = [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)
+          call = f("$splt[i]['$===']($case)", a)
+
+          splt = [f("(function($splt) { for(var i = 0; i < $splt.length; i++) {", exp)]
+          splt << f("if (") << call << f(") { return true; }", exp)
+          splt << f("} return false; }).call(#{current_self}, ", exp)
+          splt << process(a[1]) << f(")")
 
           test << splt
         else
-          call = s(:call, a, :===, s(:arglist, s(:js_tmp, "$case")))
-          call = process call, :expr
-
-          test << call
+          if @case_stmt[:cond]
+            call = s(:call, a, :===, s(:arglist, s(:js_tmp, "$case")))
+            test << process(call)
+          else
+            test << js_truthy(a)
+          end
         end
       end
 
-      [fragment("if (", exp), test, fragment(") {#@space", exp), body, fragment("#@space}", exp)]
+      [f("if ("), test, f(") {#@space"), body, f("#@space}")]
     end
 
     # lhs =~ rhs
     #
-    # s(:match3, lhs, rhs)
+    # s(:match3, lhs, rhs) # => s(:call, lhs, :=~, s(:arglist, rhs))
     def process_match3(sexp, level)
-      lhs = sexp[0]
-      rhs = sexp[1]
-      call = s(:call, lhs, :=~, s(:arglist, rhs))
-      process call, level
+      process s(:call, sexp[0], :=~, s(:arglist, sexp[1])), level
     end
 
     # @@class_variable
@@ -1976,8 +1988,7 @@ module Opal
     # s(:cvar, name)
     def process_cvar(exp, level)
       with_temp do |tmp|
-        fragment(("((%s = Opal.cvars[%s]) == null ? nil : %s)" %
-          [tmp, exp.shift.to_s.inspect, tmp]), exp)
+        f("((#{tmp} = $opal.cvars['#{exp[0]}']) == null ? nil : #{tmp})", exp)
       end
     end
 
@@ -1985,41 +1996,39 @@ module Opal
     #
     # s(:cvasgn, :@@name, rhs)
     def process_cvasgn(exp, level)
-      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expr})"
+      "($opal.cvars['#{exp[0]}'] = #{process exp[1]})"
     end
 
+    # s(:cvdecl, :@@foo, value) # => ($opal.cvars['@@foo'] = value)
     def process_cvdecl(exp, level)
-      [fragment("(Opal.cvars[#{exp.shift.to_s.inspect}] = ", exp), process(exp.shift, :expr), fragment(")", exp)]
+      [f("($opal.cvars['#{exp[0]}'] = ", exp), process(exp[1]), f(")", exp)]
     end
 
     # BASE::NAME
     #
     # s(:colon2, base, :NAME)
     def process_colon2(sexp, level)
-      base = sexp[0]
-      cname = sexp[1].to_s
+      base, cname = sexp
       result = []
 
       if @const_missing
         with_temp do |t|
-          base = process base, :expr
+          base = process base
 
-          result << fragment("((#{t} = (", sexp) << base << fragment(")._scope).", sexp)
-          result << fragment("#{cname} == null ? #{t}.cm(#{cname.inspect}) : #{t}.#{cname})", sexp)
+          result << f("((#{t} = (", sexp) << base << f(")._scope).", sexp)
+          result << f("#{cname} == null ? #{t}.cm('#{cname}') : #{t}.#{cname})", sexp)
         end
       else
-        base = process base, :expr
-
-        result <<  fragment("(", sexp) << base << fragment(")._scope.#{cname}", sexp)
+        result << f("(", sexp) << process(base) << f(")._scope.#{cname}", sexp)
       end
 
       result
     end
 
+    # s(:colon3, :CONST_NAME) # => $opal.Object._scope.CONST_NAME
     def process_colon3(exp, level)
       with_temp do |t|
-        cname = exp.shift.to_s
-        fragment("((#{t} = __opal.Object._scope.#{cname}) == null ? __opal.cm(#{cname.inspect}) : #{t})", exp)
+        f("((#{t} = $opal.Object._scope.#{exp[0]}) == null ? $opal.cm('#{exp[0]}') : #{t})", exp)
       end
     end
 
@@ -2028,46 +2037,68 @@ module Opal
     # s(:super, arg1, arg2, ...)
     def process_super(sexp, level)
       args = []
-      until sexp.empty?
-        args << fragment(", ", sexp) unless args.empty?
-        args << process(sexp.shift, :expr)
+      sexp.each do |part|
+        args << f(", ", sexp) unless args.empty?
+        args << process(part)
       end
 
-      js_super [fragment("[", sexp), args, fragment("]", sexp)], sexp
+      js_super [f("[", sexp), args, f("]", sexp)], false, sexp
     end
 
     # super
     #
     # s(:zsuper)
     def process_zsuper(exp, level)
-      js_super fragment("__slice.call(arguments)", exp), exp
+      if @scope.def?
+        @scope.uses_zuper = true
+        js_super f("$zuper", exp), true, exp
+      else
+        js_super f("$slice.call(arguments)", exp), true, exp
+      end
     end
 
-    def js_super args, sexp
+    def js_super args, pass_block, sexp
       if @scope.def_in_class?
+        @scope.uses_block!
         mid = @scope.mid.to_s
-        sid = "super_#{unique_temp}"
 
-        @scope.uses_super = sid
+        if @scope.uses_super
+          sid = @scope.uses_super
+        else
+          sid = @scope.uses_super = "super_#{unique_temp}"
+        end
 
+        if pass_block
+          @scope.uses_block!
+          [f("(#{sid}._p = $iter, #{sid}.apply(#{current_self}, ", sexp), args, f("))", sexp)]
+        else
+          [f("#{sid}.apply(#{current_self}, ", sexp), args, f(")", sexp)]
+        end
 
-        [fragment("#{sid}.apply(#{current_self}, ", sexp), args, fragment(")", sexp)]
 
       elsif @scope.type == :def
+        @scope.uses_block!
         @scope.identify!
         cls_name = @scope.parent.name || "#{current_self}._klass._proto"
         jsid     = mid_to_jsid @scope.mid.to_s
 
+        if pass_block
+          @scope.uses_block!
+          iter = "$iter"
+        else
+          iter = "null"
+        end
+
         if @scope.defs
-          [fragment(("%s._super%s.apply(this, " % [cls_name, jsid]), sexp), args, fragment(")", sexp)]
+          [f("$opal.dispatch_super(this, #{@scope.mid.to_s.inspect},", sexp), args, f(", #{iter}, #{cls_name})", sexp)]
         else
-          [fragment("#{current_self}._klass._super._proto#{jsid}.apply(#{current_self}, ", sexp), args, fragment(")", sexp)]
+          [f("$opal.dispatch_super(#{current_self}, #{@scope.mid.to_s.inspect}, ", sexp), args, f(", #{iter})", sexp)]
         end
 
       elsif @scope.type == :iter
         chain, defn, mid = @scope.get_super_chain
         trys = chain.map { |c| "#{c}._sup" }.join ' || '
-        [fragment("(#{trys} || #{current_self}._klass._super._proto[#{mid}]).apply(#{current_self}, ", sexp), args, fragment(")", sexp)]
+        [f("(#{trys} || #{current_self}._klass._super._proto[#{mid}]).apply(#{current_self}, ", sexp), args, f(")", sexp)]
       else
         raise "Cannot call super() from outside a method block"
       end
@@ -2077,14 +2108,14 @@ module Opal
     #
     # s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, rhs))
     def process_op_asgn_or(exp, level)
-      process s(:or, exp.shift, exp.shift), :expr
+      process s(:or, exp[0], exp[1])
     end
 
     # a &&= rhs
     #
     # s(:op_asgn_and, s(:lvar, :a), s(:lasgn, :a, rhs))
     def process_op_asgn_and(sexp, level)
-      process s(:and, sexp.shift, sexp.shift), :expr
+      process s(:and, sexp[0], sexp[1])
     end
 
     # lhs[args] ||= rhs
@@ -2095,17 +2126,17 @@ module Opal
 
       with_temp do |a| # args
         with_temp do |r| # recv
-          args = process arglist[1], :expr
-          recv = process lhs, :expr
+          args = process arglist[1]
+          recv = process lhs
 
           aref = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
           aset = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
           orop = s(:or, aref, aset)
 
           result = []
-          result << fragment("(#{a} = ", sexp) << args << fragment(", #{r} = ", sexp)
-          result << recv << fragment(", ", sexp) << process(orop, :expr)
-          result << fragment(")", sexp)
+          result << f("(#{a} = ", sexp) << args << f(", #{r} = ", sexp)
+          result << recv << f(", ", sexp) << process(orop)
+          result << f(")", sexp)
           result
         end
       end
@@ -2115,10 +2146,10 @@ module Opal
     #
     # s(:op_asgn2, lhs, :b=, :+, rhs)
     def process_op_asgn2(sexp, level)
-      lhs = process sexp.shift, :expr
-      mid = sexp.shift.to_s[0..-2]
-      op  = sexp.shift
-      rhs = sexp.shift
+      lhs = process sexp[0]
+      mid = sexp[1].to_s[0..-2]
+      op  = sexp[2]
+      rhs = sexp[3]
 
       if op.to_s == "||"
         with_temp do |temp|
@@ -2126,7 +2157,7 @@ module Opal
           asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, rhs))
           orop = s(:or, getr, asgn)
 
-          [fragment("(#{temp} = ", sexp), lhs, fragment(", ", sexp), process(orop, :expr), fragment(")", sexp)]
+          [f("(#{temp} = ", sexp), lhs, f(", ", sexp), process(orop), f(")", sexp)]
         end
       elsif op.to_s == '&&'
         with_temp do |temp|
@@ -2134,7 +2165,7 @@ module Opal
           asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, rhs))
           andop = s(:and, getr, asgn)
 
-          [fragment("(#{temp} = ", sexp), lhs, fragment(", ", sexp), process(andop, :expr), fragment(")", sexp)]
+          [f("(#{temp} = ", sexp), lhs, f(", ", sexp), process(andop), f(")", sexp)]
         end
       else
         with_temp do |temp|
@@ -2142,14 +2173,14 @@ module Opal
           oper = s(:call, getr, op, s(:arglist, rhs))
           asgn = s(:call, s(:js_tmp, temp), "#{mid}=", s(:arglist, oper))
 
-          [fragment("(#{temp} = ", sexp), lhs, fragment(", ", sexp), process(asgn, :expr), fragment(")", sexp)]
+          [f("(#{temp} = ", sexp), lhs, f(", ", sexp), process(asgn), f(")", sexp)]
         end
       end
     end
 
     # s(:ensure, body, ensure)
     def process_ensure(exp, level)
-      begn = exp.shift
+      begn = exp[0]
       if level == :recv || level == :expr
         retn = true
         begn = returns begn
@@ -2157,49 +2188,49 @@ module Opal
 
       result = []
       body = process begn, level
-      ensr = exp.shift || s(:nil)
+      ensr = exp[1] || s(:nil)
       ensr = process ensr, level
 
-      body = [fragment("try {\n", exp), body, fragment("}", exp)]
+      body = [f("try {\n", exp), body, f("}", exp)]
 
-      result << body << fragment("#{@space}finally {#@space", exp) << ensr << fragment("}", exp)
+      result << body << f("#{@space}finally {#@space", exp) << ensr << f("}", exp)
 
       if retn
-        [fragment("(function() { ", exp), result, fragment("; }).call(#{current_self})", exp)]
+        [f("(function() { ", exp), result, f("; }).call(#{current_self})", exp)]
       else
         result
       end
     end
 
     def process_rescue(exp, level)
-      body = exp.first.first == :resbody ? s(:nil) : exp.shift
+      body = exp.first.first == :resbody ? s(:nil) : exp[0]
       body = indent { process body, level }
       handled_else = false
 
       parts = []
-      until exp.empty?
-        handled_else = true unless exp.first.first == :resbody
-        part = indent { process exp.shift, level }
+      exp[1..-1].each do |a|
+        handled_else = true unless a.first == :resbody
+        part = indent { process a, level }
 
         unless parts.empty?
-          parts << fragment("else ", exp)
+          parts << f("else ", exp)
         end
 
         parts << part
       end
       # if no rescue statement captures our error, we should rethrow
-      parts << indent { fragment("else { throw $err; }", exp) } unless handled_else
+      parts << indent { f("else { throw $err; }", exp) } unless handled_else
 
       code = []
-      code << fragment("try {#@space#{INDENT}", exp)
+      code << f("try {#@space#{INDENT}", exp)
       code << body
-      code << fragment("#@space} catch ($err) {#@space", exp)
+      code << f("#@space} catch ($err) {#@space", exp)
       code << parts
-      code << fragment("#@space}", exp)
+      code << f("#@space}", exp)
 
       if level == :expr
-        code.unshift fragment("(function() { ", exp)
-        code << fragment(" }).call(#{current_self})", exp)
+        code.unshift f("(function() { ", exp)
+        code << f(" }).call(#{current_self})", exp)
       end
 
       code
@@ -2215,49 +2246,52 @@ module Opal
 
       err = []
       types.each do |t|
-        err << fragment(", ", exp) unless err.empty?
+        err << f(", ", exp) unless err.empty?
         call = s(:call, t, :===, s(:arglist, s(:js_tmp, "$err")))
-        a = process call, :expr
+        a = process call
         err << a
       end
-      err << fragment("true", exp) if err.empty?
+      err << f("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) , fragment(";", exp)]
+        val = [process(val) , f(";", exp)]
       end
 
       val = [] unless val
 
-      [fragment("if (", exp), err, fragment("){#@space", exp), val, body, fragment("}", exp)]
+      [f("if (", exp), err, f("){#@space", exp), val, body, f("}", exp)]
     end
 
     # FIXME: Hack.. grammar should remove top level begin.
     def process_begin(exp, level)
-      result = process exp[0], level
+      process exp[0], level
     end
 
     def process_next(exp, level)
       if in_while?
-        fragment("continue;", exp)
+        f("continue;", exp)
       else
         result = []
-        result << fragment("return ", exp)
+        result << f("return ", exp)
 
-        result << (exp.empty? ? fragment('nil', exp) : process(exp.shift, :expr))
-        result << fragment(";", exp)
+        result << (exp.empty? ? f('nil', exp) : process(exp[0]))
+        result << f(";", exp)
 
         result
       end
     end
 
+    # s(:redo) # => $redo_var = true
+    # Only currently supported inside while loops. Simply sets the redo variable
+    # for the loop to true.
     def process_redo(exp, level)
       if in_while?
         @while_loop[:use_redo] = true
-        fragment("#{@while_loop[:redo_var]} = true", exp)
+        f("#{@while_loop[:redo_var]} = true", exp)
       else
-        fragment("REDO()", exp)
+        f("REDO()", exp)
       end
     end
   end