opal 0.3.16 → 0.3.17

data/lib/opal/{parser/grammar.y → grammar.y}

@@ -1062,6 +1062,10 @@ method_call:
     {
       result = new_call val[0], val[2].intern, val[3]
     }
+  | primary_value '.' paren_args
+    {
+      result = new_call val[0], :call, val[2]
+    }
   | primary_value '::' operation2 paren_args
   | primary_value '::' operation3
   | SUPER paren_args
@@ -1182,6 +1186,9 @@ string1:
       result = val[1]
     }
   | STRING
+    {
+      result = s(:str, val[0])
+    }
 
 xstring:
     XSTRING_BEG xstring_contents STRING_END

data/lib/opal/{parser/lexer.rb → lexer.rb}

@@ -1,12 +1,10 @@
-require 'opal/parser/grammar'
-require 'opal/parser/sexp'
-
+require 'opal/grammar'
 require 'strscan'
 
 module Opal
   class Grammar < Racc::Parser
 
-  class LexingError < StandardError; end
+  class OpalParseError < StandardError; end
 
   attr_reader :line
 
@@ -21,7 +19,7 @@ module Opal
   end
 
   def s *parts
-    sexp = Sexp.new *parts
+    sexp = parts
     sexp.line = @line
     sexp
   end
@@ -37,6 +35,10 @@ module Opal
     result
   end
 
+  def on_error(t, val, vstack)
+    raise OpalParseError, "parse error on value #{val.inspect} (line #{@line})"
+  end
+
   class LexerScope
     attr_reader :locals
     attr_accessor :parent
@@ -140,7 +142,7 @@ module Opal
 
   def new_sclass expr, body
     scope = s(:scope)
-    scope << body unless body.size == 1
+    scope << body #unless body.size == 1
     scope.line = body.line
     s = s(:sclass, expr, scope)
     s
@@ -224,7 +226,7 @@ module Opal
     if block
       b = block.to_s[1..-1].intern
       res << s(:block_pass, s(:lasgn, b))
-      @scope.add_local r
+      @scope.add_local b
     end
 
     res << opt if opt
@@ -435,8 +437,8 @@ module Opal
 
   def next_token
     t = get_next_token
-    #puts "returning token #{t.inspect}"
-    #t[1] = { :value => t[1], :line => @line }
+    # puts "returning token #{t.inspect}"
+    # t[1] = { :value => t[1], :line => @line }
     t
   end
 
@@ -1005,7 +1007,26 @@ module Opal
         return [result, result]
 
       elsif scanner.scan(/\?/)
-        @lex_state = :expr_beg if [:expr_end, :expr_endarg].include?(@lex_state)
+        # FIXME: :expr_arg shouldnt really be here
+        if [:expr_end, :expr_endarg, :expr_arg].include?(@lex_state)
+          @lex_state = :expr_beg
+          return '?', scanner.matched
+        end
+
+        #if scanner.scan(/\\/)
+          #c = if scanner.scan(/n/)
+                #"\n"
+              #else
+                #scanner.scan(/./)
+                #scanner.matched
+              #end
+        #else
+          #c = scanner.scan(/./)
+        #end
+
+        #@lex_state = :expr_end
+        #return :STRING, c
+        @lex_state = :expr_beg
         return '?', scanner.matched
 
       elsif scanner.scan(/\=\=\=/)
@@ -1331,7 +1352,7 @@ module Opal
       end
       return [false, false] if scanner.eos?
 
-      raise LexingError, "Unexpected content in parsing stream `#{scanner.peek 5}`"
+      raise OpalParseError, "Unexpected content in parsing stream `#{scanner.peek 5}`"
     end
   end
 end

data/lib/opal/{parser/parser.rb → parser.rb}

@@ -1,18 +1,19 @@
-require 'opal/parser/lexer'
-require 'opal/parser/grammar'
-require 'opal/parser/scope'
+require 'opal/lexer'
+require 'opal/grammar'
+require 'opal/scope'
+
+class Array
+  attr_accessor :line
+  attr_accessor :end_line
+end
 
 module Opal
   class OpalParseError < Exception; end
 
   class Parser
-    def self.to_syms(ary)
-      ary.map &:to_sym
-    end
-
     INDENT = '  '
 
-    LEVEL = to_syms(%w[statement statement_closure list expression receiver])
+    LEVEL = [:statement, :statement_closure, :list, :expression, :receiver]
 
     # Maths operators
     MATH = %w(+ - / * %)
