opal 0.3.18 → 0.3.19

data/lib/opal/grammar.y

@@ -14,7 +14,7 @@ token CLASS MODULE DEF UNDEF BEGIN RESCUE ENSURE END IF UNLESS
       '~' '%' '/' '+' '-' '<' '>' '|' '!' '^'
       LCURLY '}' BACK_REF2 SYMBOL_BEG STRING_BEG XSTRING_BEG REGEXP_BEG
       WORDS_BEG AWORDS_BEG STRING_DBEG STRING_DVAR STRING_END STRING
-      SYMBOL '\\n' '?' ':' ',' SPACE ';' LABEL
+      SYMBOL '\\n' '?' ':' ',' SPACE ';' LABEL LAMBDA LAMBEG DO_LAMBDA
 
 prechigh
   right    '!' '~' '+@'
@@ -453,19 +453,19 @@ arg:
     }
   | arg '+' arg
     {
-      result = new_call val[0], :"+", s(:arglist, val[2])
+      result = s(:operator, :"+", val[0], val[2])
     }
   | arg '-' arg
     {
-      result = new_call val[0], :"-", s(:arglist, val[2])
+      result = s(:operator, :"-", val[0], val[2])
     }
   | arg '*' arg
     {
-      result = new_call val[0], :"*", s(:arglist, val[2])
+      result = s(:operator, :"*", val[0], val[2])
     }
   | arg '/' arg
     {
-      result = new_call val[0], :"/", s(:arglist, val[2])
+      result = s(:operator, :"/", val[0], val[2])
     }
   | arg '%' arg
     {
@@ -784,6 +784,10 @@ primary:
       result = val[1]
       result[1] = val[0]
     }