@@ -20,7 +21,7 @@ module Opal
     # Comparison operators
     COMPARE = %w(< <= > >=)
 
-    # All operators that can be optimized in method calls
+    # All Operators that can be optimized in method calls
     CALL_OPERATORS = MATH + COMPARE
 
     # Reserved javascript keywords - we cannot create variables with the
@@ -76,7 +77,13 @@ module Opal
       singleton: 0x0800
     }
 
-    STATEMENTS = to_syms(%w[xstr dxstr])
+    STATEMENTS = [:xstr, :dxstr]
+
+    attr_reader :grammar
+
+    def self.parse(str)
+      self.new.parse str
+    end
 
     def initialize(opts = {})
       @debug = opts[:debug] or false
@@ -85,34 +92,26 @@ module Opal
     def parse(source, file = '(file)')
       @file = file
       @helpers = {
-        :breaker => true, :no_proc => true, :klass => true, :const_get => true,
-        :slice => true
+        :breaker   => true,
+        :klass     => true,
+        :const_get => true,
+        :slice     => true
+        # :nil       => true
       }
 
-      parser = Grammar.new
+      @grammar = Grammar.new
       reset
-
-      # Debug mode always uses FILE for sending methods which have stack traces
-      @uses_file = true if @debug
-
-      # $send is needed in debug mode
-      @helpers[:send] = true if @debug
-
-      begin
-        top parser.parse(source, file)
-      rescue Exception => e
-        raise OpalParseError.new("#{e.message} in #{file}:#{parser.line}")
-      end
+      top @grammar.parse(source, file)
     end
 
     def s(*parts)
-      sexp = Sexp.new *parts
+      sexp = parts
       sexp.line = @line
       sexp
     end
 
     def reset
-      @line = 1
+      @line   = 1
       @indent = ''
       @unique = 0
     end
@@ -135,19 +134,20 @@ module Opal
       vars = []
 
       in_scope(:top) do
-        code = process s(:scope, sexp), :statement
+        indent {
+          code = @indent + process(s(:scope, sexp), :statement)
+        }
 
-        vars << "FILE = $opal.FILE" if @uses_file
-        vars << "nil = $opal.nil"
-        vars << "$const = $opal.constants"
-        vars.concat @scope.locals.map { |t| "#{t}" }
-        vars.concat @scope.temps.map { |t| t }
-        vars.concat @helpers.keys.map { |h| "$#{h} = $opal.#{h}" }
+        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}" }
 
-        code = "var #{vars.join ', '};" + code unless vars.empty?
+        code = "var #{vars.join ', '};\n" + @scope.to_vars + "\n" + code
       end
 
-      pre  = "(function($opal) {"
+      pre  = "(function() {\n"
       post = ""
 
       uniques = []
@@ -158,7 +158,7 @@ module Opal
         post += ";var #{uniques.join ', '};"
       end
 
-      post += "\n}).call(opal.top, opal);"
+      post += "\n}).call(Opal.top);\n"
 
       pre + code + post
     end
@@ -167,7 +167,7 @@ module Opal
       return unless block_given?
 
       parent = @scope
-      @scope = Scope.new(type).tap { |s| s.parent = parent }
+      @scope = Scope.new(type, self).tap { |s| s.parent = parent }
       yield @scope
 
       @scope = parent
@@ -203,24 +203,13 @@ module Opal
     end
 
     def process(sexp, level)
+      # puts "PROCESS: (#{level})"
+      # puts "  #{sexp.inspect}"
       type = sexp.shift
 
       raise "Unsupported sexp: #{type}" unless respond_to? type
 
-      line = fix_line sexp.line
-      code = __send__ type, sexp, level
-      line + code
-    end
-
-    def fix_line(line)
-      res = ""
-
-      if @line < line
-        res = "\n" * (line - @line)
-        res += @indent
-        @line = line
-      end
-      res
+      __send__ type, sexp, level
     end
 
     def returns(sexp)
@@ -277,11 +266,11 @@ module Opal
       until sexp.empty?
         stmt = sexp.shift
         expr = expression?(stmt) and LEVEL.index(level) < LEVEL.index(:list)
-        result << process(stmt, level)
-        result << ";" if expr
+        code = process(stmt, level)
+        result << (expr ? "#{code};" : code)
       end
 
-      result.join
+      result.join "\n#@indent"
     end
 
     def scope(sexp, level)
@@ -302,12 +291,6 @@ module Opal
       sexp.shift.to_s
     end
 
-    # s(:js_block_given)
-    def js_block_given(sexp, level)
-      @scope.uses_block!
-      "$block_given"
-    end
-
     def js_operator_call(sexp, level)
       recv = sexp[0]
       meth = sexp[1]
@@ -329,41 +312,10 @@ module Opal
       res
     end
 
-    def js_compile_time_helpers(exp, level)
-      recv = exp[0]
-      meth = exp[1]
-      args = exp[2]
-
-      arg = args[1] || raise("No argument given to compile helper: #{meth}")
-      arg = process arg, :expression
-      tmp = @scope.new_temp
-
-      res = case meth
-      when :object?
-        "(!!(#{tmp} = #{arg}, #{tmp} != null && #{tmp}.$klass))"
-      when :native?
-        "(!!(#{tmp} = #{arg}, #{tmp} == null || !#{tmp}.$klass))"
-      when :string?
-        "(typeof #{arg} === 'string')"
-      when :number?
-        "(typeof #{arg} === 'number')"
-      when :function?
-        "(typeof #{arg} === 'function')"
-      when :defined?
-        "((#{tmp} = typeof(#{arg})) === 'undefined' ? nil : #{tmp})"
-      when :undefined?
-        "(typeof(#{arg}) === 'undefined')"
-      when :null?
-        "(#{arg} === null)"
-      when :typeof
-        "(typeof(#{arg}))"
-      else
-        raise "Bad compile time helper: #{meth}"
-      end
-
-      @scope.queue_temp tmp
-
-      res
+    # s(:js_block_given)
+    def js_block_given(sexp, level)
+      @scope.uses_block!
+      "!!#{@scope.block_name}"
     end
 
     # s(:lit, 1)
@@ -378,7 +330,8 @@ module Opal
       when Regexp
         val == // ? /^/.inspect : val.inspect
       when Range
-        "$opal.range(#{val.begin}, #{val.end}, #{val.exclude_end?})"
+        @helpers[:range] = true
+        "__range(#{val.begin}, #{val.end}, #{val.exclude_end?})"
       else
         raise "Bad lit: #{val.inspect}"
       end
@@ -398,8 +351,14 @@ module Opal
       "(new RegExp(#{parts.join ' + '}))"
     end
 
-    def dot2 exp, level
-      "$opal.range(#{process exp[0], :expression}, #{process exp[1], :expression}, false)"
+    def dot2(sexp, level)
+      @helpers[:range] = true
+      "__range(#{process sexp[0], :expression}, #{process sexp[1], :expression}, false)"
+    end
+
+    def dot3(sexp, level)
+      @helpers[:range] = true
+      "__range(#{process sexp[0], :expression}, #{process sexp[1], :expression}, true)"
     end
 
     # s(:str, "string")
@@ -407,7 +366,7 @@ module Opal
       str = sexp.shift
       if str == @file
         @uses_file = true
-        "FILE"
+        "'FILE'"
       else
         str.inspect
       end
@@ -435,20 +394,18 @@ module Opal
 
     # s(:not, sexp)
     def not(sexp, level)
-      tmp = @scope.new_temp
-      code = "((#{tmp} = #{process sexp.shift, :expression}) === false || #{tmp} === nil)"
-      @scope.queue_temp tmp
+      code = "!#{process sexp.shift, :expression}"
       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} == nil ? #{tmp} : #{to_proc}))"
+      code = "(#{tmp} = #{pass}, (typeof(#{tmp}) === 'function' || #{tmp} == null ? #{tmp} : #{to_proc}))"
 
       @scope.queue_temp tmp
 
@@ -465,13 +422,15 @@ module Opal
       body = returns body
       code = ""
       params = nil
+      scope_name = nil
 
       args = nil if Fixnum === args # argh
       args ||= s(:masgn, s(:array))
       args = args.first == :lasgn ? s(:array, args) : args[1]
 
       if args.last[0] == :block_pass
-        args.pop
+        block_arg = args.pop
+        block_arg = block_arg[1][1].intern
       end
 
       if args.last[0] == :splat
@@ -483,25 +442,36 @@ module Opal
       indent do
         in_scope(:iter) do
           args[1..-1].each do |arg|