+  | LAMBDA lambda
+    {
+      result = val[1]
+    }
   | IF expr_value then compstmt if_tail END
     {
       result = new_if val[1], val[3], val[4]
@@ -937,6 +941,35 @@ do:
   | ':'
   | DO_COND
 
+lambda:
+    f_larglist lambda_body
+    {
+      call = new_call nil, :lambda, s(:arglist)
+      result = new_iter call, val[0], val[1]
+    }
+
+f_larglist:
+    '(' block_var_args ')'
+    {
+      result = val[1]
+    }
+  | '(' ')'
+    {
+      result = nil
+    }
+  | block_var_args
+  | none
+
+lambda_body:
+    LAMBEG compstmt '}'
+    {
+      result = val[1]
+    }
+  | DO_LAMBDA compstmt END
+    {
+      result = val[1]
+    }
+
 if_tail:
     opt_else
     {

data/lib/opal/lexer.rb

@@ -617,6 +617,8 @@ module Opal
         else
           c = if scanner.scan(/n/)
             "\n"
+          elsif scanner.scan(/r/)
+            "\r"
           else
             # escaped char doesnt need escaping, so just return it
             scanner.scan(/./)
@@ -985,6 +987,11 @@ module Opal
           return '>', '>'
         end
 
+      elsif scanner.scan(/->/)
+        @lex_state = :expr_arg
+        @start_of_lambda = true
+        return [:LAMBDA, scanner.matched]
+
       elsif scanner.scan(/[+-]/)
         result  = scanner.matched
         sign    = result + '@'
@@ -1110,7 +1117,12 @@ module Opal
         return ',', scanner.matched
 
       elsif scanner.scan(/\{/)
-        if [:expr_end, :expr_arg, :expr_cmdarg].include? @lex_state
+        if @start_of_lambda
+          @start_of_lambda = false
+          @lex_state = :expr_beg
+          return [:LAMBEG, scanner.matched]
+
+        elsif [:expr_end, :expr_arg, :expr_cmdarg].include? @lex_state
           result = :LCURLY
         elsif @lex_state == :expr_endarg
           result = :LBRACE_ARG
@@ -1183,7 +1195,11 @@ module Opal
           #puts cond?
           #puts cmdarg?
           #nputs @lex_state
-          if cond?
+          if @start_of_lambda
+            @start_of_lambda = false
+            @lex_state = :expr_beg
+            return [:DO_LAMBDA, scanner.matched]
+          elsif cond?
             @lex_state = :expr_beg
             return :DO_COND, matched
           elsif cmdarg? && @lex_state != :expr_cmdarg

data/lib/opal/parser.rb

@@ -13,16 +13,9 @@ module Opal
   class Parser
     INDENT = '  '
 
-    LEVEL = [:statement, :statement_closure, :list, :expression, :receiver]
+    LEVEL = [:stmt, :stmt_closure, :list, :expr, :recv]
 
-    # Maths operators
-    MATH = %w(+ - / * %)
-
-    # Comparison operators
-    COMPARE = %w(< <= > >=)
-
-    # All Operators that can be optimized in method calls
-    CALL_OPERATORS = MATH + COMPARE
+    COMPARE = %w[< > <= >=]
 
     # Reserved javascript keywords - we cannot create variables with the
     # same name
@@ -60,25 +53,40 @@ module Opal
       :**  => 'pow'
     }
 
-    # Type info for flags of objects. This helps identify the type of object
-    # being dealt with
-    TYPES = {
-      class:     0x0001,
-      module:    0x0002,
-      object:    0x0004,
-      boolean:   0x0008,
-      string:    0x0010,
-      array:     0x0020,
-      number:    0x0040,
-      proc:      0x0080,
-      hash:      0x0100,
-      range:     0x0200,
-      iclass:    0x0400,
-      singleton: 0x0800
-    }
-
     STATEMENTS = [:xstr, :dxstr]
 
+    DEBUG_CODE = <<-CODE
+      var __const_get = function(const_table, id) {
+        if (const_table && const_table[id]) {
+          return const_table[id];
+        }
+
+        throw new Error('uninitialized constant ' + id);
+      };
+
+      var __send = function(recv, mid, jsid, block) {
+        var args = Array.prototype.slice.call(arguments, 4);
+
+        if (recv == null) {
+          throw new Error("cannot send '" + mid + "' to null");
+        }
+
+        var func = recv[jsid];
+
+        if (!func) {
+          throw new Error(recv + " does not respond to '" + mid + "'");
+        }
+
+        func._p = block;
+
+        return func.apply(recv, args);
+      };
+
+      var __send_splat = function(recv, mid, jsid, block, splat) {
+        return __send.apply(null, [recv, mid, jsid, block].concat(splat));
+      };
+    CODE
+
     attr_reader :grammar
 
     def self.parse(str)
@@ -90,13 +98,10 @@ module Opal
     end
 
     def parse(source, file = '(file)')
-      @file = file
-      @helpers = {
+      @file     = file
+      @helpers  = {
         :breaker   => true,
-        :klass     => true,
-        :const_get => true,
         :slice     => true
-        # :nil       => true
       }
 
       @grammar = Grammar.new
@@ -104,6 +109,14 @@ module Opal
       top @grammar.parse(source, file)
     end
 
+    def raise(msg)
+      super "#{msg} :#{@file}:#{@line}"
+    end
+
+    def parser_indent
+      @indent
+    end
+
     def s(*parts)
       sexp = parts
       sexp.line = @line
@@ -126,7 +139,7 @@ module Opal
 
     # guaranteed unique id per file..
     def unique_temp
-      "$TMP_#{@unique += 1}"
+      "TMP_#{@unique += 1}"
     end
 
     def top(sexp, options = {})
@@ -135,30 +148,30 @@ module Opal
 
       in_scope(:top) do
         indent {
-          code = @indent + process(s(:scope, sexp), :statement)
+          code = @indent + process(s(:scope, sexp), :stmt)
         }
 
-        vars << "__scope = Opal.constants"
-        vars << "nil = Opal.nil"
-        # vars.concat @scope.locals.map { |t| "#{t}" }
-        # vars.concat @scope.temps.map { |t| t }
-        vars.concat @helpers.keys.map { |h| "__#{h} = Opal.#{h}" }
+        vars << "__opal = Opal"
+        vars << "__scope = __opal"
+        vars << "nil = __opal.nil"
+        vars.concat @helpers.keys.map { |h| "__#{h} = __opal.#{h}" }
 
         code = "var #{vars.join ', '};\n" + @scope.to_vars + "\n" + code
       end
 
-      pre  = "(function() {\n"
+      pre  = "function() {\n"
       post = ""
 
+      pre += DEBUG_CODE if @debug
       uniques = []
 
-      @unique.times { |i| uniques << "$TMP_#{i+1}" }
+      @unique.times { |i| uniques << "TMP_#{i+1}" }
 
       unless uniques.empty?
         post += ";var #{uniques.join ', '};"
       end
 
-      post += "\n}).call(Opal.top);\n"
+      post += "\n}"
 
       pre + code + post
     end
@@ -203,13 +216,11 @@ module Opal
     end
 
     def process(sexp, level)
-      # puts "PROCESS: (#{level})"
-      # puts "  #{sexp.inspect}"
       type = sexp.shift
+      meth = "process_#{type}"
+      raise "Unsupported sexp: #{type}" unless respond_to? meth
 
-      raise "Unsupported sexp: #{type}" unless respond_to? type
-
-      __send__ type, sexp, level
+      __send__ meth, sexp, level
     end
 
     def returns(sexp)
@@ -259,7 +270,7 @@ module Opal
       !STATEMENTS.include?(sexp.first)
     end
 
-    def block(sexp, level)
+    def process_block(sexp, level)
       result = []
       sexp << s(:nil) if sexp.empty?
 
@@ -273,58 +284,56 @@ module Opal
       result.join "\n#@indent"
     end
 
-    def scope(sexp, level)
+    def process_scope(sexp, level)
       stmt = sexp.shift
-      stmt = returns stmt unless @scope.donates_methods
-      code = process stmt, :statement
+      if stmt
+        stmt = returns stmt unless @scope.donates_methods
+        code = process stmt, :stmt
+      else
+        code = "nil"
+      end
 
       code
     end
 
     # s(:js_return, sexp)
-    def js_return(sexp, level)
-      "return #{process sexp.shift, :expression}"
+    def process_js_return(sexp, level)
+      "return #{process sexp.shift, :expr}"
     end
 
     # s(:js_tmp, str)
-    def js_tmp(sexp, level)
+    def process_js_tmp(sexp, level)
       sexp.shift.to_s
     end
 
-    def js_operator_call(sexp, level)
-      recv = sexp[0]
-      meth = sexp[1]
-      arglist = sexp[2]
+    def process_operator(sexp, level)
+      meth, recv, arg = sexp
       mid = mid_to_jsid meth.to_s
 
       a = @scope.new_temp
       b = @scope.new_temp
-      l  = process recv, :expression
-      r  = process arglist[1], :expression
-
-      res = "(#{a} = #{l}, #{b} = #{r}, typeof(#{a}) === "
-      res += "'number' ? #{a} #{meth} #{b} : #{a}.#{mid}"
-      res += "(#{b}))"
+      l  = process recv, :expr
+      r  = process arg, :expr
 
       @scope.queue_temp a
       @scope.queue_temp b
 
-      res
+      "(%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]
     end
 
-    # s(:js_block_given)
     def js_block_given(sexp, level)
       @scope.uses_block!
-      "!!#{@scope.block_name}"
+      "(#{@scope.block_name} !== nil)"
     end
 
     # s(:lit, 1)
     # s(:lit, :foo)
-    def lit(sexp, level)
+    def process_lit(sexp, level)
       val = sexp.shift
       case val
       when Numeric
-        level == :receiver ? "(#{val.inspect})" : val.inspect
+        level == :recv ? "(#{val.inspect})" : val.inspect
       when Symbol
         val.to_s.inspect
       when Regexp
@@ -337,32 +346,36 @@ module Opal
       end
     end
 
-    def dregx(sexp, level)
+    def process_dregx(sexp, level)
       parts = sexp.map do |part|
         if String === part
           part.inspect
         elsif part[0] == :str
-          process part, :expression
+          process part, :expr
         else
-          process part[1], :expression
+          process part[1], :expr
         end
       end
 
       "(new RegExp(#{parts.join ' + '}))"
     end
 
-    def dot2(sexp, level)
+    def process_dot2(sexp, level)
+      lhs = process sexp[0], :expr
+      rhs = process sexp[1], :expr
       @helpers[:range] = true
-      "__range(#{process sexp[0], :expression}, #{process sexp[1], :expression}, false)"
+      "__range(%s, %s, false)" % [lhs, rhs]
     end
 
-    def dot3(sexp, level)
+    def process_dot3(sexp, level)
+      lhs = process sexp[0], :expr
+      rhs = process sexp[1], :expr
       @helpers[:range] = true
-      "__range(#{process sexp[0], :expression}, #{process sexp[1], :expression}, true)"
+      "__range(%s, %s, true)" % [lhs, rhs]
     end
 
     # s(:str, "string")
-    def str(sexp, level)
+    def process_str(sexp, level)
       str = sexp.shift
       if str == @file
         @uses_file = true
@@ -372,7 +385,7 @@ module Opal
       end
     end
 
-    def defined(sexp, level)
+    def process_defined(sexp, level)
       part = sexp[0]
       case part[0]
       when :self
@@ -385,7 +398,7 @@ module Opal
         "false".inspect
       when :call
         mid = mid_to_jsid part[2].to_s
-        recv = part[1] ? process(part[1], :expression) : 'this'
+        recv = part[1] ? process(part[1], :expr) : 'this'
         "(#{recv}.#{mid} ? 'method' : nil)"
       else
         raise "bad defined? part: #{part[0]}"
@@ -393,30 +406,18 @@ module Opal
     end
 
     # s(:not, sexp)
-    def not(sexp, level)
-      code = "!#{process sexp.shift, :expression}"
+    def process_not(sexp, level)
+      code = "!#{process sexp.shift, :expr}"
       code
     end
 
-    def block_pass(exp, level)
-      pass = process exp.shift, level
-      return "(#{pass} || function(){})" 
-      tmp = @scope.new_temp
-
-      to_proc = process(s(:call, s(:js_tmp, tmp), :to_proc, s(:arglist)), :expression)
-
-      code = "(#{tmp} = #{pass}, (typeof(#{tmp}) === 'function' || #{tmp} == null ? #{tmp} : #{to_proc}))"
-
-      @scope.queue_temp tmp
-
-      code
+    def process_block_pass(exp, level)
+      process(s(:call, exp.shift, :to_proc, s(:arglist)), :expr)
     end
 
     # s(:iter, call, block_args [, body)
-    def iter(sexp, level)
-      call = sexp[0]
-      args = sexp[1]
-      body = sexp[2]
+    def process_iter(sexp, level)
+      call, args, body = sexp
 
       body ||= s(:nil)
       body = returns body
@@ -460,7 +461,7 @@ module Opal
             code += "var #{block_arg} = _$ || nil, $context = #{block_arg}.$S;"
           end
 
-          code += "\n#@indent" + process(body, :statement)
+          code += "\n#@indent" + process(body, :stmt)
 
           code = "\n#@indent#{@scope.to_vars}\n#@indent#{code}"
 
@@ -468,11 +469,17 @@ module Opal
         end
       end
 
+      tmp = @scope.new_temp
+
       itercode = "function(#{params.join ', '}) {\n#{code}\n#@indent}"
       itercode = "#{scope_name} = #{itercode}" if scope_name
-      call << itercode
 
-      process call, level
+      call << ("(%s = %s, %s._s = this, %s)" % [tmp, itercode, tmp, tmp])
+
+      res = process call, level
+      @scope.queue_temp tmp
+
+      res
     end
 
     def js_block_args(sexp)
@@ -488,8 +495,7 @@ module Opal
     # recv.mid = rhs
     #
     # s(recv, :mid=, s(:arglist, rhs))
-
-    def attrasgn(exp, level)
+    def process_attrasgn(exp, level)
       recv = exp[0]
       mid = exp[1]
       arglist = exp[2]
@@ -497,35 +503,69 @@ module Opal
       return process(s(:call, recv, mid, arglist), level)
     end
 
-    # s(:math_op, :op, lhs, rhs)
-    def math_op(exp, level)
-      op  = exp[0]
-      lhs = exp[1]
-      rhs = exp[2]
+    # 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(:lit) or s(:str)
+    # @return [String] precompiled attr methods
+    def attr_optimize(meth, attrs)
+      out = []
+
+      attrs.each do |attr|
+        ivar = attr[1].to_s
+
+        unless meth == :attr_writer
+          attr = mid_to_jsid ivar
+          check = "this.#{ivar} == null ? nil : this.#{ivar}"
+          out << "def.#{attr} = function() { return #{check}; }"
+        end
+
+        unless meth == :attr_reader
+          attr = mid_to_jsid "#{ivar}="
+          out << "def.#{attr} = function(val) { return this.#{ivar} = val }"
+        end
+      end
 
-      "#{process lhs, level} #{op} #{process rhs, level}"
+      out.join ", \n#@indent"
     end
 
     # s(:call, recv, :mid, s(:arglist))
     # s(:call, nil, :mid, s(:arglist))
-    def call(sexp, level)
-      recv = sexp[0]
-      meth = sexp[1]
-      arglist = sexp[2]
-      iter = sexp[3]
-
+    def process_call(sexp, level)
+      recv, meth, arglist, iter = sexp
       mid = mid_to_jsid meth.to_s
 
-      return js_operator_call(sexp, level) if CALL_OPERATORS.include? meth.to_s
-      return js_block_given(sexp, level) if meth == :block_given?
+      case meth
+      when :attr_reader, :attr_writer, :attr_accessor
+        attrs = arglist[1..-1]
+        if @scope.class_scope? && attrs.all? { |a| [:lit, :str].include? a.first }
+          return attr_optimize meth, attrs
+        end
+      when :block_given?
+        return js_block_given(sexp, level)
+      when :require
+        # path = arglist[1]
+
+        # if path and path[0] == :str
+        #   path_name = path[1].sub(/^opal\//, '')
+        #   @requires << path_name
+        #   return "nil"
+        # else
+        #   raise "Opal cannot do dynamic requires"
+        # end
+      end
 
       splat = arglist[1..-1].any? { |a| a.first == :splat }
 
       if Array === arglist.last and arglist.last.first == :block_pass
-        tmpmeth = @scope.new_temp
-        block   = process s(:js_tmp, process(arglist.pop, :expression)), :expression
+        block   = process s(:js_tmp, process(arglist.pop, :expr)), :expr
       elsif iter
-        tmpmeth = @scope.new_temp
         block   = iter
       end
 
@@ -537,22 +577,22 @@ module Opal
         tmprecv = @scope.new_temp
       end
       
-      recv_code = process recv, :receiver
+      recv_code = process recv, :recv
       args      = ""
 
       @scope.queue_temp tmprecv if tmprecv
-      @scope.queue_temp tmpmeth if tmpmeth
 
-      if tmpmeth and !splat
-        arglist.insert 1, s(:js_tmp, tmprecv)
-      end
+      args = process arglist, :expr
 
-      args = process arglist, :expression
+      if block
+        dispatch = "(%s = %s, %s.%s._p = %s, %s.%s" %
+          [tmprecv, recv_code, tmprecv, mid, block, tmprecv, mid]
 
-      if tmpmeth
-        dispatch  = "(((#{tmpmeth} = (#{tmprecv} = #{recv_code})"
-        dispatch += ".#{mid})._p = #{block})._s = this, #{tmpmeth})"
-        splat ? "#{dispatch}.apply(#{tmprecv}, #{args})" : "#{dispatch}.call(#{args})"
+        if splat
+          "%s.apply(%s, %s))" % [dispatch, tmprecv, args]
+        else
+          "%s(%s))" % [dispatch, args]
+        end
       else
         dispatch = tmprecv ? "(#{tmprecv} = #{recv_code}).#{mid}" : "#{recv_code}.#{mid}"
         splat ? "#{dispatch}.apply(#{tmprecv || recv_code}, #{args})" : "#{dispatch}(#{args})"
@@ -560,18 +600,18 @@ module Opal
     end
 
     # s(:arglist, [arg [, arg ..]])
-    def arglist(sexp, level)
+    def process_arglist(sexp, level)
       code = ''
       work = []
 
       until sexp.empty?
         splat = sexp.first.first == :splat
-        arg   = process sexp.shift, :expression
+        arg   = process sexp.shift, :expr
 
         if splat
           if work.empty?
             if code.empty?
-              code += arg
+              code += "[].concat(#{arg})"
             else
               code += ".concat(#{arg})"
             end
@@ -596,75 +636,77 @@ module Opal
     end
 
     # s(:splat, sexp)
-    def splat(sexp, level)
+    def process_splat(sexp, level)
       return "[]" if sexp.first == [:nil]
-      return "[#{process sexp.first, :expression}]" if sexp.first.first == :lit
-      process sexp.first, :receiver
+      return "[#{process sexp.first, :expr}]" if sexp.first.first == :lit
+      process sexp.first, :recv
     end
 
     # s(:class, cid, super, body)
-    def class(sexp, level)
-      cid = sexp[0]
-      sup = sexp[1]
-      body = sexp[2]
+    def process_class(sexp, level)
+      cid, sup, body = sexp
+
+      body[1] = s(:nil) unless body[1]
+
       code = nil
+      @helpers[:klass] = @helpers[:donate] = true
 
       if Symbol === cid or String === cid
-        donates_methods = (cid === :Object || cid === :BasicObject)
         base = 'this'
         name = cid.to_s.inspect
       elsif cid[0] == :colon2
-        base = process(cid[1], :expression)
+        base = process(cid[1], :expr)
         name = cid[2].to_s.inspect
       elsif cid[0] == :colon3
-        donates_methods = (cid[1] === :Object || cid[1] === :BasicObject)
         base = 'Opal.Object'
         name = cid[1].to_s.inspect
       else
         raise "Bad receiver in class"
       end
 
-      sup = sup ? process(sup, :expression) : 'null'
+      sup = sup ? process(sup, :expr) : 'null'
 
       indent do
         in_scope(:class) do
-          @scope.donates_methods = donates_methods
-          code = @indent + @scope.to_vars + "\n#@indent" + process(body, :statement)
-          code += "\n#{@scope.to_donate_methods}" if @scope.donates_methods
+          @scope.donates_methods = true
+          code = @indent + @scope.to_vars + "\n#@indent" + process(body, :stmt)
+          code += "\n#{@scope.to_donate_methods}"
         end
       end
 
-      "__klass(#{base}, #{sup}, #{name}, function() {\n#{code}\n#@indent}, 0)"
+      "__klass(#{base}, #{sup}, #{name}, function() {\n#{code}\n#@indent})"
     end
 
     # s(:sclass, recv, body)
-    def sclass(sexp, level)
+    def process_sclass(sexp, level)
       recv = sexp[0]
       body = sexp[1]
       code = nil
-      base = process recv, :expression
+      base = process recv, :expr
+      @helpers[:sklass] = true
 
       in_scope(:sclass) do
-        code = @scope.to_vars + process(body, :statement)
+        code = @scope.to_vars + process(body, :stmt)
       end
 
-      "__klass(#{base}, null, null, function() {#{code}}, 2)"
+      "__sklass(#{base}, function() {#{code}})"
     end
 
     # s(:module, cid, body)
-    def module(sexp, level)
+    def process_module(sexp, level)
       cid = sexp[0]
       body = sexp[1]
       code = nil
+      @helpers[:module] = @helpers[:donate] = true
 
       if Symbol === cid or String === cid
         base = 'this'
         name = cid.to_s.inspect
       elsif cid[0] == :colon2
-        base = process(cid[1], :expression)
+        base = process(cid[1], :expr)
         name = cid[2].to_s.inspect
       elsif cid[0] == :colon3
-        base = 'opal.Object'
+        base = 'Opal.Object'
         name = cid[1].to_s.inspect
       else
         raise "Bad receiver in class"
@@ -673,20 +715,26 @@ module Opal
       indent do
         in_scope(:module) do
           @scope.donates_methods = true
-          code = @indent + @scope.to_vars + "\n#@indent" + process(body, :statement) + "\n#@indent" + @scope.to_donate_methods
+          code = @indent + @scope.to_vars + "\n#@indent" + process(body, :stmt) + "\n#@indent" + @scope.to_donate_methods
         end
       end
 
-      "__klass(#{base}, null, #{name}, function() {\n#{code}\n#@indent}, 1)"
+      "__module(#{base}, #{name}, function() {\n#{code}\n#@indent})"
     end
 
-    def undef(exp, level)
+    def process_undef(exp, level)
       @helpers[:undef] = true
-      "__undef(this, #{process exp.shift, :expression})"
+      jsid = mid_to_jsid exp[0][1].to_s
+
+      # "__undef(this, #{jsid.inspect})"
+      # FIXME: maybe add this to donate(). it will be undefined, so
+      # when added to includees it will actually undefine methods there
+      # too.
+      "delete def.#{jsid}"
     end
 
     # s(:defn, mid, s(:args), s(:scope))
-    def defn(sexp, level)
+    def process_defn(sexp, level)
       mid = sexp[0]
       args = sexp[1]
       stmts = sexp[2]
@@ -694,7 +742,7 @@ module Opal
     end
 
     # s(:defs, recv, mid, s(:args), s(:scope))
-    def defs(sexp, level)
+    def process_defs(sexp, level)
       recv = sexp[0]
       mid  = sexp[1]
       args = sexp[2]
@@ -706,11 +754,10 @@ module Opal
       mid = mid_to_jsid mid.to_s
 
       if recvr
-        @helpers[:defs] = true
-        type = '__defs'
-        recv = process(recvr, :expression)
+        @scope.defines_defs = true
+        recv = process(recvr, :expr)
       else
-        type = 'Opal.defn'
+        @scope.defines_defn = true
         recv = 'this'
       end
 
@@ -750,25 +797,25 @@ module Opal
         yielder = block_name || '__yield'
         @scope.block_name = yielder
 
-        params = process args, :expression
+        params = process args, :expr
 
         opt[1..-1].each do |o|
           next if o[2][2] == :undefined
-          id = process s(:lvar, o[1]), :expression
-          code += "if (#{id} == null) {\n#@indent#{INDENT}#{process o, :expression};\n#@indent}"
+          id = process s(:lvar, o[1]), :expr
+          code += "if (#{id} == null) {\n#@indent#{INDENT}#{process o, :expr};\n#@indent}"
         end if opt
 
         code += "#{splat} = __slice.call(arguments, #{len});" if splat
-        code += "\n#@indent" + process(stmts, :statement)
+        code += "\n#@indent" + process(stmts, :stmt)
 
         # Returns the identity name if identified, nil otherwise
         scope_name = @scope.identity
 
         if @scope.uses_block?
-          @scope.add_local '__context'
-          @scope.add_local yielder
-          blk = "\n#{@indent}if (#{yielder} = #{scope_name}._p) {\n#{@indent + INDENT}__context = #{yielder}._s"
-          blk += ";\n#{@indent + INDENT}#{scope_name}._p = null;\n#{@indent}}"
+          @scope.add_temp '__context'
+          @scope.add_temp yielder
+          blk = "\n#{@indent}#{yielder} = #{scope_name}._p || nil;\n#{@indent}__context = #{yielder}._s"
+          blk += ";\n#{@indent}#{scope_name}._p = null;\n#{@indent}"
           code = blk + code
         end
 
@@ -782,18 +829,21 @@ module Opal
 
       defcode = "#{"#{scope_name} = " if scope_name}function(#{params}) {\n#{code}\n#@indent}"
 
-      if @debug
-        "#{type}(#{recv}, '#{mid}', #{defcode}, FILE, #{line})"
-      elsif recvr
-        "#{type}(#{recv}, '#{mid}', #{defcode})"
+      if recvr
+        # FIXME: need to donate()
+        "#{recv}.$singleton_class()._proto.#{mid} = #{defcode}"
       elsif @scope.type == :class
-        @scope.methods << mid if @scope.donates_methods
+        @scope.methods << mid# if @scope.donates_methods
         "def.#{mid} = #{defcode}"
       elsif @scope.type == :module
         @scope.methods << mid
         "def.#{mid} = #{defcode}"
+      elsif @scope.type == :iter
+        # FIXME: this should also donate()
+        "def.#{mid} = #{defcode}"
       else
-        "#{type}(#{recv}, '#{mid}', #{defcode})"
+        # FIXME: this should also donate()
+        "def.#{mid} = #{defcode}"
       end
     end
 
@@ -813,7 +863,7 @@ module Opal
       end
     end
 
-    def args(exp, level)
+    def process_args(exp, level)
       args = []
 
       until exp.empty?
@@ -827,24 +877,21 @@ module Opal
     end
 
     # s(:self)  # => this
-    def self(sexp, level)
+    def process_self(sexp, level)
       'this'
     end
 
     # s(:true)  # => true
     # s(:false) # => false
-    %w(true false).each do |name|
-      define_method name do |exp, level|
+    # s(:nil)   # => nil
+    %w(true false nil).each do |name|
+      define_method "process_#{name}" do |exp, level|
         name
       end
     end
 
-    def nil(*)
-      "nil"
-    end
-
     # s(:array [, sexp [, sexp]])
-    def array(sexp, level)
+    def process_array(sexp, level)
       return '[]' if sexp.empty?
 
       code = ''
@@ -852,7 +899,7 @@ module Opal
 
       until sexp.empty?
         splat = sexp.first.first == :splat
-        part  = process sexp.shift, :expression
+        part  = process sexp.shift, :expr
 
         if splat
           if work.empty?
@@ -877,27 +924,28 @@ module Opal
     end
 
     # s(:hash, key1, val1, key2, val2...)
-    def hash(sexp, level)
-      "Opal.hash(#{sexp.map { |p| process p, :expression }.join ', '})"
+    def process_hash(sexp, level)
+      @helpers[:hash] = true
+      "__hash(#{sexp.map { |p| process p, :expr }.join ', '})"
     end
 
     # s(:while, exp, block, true)
-    def while(sexp, level)
+    def process_while(sexp, level)
       expr = sexp[0]
       stmt = sexp[1]
       redo_var = @scope.new_temp
-      stmt_level = if level == :expression or level == :receiver
-                     :statement_closure
+      stmt_level = if level == :expr or level == :recv
+                     :stmt_closure
                     else
-                      :statement
+                      :stmt
                     end
       pre = "while ("
       code = "#{js_truthy expr}){"
 
       in_while do
-        @while_loop[:closure] = true if stmt_level == :statement_closure
+        @while_loop[:closure] = true if stmt_level == :stmt_closure
         @while_loop[:redo_var] = redo_var
-        body = process(stmt, :statement)
+        body = process(stmt, :stmt)
 
         if @while_loop[:use_redo]
           pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
@@ -911,29 +959,29 @@ module Opal
       code = pre + code
       @scope.queue_temp redo_var
 
-      if stmt_level == :statement_closure
+      if stmt_level == :stmt_closure
         code = "(function() {#{code}; return nil;}).call(this)"
       end
 
       code
     end
 
-    def until(exp, level)
+    def process_until(exp, level)
       expr = exp[0]
       stmt = exp[1]
       redo_var   = @scope.new_temp
-      stmt_level = if level == :expression or level == :receiver
-                     :statement_closure
+      stmt_level = if level == :expr or level == :recv
+                     :stmt_closure
                    else
-                     :statement
+                     :stmt
                    end
       pre = "while (!("
       code = "#{js_truthy expr})) {"
 
       in_while do
-        @while_loop[:closure] = true if stmt_level == :statement_closure
+        @while_loop[:closure] = true if stmt_level == :stmt_closure
         @while_loop[:redo_var] = redo_var
-        body = process(stmt, :statement)
+        body = process(stmt, :stmt)
 
         if @while_loop[:use_redo]
           pre = "#{redo_var}=false;" + pre + "#{redo_var} || "
@@ -947,7 +995,7 @@ module Opal
       code = pre + code
       @scope.queue_temp redo_var
 
-      if stmt_level == :statement_closure
+      if stmt_level == :stmt_closure
         code = "(function() {#{code}; return nil;}).call(this)"
       end
 
@@ -958,14 +1006,16 @@ module Opal
     # alias foo bar
     #
     # s(:alias, s(:lit, :foo), s(:lit, :bar))
-    def alias(exp, level)
+    def process_alias(exp, level)
       @helpers['alias'] = true
-      new = exp[0]
-      old = exp[1]
-      "__alias(this, #{process new, :expression}, #{process old, :expression})"
+      new = mid_to_jsid exp[0][1].to_s
+      old = mid_to_jsid exp[1][1].to_s
+      # "__alias(this, #{new.inspect}, #{old.inspect})"
+      @scope.methods << new
+      "def.#{new} = def.#{old}"
     end
 
-    def masgn(sexp, level)
+    def process_masgn(sexp, level)
       lhs = sexp[0]
       rhs = sexp[1]
       tmp = @scope.new_temp
@@ -975,11 +1025,11 @@ module Opal
       lhs.shift
       if rhs[0] == :array
         len = rhs.length - 1 # we are guaranteed an array of this length
-        code  = ["#{tmp} = #{process rhs, :expression}"]
+        code  = ["#{tmp} = #{process rhs, :expr}"]
       elsif rhs[0] == :to_ary
-        code = ["#{tmp} = [#{process rhs[1], :expression}]"]
+        code = ["#{tmp} = [#{process rhs[1], :expr}]"]
       elsif rhs[0] == :splat
-        code = ["#{tmp} = #{process rhs[1], :expression}"]
+        code = ["#{tmp} = #{process rhs[1], :expr}"]
       else
         raise "Unsupported mlhs type"
       end
@@ -989,14 +1039,14 @@ module Opal
         if l.first == :splat
           s = l[1]
           s << s(:js_tmp, "__slice.call(#{tmp}, #{idx})")
-          code << process(s, :expression)
+          code << process(s, :expr)
         else
           if idx >= len
             l << s(:js_tmp, "(#{tmp}[#{idx}] == null ? nil : #{tmp}[#{idx}])")
           else
             l << s(:js_tmp, "#{tmp}[#{idx}]")
           end
-          code << process(l, :expression)
+          code << process(l, :expr)
         end
       end
 
@@ -1004,38 +1054,38 @@ module Opal
       code.join ', '
     end
 
-    def svalue(sexp, level)
+    def process_svalue(sexp, level)
       process sexp.shift, level
     end
 
     # s(:lasgn, :lvar, rhs)
-    def lasgn(sexp, level)
+    def process_lasgn(sexp, level)
       lvar = sexp[0]
       rhs  = sexp[1]
       lvar = "#{lvar}$".intern if RESERVED.include? lvar.to_s
       @scope.add_local lvar
-      res = "#{lvar} = #{process rhs, :expression}"
-      level == :receiver ? "(#{res})" : res
+      res = "#{lvar} = #{process rhs, :expr}"
+      level == :recv ? "(#{res})" : res
     end
 
     # s(:lvar, :lvar)
-    def lvar(exp, level)
+    def process_lvar(exp, level)
       lvar = exp.shift.to_s
       lvar = "#{lvar}$" if RESERVED.include? lvar
       lvar
     end
 
     # s(:iasgn, :ivar, rhs)
-    def iasgn(exp, level)
+    def process_iasgn(exp, level)
       ivar = exp[0]
       rhs = exp[1]
       ivar = ivar.to_s[1..-1]
       lhs = RESERVED.include?(ivar) ? "this['#{ivar}']" : "this.#{ivar}"
-      "#{lhs} = #{process rhs, :expression}"
+      "#{lhs} = #{process rhs, :expr}"
     end
 
     # s(:ivar, :ivar)
-    def ivar(exp, level)
+    def process_ivar(exp, level)
       ivar = exp.shift.to_s[1..-1]
       part = RESERVED.include?(ivar) ? "['#{ivar}']" : ".#{ivar}"
       @scope.add_ivar part
@@ -1043,63 +1093,58 @@ module Opal
     end
 
     # s(:gvar, gvar)
-    def gvar(sexp, level)
+    def process_gvar(sexp, level)
       gvar = sexp.shift.to_s
       @helpers['gvars'] = true
       "__gvars[#{gvar.inspect}]"
     end
 
     # s(:gasgn, :gvar, rhs)
-    def gasgn(sexp, level)
+    def process_gasgn(sexp, level)
       gvar = sexp[0]
       rhs  = sexp[1]
       @helpers['gvars'] = true
-      "__gvars[#{gvar.to_s.inspect}] = #{process rhs, :expression}"
+      "__gvars[#{gvar.to_s.inspect}] = #{process rhs, :expr}"
     end
 
     # s(:const, :const)
-    def const(sexp, level)
+    def process_const(sexp, level)
       if @debug
-        "Opal.const_get(__scope, #{sexp.shift.to_s.inspect})"
+        "__const_get(__scope, #{sexp.shift.to_s.inspect})"
       else
         "__scope.#{sexp.shift}"
       end
     end
 
     # s(:cdecl, :const, rhs)
-    def cdecl(sexp, level)
+    def process_cdecl(sexp, level)
       const = sexp[0]
       rhs   = sexp[1]
-      "__scope.#{const} = #{process rhs, :expression}"
+      "__scope.#{const} = #{process rhs, :expr}"
     end
 
     # s(:return [val])
-    def return(sexp, level)
-      val = process(sexp.shift || s(:nil), :expression)
+    def process_return(sexp, level)
+      val = process(sexp.shift || s(:nil), :expr)
 
-      if level == :statement
-        "return #{val}"
-      else
-        "$return(#{val})"
-      end
+      raise "Cannot return as an expression" unless level == :stmt
+      "return #{val}"
     end
 
     # s(:xstr, content)
-    def xstr(sexp, level)
+    def process_xstr(sexp, level)
       code = sexp.first.to_s
-      code += ";" if level == :statement and !code.include?(';')
-      code = "(#{code})" if level == :receiver
-
-      code
+      code += ";" if level == :stmt and !code.include?(';')
+      level == :recv ? "(#{code})" : code
     end
 
     # s(:dxstr, parts...)
-    def dxstr(sexp, level)
+    def process_dxstr(sexp, level)
       code = sexp.map do |p|
         if String === p
           p.to_s
         elsif p.first == :evstr
-          process p.last, :statement
+          process p.last, :stmt
         elsif p.first == :str
           p.last.to_s
         else
@@ -1107,18 +1152,18 @@ module Opal
         end
       end.join
 
-      code += ";" if level == :statement and !code.include?(';')
-      code = "(#{code})" if level == :receiver
+      code += ";" if level == :stmt and !code.include?(';')
+      code = "(#{code})" if level == :recv
       code
     end
 
     # s(:dstr, parts..)
-    def dstr(sexp, level)
+    def process_dstr(sexp, level)
       parts = sexp.map do |p|
         if String === p
           p.inspect
         elsif p.first == :evstr
-          process p.last, :expression
+          process p.last, :expr
         elsif p.first == :str
           p.last.inspect
         else
@@ -1127,15 +1172,15 @@ module Opal
       end
 
       res = parts.join ' + '
-      level == :receiver ? "(#{res})" : res
+      level == :recv ? "(#{res})" : res
     end
 
-    def dsym(sexp, level)
+    def process_dsym(sexp, level)
       parts = sexp.map do |p|
         if String === p
           p.inspect
         elsif p.first == :evstr
-          process(s(:call, p.last, :to_s, s(:arglist)), :expression)
+          process(s(:call, p.last, :to_s, s(:arglist)), :expr)
         elsif p.first == :str
           p.last.inspect
         else
@@ -1147,22 +1192,21 @@ module Opal
     end
 
     # s(:if, test, truthy, falsy)
-    def if(sexp, level)
-      test   = sexp[0]
-      truthy = sexp[1]
-      falsy  = sexp[2]
+    def process_if(sexp, level)
+      test, truthy, falsy = sexp
+      returnable = (level == :expr or level == :recv)
 
-      if level == :expression or level == :receiver
+      if returnable
         truthy = returns(truthy || s(:nil))
         falsy = returns(falsy || s(:nil))
       end
 
       code = "if (#{js_truthy test}) {\n"
-      indent { code += @indent + process(truthy, :statement) } if truthy
-      indent { code += "\n#@indent} else {\n#@indent#{process falsy, :statement}" } if falsy
+      indent { code += @indent + process(truthy, :stmt) } if truthy
+      indent { code += "\n#@indent} else {\n#@indent#{process falsy, :stmt}" } if falsy
       code += "\n#@indent}"
 
-      code = "(function() { #{code}; return nil; }).call(this)" if level == :expression or level == :receiver
+      code = "(function() { #{code}; return nil; }).call(this)" if returnable
 
       code
     end
@@ -1171,9 +1215,9 @@ module Opal
       if sexp.first == :call
         mid = sexp[2]
         if mid == :block_given?
-          return process sexp, :expression
+          return process sexp, :expr
         elsif COMPARE.include? mid.to_s
-          return process sexp, :expression
+          return process sexp, :expr
         end
       end
     end
@@ -1184,89 +1228,72 @@ module Opal
       end
 
       tmp = @scope.new_temp
-      code = "(#{tmp} = #{process sexp, :expression}) !== false && #{tmp} !== nil"
       @scope.queue_temp tmp
 
-      code
+      "(%s = %s) !== false && %s !== nil" % [tmp, process(sexp, :expr), tmp]
     end
 
     # s(:and, lhs, rhs)
-    def and(sexp, level)
+    def process_and(sexp, level)
       lhs = sexp[0]
       rhs = sexp[1]
       t = nil
       tmp = @scope.new_temp
 
       if t = js_truthy_optimize(lhs)
-        return "(#{tmp} = #{t} ? #{process rhs, :expression} : #{tmp})".tap {
+        return "(#{tmp} = #{t} ? #{process rhs, :expr} : #{tmp})".tap {
           @scope.queue_temp tmp
         }
       end
 
-      code = "((#{tmp} = #{process lhs, :expression}, #{tmp} !== false && "
-      code += "#{tmp} !== nil) ? #{process rhs, :expression} : #{tmp})"
       @scope.queue_temp tmp
 
-      code
+      "(%s = %s, %s !== false && %s !== nil ? %s : %s)" %
+      [tmp, process(lhs, :expr), tmp, tmp, process(rhs, :expr), tmp]
     end
 
     # s(:or, lhs, rhs)
-    def or(sexp, level)
+    def process_or(sexp, level)
       lhs = sexp[0]
       rhs = sexp[1]
       t = nil
       tmp = @scope.new_temp
 
       if t = js_truthy_optimize(lhs)
-        return "(#{tmp} = #{t} ? #{tmp} : #{process rhs, :expression})".tap {
+        return "(#{tmp} = #{t} ? #{tmp} : #{process rhs, :expr})".tap {
           @scope.queue_temp tmp
         }
       end
 
-      code = "(#{tmp} = #{process lhs, :expression}, #{tmp} !== false && "
-      code += "#{tmp} !== nil ? #{tmp} : #{process rhs, :expression})"
       @scope.queue_temp tmp
 
-      code
+      "(%s = %s, %s !== false && %s !== nil ? %s : %s)" %
+      [tmp, process(lhs, :expr), tmp, tmp, tmp, process(rhs, :expr)]
     end
 
     # s(:yield, arg1, arg2)
-    def yield(sexp, level)
-              # puts sexp.inspect
-              # puts level.inspect
+    #
+    # FIXME: yield as an expression (when used with js_return) should have the
+    # right action. We should then warn when used as an expression in other cases
+    # that we would need to use a try/catch/throw block (which is slow and bad
+    # mmmkay).
+    def process_yield(sexp, level)
       @scope.uses_block!
       splat = sexp.any? { |s| s.first == :splat }
-      # sexp.unshift s(:js_tmp, 'null')
       sexp.unshift s(:js_tmp, '__context') unless splat
-      args = arglist(sexp, level)
+      args = process_arglist(sexp, level)
 
       yielder = @scope.block_name || '__yield'
 
-      call =  if splat
-                "#{yielder}.apply(__context, #{args})"
-              else
-                "#{yielder}.call(#{args})"
-              end
-
-      # FIXME: yield as an expression (when used with js_return) should have the
-      # right action. We should then warn when used as an expression in other cases
-      # that we would need to use a try/catch/throw block (which is slow and bad
-      # mmmkay).
-
-      # if level == :receiver or level == :expression
-        # tmp = @scope.new_temp
-        # @scope.catches_break!
-        # code = "((#{tmp} = #{call}) === __breaker ? #{tmp}.$t() : #{tmp})"
-        # @scope.queue_temp tmp
-      # else
-        code = call
-      # end
-
-      code
+      if splat
+        "#{yielder}.apply(__context, #{args})"
+      else
+        "#{yielder}.call(#{args})"
+      end
     end
 
-    def break(exp, level)
-      val = exp.empty? ? 'nil' : process(exp.shift, :expression)
+    def process_break(exp, level)
+      val = exp.empty? ? 'nil' : process(exp.shift, :expr)
       if in_while?
         if @while_loop[:closure]
           "return #{val};"
@@ -1279,25 +1306,25 @@ module Opal
     end
 
     # s(:case, expr, when1, when2, ..)
-    def case(exp, level)
+    def process_case(exp, level)
       code = []
       @scope.add_local "$case"
-      expr = process exp.shift, :expression
+      expr = process exp.shift, :expr
       # are we inside a statement_closure
-      returnable = level != :statement
+      returnable = level != :stmt
       done_else = false
 
       until exp.empty?
         wen = exp.shift
         if wen and wen.first == :when
           returns(wen) if returnable
-          wen = process(wen, :statement)
+          wen = process(wen, :stmt)
           wen = "else #{wen}" unless code.empty?
           code << wen
         elsif wen # s(:else)
           done_else = true
           wen = returns(wen) if returnable
-          code << "else {#{process wen, :statement}}"
+          code << "else {#{process wen, :stmt}}"
         end
       end
 
@@ -1312,7 +1339,7 @@ module Opal
     #   bar
     #
     # s(:when, s(:array, foo), bar)
-    def when(exp, level)
+    def process_when(exp, level)
       arg = exp.shift[1..-1]
       body = exp.shift
       body = process body, level if body
@@ -1324,26 +1351,26 @@ module Opal
         if a.first == :when # 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, :expression}) { return true; }"
-          splt += "} return false; }).call(this, #{process a[1], :expression})"
+          splt += "if (#{process call, :expr}) { return true; }"
+          splt += "} return false; }).call(this, #{process a[1], :expr})"
 
           test << splt
         else
           call = s(:call, a, :===, s(:arglist, s(:js_tmp, "$case")))
-          call = process call, :expression
+          call = process call, :expr
           # call = "else " unless test.empty?
 
           test << call
         end
       end
 
-      "if (#{test.join " || "}) {\n#{body}\n}"
+      "if (%s) {\n%s\n}" % [test.join(' || '), body]
     end
 
     # lhs =~ rhs
     #
     # s(:match3, lhs, rhs)
-    def match3(sexp, level)
+    def process_match3(sexp, level)
       lhs = sexp[0]
       rhs = sexp[1]
       call = s(:call, lhs, :=~, s(:arglist, rhs))
@@ -1353,68 +1380,67 @@ module Opal
     # @@class_variable
     #
     # s(:cvar, name)
-    def cvar(exp, level)
+    def process_cvar(exp, level)
       tmp = @scope.new_temp
-      code = "((#{tmp} = Opal.cvars[#{exp.shift.to_s.inspect}]) == null ? null : #{tmp})"
       @scope.queue_temp tmp
-      code
+      "((%s = Opal.cvars[%s]) == null ? nil : %s)" % [tmp, exp.shift.to_s.inspect, tmp]
     end
 
     # @@name = rhs
     #
     # s(:cvasgn, :@@name, rhs)
-    def cvasgn(exp, level)
-      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expression})"
+    def process_cvasgn(exp, level)
+      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expr})"
     end
 
-    def cvdecl(exp, level)
-      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expression})"
+    def process_cvdecl(exp, level)
+      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expr})"
     end
 
     # BASE::NAME
     #
     # s(:colon2, base, :NAME)
-    def colon2(sexp, level)
+    def process_colon2(sexp, level)
       base = sexp[0]
       name = sexp[1]
-      "Opal.const_get((#{process base, :expression})._scope, #{name.to_s.inspect})"
+      "(%s)._scope.%s" % [process(base, :expr), name.to_s]
     end
 
-    def colon3(exp, level)
-      "Opal.const_get(Opal.Object._scope, #{exp.shift.to_s.inspect})"
+    def process_colon3(exp, level)
+      "__opal.Object._scope.#{exp.shift.to_s}"
     end
 
     # super a, b, c
     #
     # s(:super, arg1, arg2, ...)
-    def super(sexp, level)
+    def process_super(sexp, level)
       args = []
       until sexp.empty?
-        args << process(sexp.shift, :expression)
+        args << process(sexp.shift, :expr)
       end
 
-      # args.unshift 'null'
-
       js_super "[#{ args.join ', ' }]"
     end
 
     # super
     #
     # s(:zsuper)
-    def zsuper(exp, level)
-
+    def process_zsuper(exp, level)
       js_super "__slice.call(arguments)"
     end
 
     def js_super args
       if @scope.type == :def
-        mid      = @scope.mid
         identity = @scope.identify!
-        "Opal.zuper(#{identity}, '#{mid}', this, #{args})"
+
+        # FIXME: only use `._proto` when inside normal def. remove it
+        # for `def self.foo`.
+        "__class._super._proto.#{@scope.mid}.apply(this, #{args})"
 
       elsif @scope.type == :iter
         chain, defn, mid = @scope.get_super_chain