-            arg = arg[1]
-            arg = "#{arg}$" if RESERVED.include? arg.to_s
-            code += "if (#{arg} === undefined) {#{arg} = nil; }"
+           arg = arg[1]
+           arg = "#{arg}$" if RESERVED.include? arg.to_s
+            code += "if (#{arg} == null) #{arg} = nil;\n"
           end
 
           params = js_block_args(args[1..-1])
+          # params.unshift '_$'
 
           if splat
             params << splat
-            code += "#{splat} = $slice.call(arguments, #{len - 1});"
+            code += "#{splat} = __slice.call(arguments, #{len - 1});"
           end
 
-          code += process body, :statement
+          if block_arg
+            @scope.add_arg block_arg
+            code += "var #{block_arg} = _$ || nil, $context = #{block_arg}.$S;"
+          end
+
+          code += "\n#@indent" + process(body, :statement)
+
+          code = "\n#@indent#{@scope.to_vars}\n#@indent#{code}"
 
-          code = @scope.to_vars + code
+          scope_name = @scope.identity
         end
       end
 
-      call << "function(#{params.join ', '}) {#{code}#{fix_line sexp.end_line}}"
+      itercode = "function(#{params.join ', '}) {\n#{code}\n#@indent}"
+      itercode = "#{scope_name} = #{itercode}" if scope_name
+      call << itercode
+
       process call, level
     end
 
@@ -527,6 +497,15 @@ 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]
+
+      "#{process lhs, level} #{op} #{process rhs, level}"
+    end
+
     # s(:call, recv, :mid, s(:arglist))
     # s(:call, nil, :mid, s(:arglist))
     def call(sexp, level)
@@ -538,63 +517,45 @@ module Opal
       mid = mid_to_jsid meth.to_s
 
       return js_operator_call(sexp, level) if CALL_OPERATORS.include? meth.to_s
-      return js_compile_time_helpers(sexp, level) if recv && recv == [:const, :Opal]
       return js_block_given(sexp, level) if meth == :block_given?
-      return "undefined" if meth == :undefined
 
       splat = arglist[1..-1].any? { |a| a.first == :splat }
 
-      if Sexp === arglist.last and arglist.last.first == :block_pass
-        tmpproc = @scope.new_temp
-        tmprecv = @scope.new_temp
-        block = process arglist.pop, :expression
+      if Array === arglist.last and arglist.last.first == :block_pass
+        tmpmeth = @scope.new_temp
+        block   = process s(:js_tmp, process(arglist.pop, :expression)), :expression
       elsif iter
-        tmpproc = @scope.new_temp
+        tmpmeth = @scope.new_temp
+        block   = iter
+      end
+
+      recv ||= [:self]
+
+      if block
         tmprecv = @scope.new_temp
-        block = iter
-      elsif splat or @debug
+      elsif splat and recv != [:self] and recv[0] != :lvar
         tmprecv = @scope.new_temp
       end
+      
+      recv_code = process recv, :receiver
+      args      = ""
 
-      args = ""
-
-      recv_code = recv.nil? ? 'this' : process(recv, :receiver)
+      @scope.queue_temp tmprecv if tmprecv
+      @scope.queue_temp tmpmeth if tmpmeth
 
-      if @debug
-        if iter
-          debugblock = "(#{tmpproc}=#{block},#{tmpproc}.$S=this, #{tmpproc})"
-        elsif block
-          debugblock = block
-        else
-          debugblock = 'null'
-        end
-        arglist.insert 1, s(:js_tmp, recv_code), s(:js_tmp, debugblock), s(:js_tmp, mid.inspect)
+      if tmpmeth and !splat
+        arglist.insert 1, s(:js_tmp, tmprecv)
       end
 
       args = process arglist, :expression
 
-      @scope.queue_temp tmprecv if tmprecv
-      @scope.queue_temp tmpproc if tmpproc
-
-      if @debug
-        splat ? "$send.apply(null, #{args})" : "$send(#{args})"
-      elsif @method_missing
-        pre = "((#{tmprecv}=#{recv_code}).#{mid} || $opal.mm('#{mid}'))."
-        splat ? "#{pre}apply(#{tmprecv}, #{args})" : "#{pre}call(#{tmprecv}#{args == '' ? '' : ", #{args}"})"
+      if tmpmeth
+        dispatch  = "(((#{tmpmeth} = (#{tmprecv} = #{recv_code})"
+        dispatch += ".#{mid})._p = #{block})._s = this, #{tmpmeth})"
+        splat ? "#{dispatch}.apply(#{tmprecv}, #{args})" : "#{dispatch}.call(#{args})"
       else
-        if block
-          if iter
-            call = "(#{tmpproc}=(#{tmprecv}=#{recv_code}).#{mid}, (#{tmpproc}.$P = #{block}).$S = this, #{tmpproc})"
-          else # block_pass
-            call = "(#{tmpproc}=(#{tmprecv}=#{recv_code}).#{mid}, #{tmpproc}.$P = #{block}, #{tmpproc})"
-          end
-
-          args = ", #{args}" unless args.empty?
-          splat ? "#{call}.apply(#{tmprecv}#{args})" : "#{call}.call(#{tmprecv}#{args})"
-
-        else
-          splat ? "(#{tmprecv}=#{recv_code}).#{mid}.apply(#{tmprecv}, #{args})" : "#{recv_code}.#{mid}(#{args})"
-        end
+        dispatch = tmprecv ? "(#{tmprecv} = #{recv_code}).#{mid}" : "#{recv_code}.#{mid}"
+        splat ? "#{dispatch}.apply(#{tmprecv || recv_code}, #{args})" : "#{dispatch}(#{args})"
       end
     end
 
@@ -657,23 +618,23 @@ module Opal
         name = cid[2].to_s.inspect
       elsif cid[0] == :colon3
         donates_methods = (cid[1] === :Object || cid[1] === :BasicObject)
-        base = '$opal.Object'
+        base = 'opal.Object'
         name = cid[1].to_s.inspect
       else
         raise "Bad receiver in class"
       end
 
-      sup = sup ? process(sup, :expression) : 'nil'
+      sup = sup ? process(sup, :expression) : 'null'
 
       indent do
         in_scope(:class) do
           @scope.donates_methods = donates_methods
-          code = @scope.to_vars + process(body, :statement)
-          code += @scope.to_donate_methods if @scope.donates_methods
+          code = @indent + @scope.to_vars + "\n#@indent" + process(body, :statement)
+          code += "\n#{@scope.to_donate_methods}" if @scope.donates_methods
         end
       end
 
-      "$klass(#{base}, #{sup}, #{name}, function() {#{code}#{fix_line sexp.end_line}}, 0)"
+      "__klass(#{base}, #{sup}, #{name}, function() {\n#{code}\n#@indent}, 0)"
     end
 
     # s(:sclass, recv, body)
@@ -687,7 +648,7 @@ module Opal
         code = @scope.to_vars + process(body, :statement)
       end
 
-      "$klass(#{base}, nil, nil, function() {#{code}}, 2)"
+      "__klass(#{base}, null, null, function() {#{code}}, 2)"
     end
 
     # s(:module, cid, body)
@@ -703,7 +664,7 @@ module Opal
         base = process(cid[1], :expression)
         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"
@@ -712,15 +673,15 @@ module Opal
       indent do
         in_scope(:module) do
           @scope.donates_methods = true
-          code = @scope.to_vars + process(body, :statement) + @scope.to_donate_methods
+          code = @indent + @scope.to_vars + "\n#@indent" + process(body, :statement) + "\n#@indent" + @scope.to_donate_methods
         end
       end
 
-      "$klass(#{base}, nil, #{name}, function() {#{code}#{fix_line sexp.end_line}}, 1)"
+      "__klass(#{base}, null, #{name}, function() {\n#{code}\n#@indent}, 1)"
     end
 
     def undef(exp, level)
-      "$opal.undef(this, #{process exp.shift, :expression})"
+      "opal.undef(this, #{process exp.shift, :expression})"
     end
 
     # s(:defn, mid, s(:args), s(:scope))
@@ -744,10 +705,11 @@ module Opal
       mid = mid_to_jsid mid.to_s
 
       if recvr
-        type = '$opal.defs'
+        @helpers[:defs] = true
+        type = '__defs'
         recv = process(recvr, :expression)
       else
-        type = '$opal.defn'
+        type = 'Opal.defn'
         recv = 'this'
       end
 
@@ -756,7 +718,7 @@ module Opal
       scope_name = nil
 
       # opt args if last arg is sexp
-      opt = args.pop if Sexp === args.last
+      opt = args.pop if Array === args.last
 
       # block name &block
       if args.last.to_s[0] == '&'
@@ -774,52 +736,50 @@ module Opal
         end
       end
 