-        "Opal.dsuper([#{chain.join ', '}], #{defn}, #{mid}, this, #{args})"
+        trys = chain.map { |c| "#{c}._jsid" }.join ' || '
+        "this._klass._super._proto[#{trys} || #{mid}].apply(this, #{args})"
 
       else
         raise "Cannot call super() from outside a method block"
@@ -1424,19 +1450,19 @@ module Opal
     # a ||= rhs
     #
     # s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, rhs))
-    def op_asgn_or(exp, level)
-      process s(:or, exp.shift, exp.shift), :expression
+    def process_op_asgn_or(exp, level)
+      process s(:or, exp.shift, exp.shift), :expr
     end
 
-    def op_asgn1(sexp, level)
+    def process_op_asgn1(sexp, level)
       "'FIXME(op_asgn1)'"
     end
 
     # lhs.b += rhs
     #
     # s(:op_asgn2, lhs, :b=, :+, rhs)
-    def op_asgn2(exp, level)
-      lhs = process exp.shift, :expression
+    def process_op_asgn2(exp, level)
+      lhs = process exp.shift, :expr
       mid = exp.shift.to_s[0..-2]
       op  = exp.shift
       rhs = exp.shift
@@ -1449,16 +1475,16 @@ 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, :expression})".tap {
+        "(#{temp} = #{lhs}, #{process asgn, :expr})".tap {
           @scope.queue_temp temp
         }
       end
     end
 
     # s(:ensure, body, ensure)