-      aritycode = arity_check(args, opt, splat) if @debug && false
+      # aritycode = arity_check(args, opt, splat) if @debug && false
 
       indent do
       in_scope(:def) do
-        params = process args, :expression
+        @scope.mid = mid
 
         if block_name
-          @scope.add_arg block_name
           @scope.uses_block!
         end
 
+        yielder = block_name || '__yield'
+        @scope.block_name = yielder
+
+        params = process args, :expression
+
         opt[1..-1].each do |o|
           next if o[2][2] == :undefined
           id = process s(:lvar, o[1]), :expression
-          code += "if (#{id} === undefined) { #{process o, :expression}; }"
+          code += "if (#{id} == null) {\n#@indent#{INDENT}#{process o, :expression};\n#@indent}"
         end if opt
 
-        code += "#{splat} = $slice.call(arguments, #{len});" if splat
-        code += process(stmts, :statement)
-
-        if @scope.uses_block?
-          scope_name = @scope.name = unique_temp
-          blk = "var $yield = #{scope_name}.$P;"
-          blk += "if ($yield) { var $context = $yield.$S"
-          blk += ", $block_given = true"
-          blk += ", #{block_name} = $yield" if block_name
-          blk += "; #{scope_name}.$P = null; }"
+        code += "#{splat} = __slice.call(arguments, #{len});" if splat
+        code += "\n#@indent" + process(stmts, :statement)
 
-          blk += "else { $yield = $no_proc"
-          blk += ", #{block_name} = nil" if block_name
-          blk += "; }"
+        # 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}}"
           code = blk + code
         end
 
-        code = aritycode.to_s + code
-
         if @scope.catches_break?
-          code = "try {#{code}} catch (e) { if (e === $breaker) { return e.$v; }; throw e;}"
+          # code = "try {#{code}} catch (e) { if (e === __breaker) { return e.$v; }; throw e;}"
         end
 
-        code = @scope.to_vars + code
+        code = "#@indent#{@scope.to_vars}" + code
       end
       end
 
-      defcode = "#{"#{scope_name} = " if scope_name}function(#{params}) {#{code}#{fix_line end_line}}"
+      defcode = "#{"#{scope_name} = " if scope_name}function(#{params}) {\n#{code}\n#@indent}"
 
       if @debug
         "#{type}(#{recv}, '#{mid}', #{defcode}, FILE, #{line})"
@@ -846,9 +806,9 @@ module Opal
 
       aritycode = "var $arity = arguments.length; if ($arity !== 0) { $arity -= 1; }"
       if arity < 0 # splat or opt args
-        aritycode + "if ($arity < #{-(arity + 1)}) { $opal.arg_error($arity, #{arity}); }"
+        aritycode + "if ($arity < #{-(arity + 1)}) { opal.arg_error($arity, #{arity}); }"
       else
-        aritycode + "if ($arity !== #{arity}) { $opal.arg_error($arity, #{arity}); }"
+        aritycode + "if ($arity !== #{arity}) { opal.arg_error($arity, #{arity}); }"
       end
     end
 
@@ -872,13 +832,16 @@ module Opal
 
     # s(:true)  # => true
     # s(:false) # => false
-    # s(:nil)   # => nil
-    %w(true false nil).each do |name|
+    %w(true false).each do |name|
       define_method name do |exp, level|
         name
       end
     end
 
+    def nil(*)
+      "nil"
+    end
+
     # s(:array [, sexp [, sexp]])
     def array(sexp, level)
       return '[]' if sexp.empty?
@@ -914,7 +877,7 @@ module Opal
 
     # s(:hash, key1, val1, key2, val2...)
     def hash(sexp, level)
-      "$opal.hash(#{sexp.map { |p| process p, :expression }.join ', '})"
+      "Opal.hash(#{sexp.map { |p| process p, :expression }.join ', '})"
     end
 
     # s(:while, exp, block, true)
@@ -995,9 +958,10 @@ module Opal
     #
     # s(:alias, s(:lit, :foo), s(:lit, :bar))
     def alias(exp, level)
+      @helpers['alias'] = true
       new = exp[0]
       old = exp[1]
-      "$opal.alias(this, #{process new, :expression}, #{process old, :expression})"
+      "__alias(this, #{process new, :expression}, #{process old, :expression})"
     end
 
     def masgn(sexp, level)
@@ -1023,11 +987,11 @@ module Opal
 
         if l.first == :splat
           s = l[1]
-          s << s(:js_tmp, "$slice.call(#{tmp}, #{idx})")
+          s << s(:js_tmp, "__slice.call(#{tmp}, #{idx})")
           code << process(s, :expression)
         else
           if idx >= len
-            l << s(:js_tmp, "(#{tmp}[#{idx}] === undefined ? nil : #{tmp}[#{idx}])")
+            l << s(:js_tmp, "(#{tmp}[#{idx}] == null ? nil : #{tmp}[#{idx}])")
           else
             l << s(:js_tmp, "#{tmp}[#{idx}]")
           end
@@ -1049,7 +1013,8 @@ module Opal
       rhs  = sexp[1]
       lvar = "#{lvar}$".intern if RESERVED.include? lvar.to_s
       @scope.add_local lvar
-      "#{lvar} = #{process rhs, :expression}"
+      res = "#{lvar} = #{process rhs, :expression}"
+      level == :receiver ? "(#{res})" : res
     end
 
     # s(:lvar, :lvar)
@@ -1079,25 +1044,24 @@ module Opal
     # s(:gvar, gvar)
     def gvar(sexp, level)
       gvar = sexp.shift.to_s
-      tmp = @scope.new_temp
-      code = "((#{tmp} = $opal.gvars[#{gvar.inspect}]) == null ? nil : #{tmp})"
-      @scope.queue_temp tmp
-      code
+      @helpers['gvars'] = true
+      "__gvars[#{gvar.inspect}]"
     end
 
     # s(:gasgn, :gvar, rhs)
     def gasgn(sexp, level)
       gvar = sexp[0]
       rhs  = sexp[1]
-      "($opal.gvars[#{gvar.to_s.inspect}] = #{process rhs, :expression})"
+      @helpers['gvars'] = true
+      "__gvars[#{gvar.to_s.inspect}] = #{process rhs, :expression}"
     end
 
     # s(:const, :const)
     def const(sexp, level)
       if @debug
-        "$opal.const_get($const, #{sexp.shift.to_s.inspect})"
+        "Opal.const_get(__scope, #{sexp.shift.to_s.inspect})"
       else
-        "$const.#{sexp.shift}"
+        "__scope.#{sexp.shift}"
       end
     end
 
@@ -1105,7 +1069,7 @@ module Opal
     def cdecl(sexp, level)
       const = sexp[0]
       rhs   = sexp[1]
-      "$const.#{const} = #{process rhs, :expression}"
+      "__scope.#{const} = #{process rhs, :expression}"
     end
 
     # s(:return [val])
@@ -1134,7 +1098,7 @@ module Opal
         if String === p
           p.to_s
         elsif p.first == :evstr
-          process p.last, :expression
+          process p.last, :statement
         elsif p.first == :str
           p.last.to_s
         else
@@ -1153,7 +1117,7 @@ module Opal
         if String === p
           p.inspect
         elsif p.first == :evstr
-          process(s(:call, p.last, :to_s, s(:arglist)), :expression)
+          process p.last, :expression
         elsif p.first == :str
           p.last.inspect
         else
@@ -1161,7 +1125,8 @@ module Opal
         end
       end
 
-      "(#{parts.join ' + '})"
+      res = parts.join ' + '
+      level == :receiver ? "(#{res})" : res
     end
 
     def dsym(sexp, level)
@@ -1182,19 +1147,19 @@ module Opal
 
     # s(:if, test, truthy, falsy)
     def if(sexp, level)
-      test = sexp[0]
+      test   = sexp[0]
       truthy = sexp[1]
-      falsy = sexp[2]
+      falsy  = sexp[2]
 
       if level == :expression or level == :receiver
         truthy = returns(truthy || s(:nil))
         falsy = returns(falsy || s(:nil))
       end
 
-      code = "if (#{js_truthy test}) {"
-      indent { code += process(truthy, :statement) } if truthy
-      indent { code += "} else {#{process falsy, :statement}" } if falsy
-      code += "#{fix_line sexp.end_line}}"
+      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
+      code += "\n#@indent}"
 
       code = "(function() { #{code}; return nil; }).call(this)" if level == :expression or level == :receiver
 
@@ -1237,8 +1202,8 @@ module Opal
         }
       end
 