-    def ensure(exp, level)
+    def process_ensure(exp, level)
       begn = exp.shift
-      if level == :receiver || level == :expression
+      if level == :recv || level == :expr
         retn = true
         begn = returns begn
       end
@@ -1473,7 +1499,7 @@ module Opal
       res
     end
 
-    def rescue(exp, level)
+    def process_rescue(exp, level)
       body = exp.first.first == :resbody ? s(:nil) : exp.shift
       body = process body, level
 
@@ -1486,13 +1512,13 @@ module Opal
       # if no rescue statement captures our error, we should rethrow
       parts << "else { throw $err; }"
 
-      code = "try {\n#{body}\n} catch ($err) {\n#{parts.join "\n"}\n}"
-      code = "(function() { #{code} }).call(this)" if level == :expression
+      code = "try {\n#@indent#{body}\n#@indent} catch ($err) {\n#@indent#{parts.join "\n"}\n}"
+      code = "(function() { #{code} }).call(this)" if level == :expr
 
       code
     end
 
-    def resbody(exp, level)
+    def process_resbody(exp, level)
       args = exp[0]
       body = exp[1]
       body = process(body || s(:nil), level)
@@ -1500,7 +1526,7 @@ module Opal
 
       err = types.map { |t|
         call = s(:call, t, :===, s(:arglist, s(:js_tmp, "$err")))
-        a = process call, :expression
+        a = process call, :expr
         #puts a
         a
       }.join ', '
@@ -1509,7 +1535,7 @@ module Opal
       if Array === args.last and [:lasgn, :iasgn].include? args.last.first
         val = args.last
         val[2] = s(:js_tmp, "$err")
-        val = process(val, :expression) + ";"
+        val = process(val, :expr) + ";"
       end
 
       "if (#{err}) {\n#{val}#{body}}"
@@ -1517,12 +1543,12 @@ module Opal
     end
 
     # FIXME: Hack.. grammar should remove top level begin.
-    def begin(exp, level)
+    def process_begin(exp, level)
       process exp[0], level
     end
 
-    def next(exp, level)
-      val = exp.empty? ? 'nil' : process(exp.shift, :expression)
+    def process_next(exp, level)
+      val = exp.empty? ? 'nil' : process(exp.shift, :expr)
       if in_while?
         "continue;"
       else
@@ -1530,7 +1556,7 @@ module Opal
       end
     end
 
-    def redo(exp, level)
+    def process_redo(exp, level)
       if in_while?
         @while_loop[:use_redo] = true
         "#{@while_loop[:redo_var]} = true"
@@ -1539,4 +1565,4 @@ module Opal
       end
     end
   end
-end
+end