-      code = "(#{tmp} = #{process lhs, :expression}, #{tmp} !== false && "
-      code += "#{tmp} != nil ? #{process rhs, :expression} : #{tmp})"
+      code = "((#{tmp} = #{process lhs, :expression}, #{tmp} !== false && "
+      code += "#{tmp} !== nil) ? #{process rhs, :expression} : #{tmp})"
       @scope.queue_temp tmp
 
       code
@@ -1258,7 +1223,7 @@ module Opal
       end
 
       code = "(#{tmp} = #{process lhs, :expression}, #{tmp} !== false && "
-      code += "#{tmp} != nil ? #{tmp} : #{process rhs, :expression})"
+      code += "#{tmp} !== nil ? #{tmp} : #{process rhs, :expression})"
       @scope.queue_temp tmp
 
       code
@@ -1266,25 +1231,35 @@ module Opal
 
     # s(:yield, arg1, arg2)
     def yield(sexp, level)
+              # puts sexp.inspect
+              # puts level.inspect
       @scope.uses_block!
       splat = sexp.any? { |s| s.first == :splat }
-      sexp.unshift s(:js_tmp, '$context') unless splat
+      # sexp.unshift s(:js_tmp, 'null')
+      sexp.unshift s(:js_tmp, '__context') unless splat
       args = arglist(sexp, level)
 
+      yielder = @scope.block_name || '__yield'
+
       call =  if splat
-                "$yield.apply($context, #{args})"
+                "#{yielder}.apply(__context, #{args})"
               else
-                "$yield.call(#{args})"
+                "#{yielder}.call(#{args})"
               end
 
-      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
+      # 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
+      # end
 
       code
     end
@@ -1298,7 +1273,7 @@ module Opal
           "break;"
         end
       else
-        "return ($breaker.$v = #{val}, $breaker)"
+        "return (__breaker.$v = #{val}, __breaker)"
       end
     end
 
@@ -1379,7 +1354,7 @@ module Opal
     # s(:cvar, name)
     def cvar(exp, level)
       tmp = @scope.new_temp
-      code = "((#{tmp} = $opal.cvars[#{exp.shift.to_s.inspect}]) == null ? nil : #{tmp})"
+      code = "((#{tmp} = Opal.cvars[#{exp.shift.to_s.inspect}]) == null ? null : #{tmp})"
       @scope.queue_temp tmp
       code
     end
@@ -1388,11 +1363,11 @@ module Opal
     #
     # s(:cvasgn, :@@name, rhs)
     def cvasgn(exp, level)
-      "($opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expression})"
+      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expression})"
     end
 
     def cvdecl(exp, level)
-      "($opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expression})"
+      "(Opal.cvars[#{exp.shift.to_s.inspect}] = #{process exp.shift, :expression})"
     end
 
     # BASE::NAME
@@ -1401,11 +1376,11 @@ module Opal
     def colon2(sexp, level)
       base = sexp[0]
       name = sexp[1]
-      "$opal.const_get((#{process base, :expression}).$const, #{name.to_s.inspect})"
+      "Opal.const_get((#{process base, :expression})._scope, #{name.to_s.inspect})"
     end
 
     def colon3(exp, level)
-      "$opal.const_get($opal.Object, #{exp.shift.to_s.inspect})"
+      "Opal.const_get(Opal.Object._scope, #{exp.shift.to_s.inspect})"
     end
 
     # super a, b, c
@@ -1416,14 +1391,33 @@ module Opal
       until sexp.empty?
         args << process(sexp.shift, :expression)
       end
-      "$opal.zuper(arguments.callee, this, [#{args.join ', '}])"
+
+      # args.unshift 'null'
+
+      js_super "[#{ args.join ', ' }]"
     end
 
     # super
     #
     # s(:zsuper)
     def zsuper(exp, level)
-      "$opal.zuper(arguments.callee, this, [])"
+
+      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})"
+
+      elsif @scope.type == :iter
+        chain, defn, mid = @scope.get_super_chain
+        "Opal.dsuper([#{chain.join ', '}], #{defn}, #{mid}, this, #{args})"
+
+      else
+        raise "Cannot call super() from outside a method block"
+      end
     end
 
     # a ||= rhs
@@ -1511,7 +1505,7 @@ module Opal
       }.join ', '
       err = "true" if err.empty?
 
-      if Sexp === args.last and [:lasgn, :iasgn].include? args.last.first
+      if Array === args.last and [:lasgn, :iasgn].include? args.last.first
         val = args.last
         val[2] = s(:js_tmp, "$err")
         val = process(val, :expression) + ";"