opal 0.3.2 → 0.3.6

data/{lib → opal_lib}/opal/ruby/nodes.rb

@@ -1,4 +1,5 @@
-class Opal::RubyParser < Racc::Parser
+module Opal
+  class RubyParser < Racc::Parser
 
   # Indent for generated code scopes; 2 spaces, never use tabs
   INDENT = '  '
@@ -90,6 +91,28 @@ class Opal::RubyParser < Racc::Parser
       @temp_queue = []
       # ivars..we need to make sure these exist (make sure they are nil if new)
       @ivars = []
+
+      # keep tabs on whether in while loop or not
+      @while_scope = 0
+      @while_scope_stack = []
+    end
+
+    def push_while_scope(while_scope)
+      @while_scope_stack << while_scope
+      @while_scope += 1
+    end
+
+    def pop_while_scope
+      @while_scope_stack.pop
+      @while_scope -= 1
+    end
+
+    def in_while_scope?
+      @while_scope > 0
+    end
+
+    def while_scope
+      @while_scope_stack.last
     end
 
     def ensure_ivar(name)
@@ -163,45 +186,76 @@ class Opal::RubyParser < Racc::Parser
     # keep track of the current line number in the generator
     attr_accessor :line
 
+    # expose top level options... useful for certain nodes to know if we are
+    # debug mode etc
+    attr_reader :opts
+
     def initialize(statements)
       super nil, statements
       @file_helpers = []
       @line = 1
       @mm_ids = []
+
+      @symbol_refs = {}
+      @symbol_count = 1
+
+      @regexp_refs = []
     end
 
-    # Register a method name that needs to be called to $opal.mm. This method
-    # will remove duplicates.
     def register_mm_id(mid)
       @mm_ids << mid unless @mm_ids.include? mid
     end
 
+    def register_symbol(sym)
+      if ref = @symbol_refs[sym]
+        ref
+      else
+        ref = @symbol_refs[sym] = "$symbol_#{@symbol_count}"
+        @symbol_count += 1
+        ref
+      end
+    end
+
     def generate(opts, level)
+      @opts = opts
       code = []
-      code << super(opts, level)
+      @statements.returns
+      # code << super(opts, level)
+      code << @statements.generate(opts, level)
+
+      pre = 'function $$(){'
+      post = "\n}\n"
+      # post = "\n\n}\nvar nil, $ac, $super, $break, $class, $def, $symbol, $range, "
+      # post += '$hash, $B, Qtrue, Qfalse, $cg;'
+      # local vars... only if we used any..
+      unless @scope_vars.empty?
+        post += "var #{@scope_vars.join ', '};"
+      end
 
-      pre = ''
-      pre += 'var nil = VM.Qnil, '
-      pre += '$class = VM.dc, $def = VM.dm, $symbol = VM.Y, '
-      pre += '$hash = VM.H, $block = VM.P, Qtrue = VM.Qtrue, Qfalse = VM.Qfalse;'
+      post += 'var nil = $rb.Qnil, $ac = $rb.ac, $super = $rb.S, $break = $rb.B, '
+      post += '$class = $rb.dc, $defn = $rb.dm, $defs = $rb.ds, $symbol = $rb.Y, '
+      post += '$hash = $rb.H, $B = $rb.P, Qtrue = $rb.Qtrue, Qfalse = $rb.Qfalse, '
+      post += '$cg = $rb.cg, $range = $rb.G'
 
-      # add method missing setup
-      if @mm_ids.length > 0
-        mm_ids = "VM.mm(['#{@mm_ids.join "', '"}']);"
-        pre += mm_ids
+      # symbols
+      @symbol_refs.each do |val, sym|
+        post += ", #{sym} = $symbol('#{val}')"
       end
 
-      # local vars... only if we used any..
-      unless @scope_vars.empty?
-        pre = pre + "var #{@scope_vars.join ', '};"
+      post += ';'
+
+      if @mm_ids.length > 0
+        post += "$rb.mm(['#{ @mm_ids.join "', '" }']);"
       end
 
       # ivars
       @ivars.each do |ivar|
-        pre += "if (self['#{ivar}'] == undefined) { self['#{ivar}'] = nil; }"
+        post += "if (self['#{ivar}'] == undefined) { self['#{ivar}'] = nil; }"
       end
 
-      pre + code.join('')
+      post += "return $$();\n"
+
+      pre + code.join('') + post
     end
   end
 
@@ -229,7 +283,7 @@ class Opal::RubyParser < Racc::Parser
       return NilNode.new.generate(opts, level) if @nodes.empty?
 
       @nodes.each do |node|
-        node_code = node.process opts, LEVEL_TOP
+        node_code = node.process opts, level
 
         if level <= LEVEL_TOP_CLOSURE
           # to prevent lots of trailing whitespace when we generate statements
@@ -274,6 +328,8 @@ class Opal::RubyParser < Racc::Parser
 
   class NumericNode < BaseNode
 
+    attr_accessor :value
+
     def initialize(val)
       @line = val[:line]
       @value = val[:value]
@@ -292,7 +348,7 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      "$symbol('#{@value}')"
+      opts[:top].register_symbol @value
     end
   end
 
@@ -315,8 +371,6 @@ class Opal::RubyParser < Racc::Parser
     def mid_to_jsid(id)
       return ".$m['#{id}']" if /[\!\=\?\+\-\*\/\^\&\%\@\|\[\]\<\>\~]/ =~ id
 
-      # FIXME: if our id is a reserved word in js, we need to also wrap it in
-      # brackets.
       return ".$m['#{id}']" if js_reserved_words.include? id
 
       # default we just do .method_name
@@ -332,26 +386,48 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      code, arg_res, recv, mid = '', [], nil, nil
+      # Special handlers
+      if @recv.is_a? NumericNode and @mid == '-@'
+        @recv.value = "-#{@recv.value}"
+        return @recv.generate opts, level
+
+      elsif @mid == "block_given?"
+        # name = opts[:scope].set_uses_block
+        return "($yy == $y.y ? Qfalse : Qtrue)"
+      end
 
-      # we need a temp var for the receiver, which we add to the front of
-      # the args to send.
+      code = ''
+      arg_res = []
+      recv = nil
+      mid = @mid
       tmp_recv = opts[:scope].temp_local
 
+      opts[:top].register_mm_id @mid
+
       # receiver
       if @recv.is_a? NumericNode
         recv = "(#{@recv.process opts, LEVEL_EXPR})"
       elsif @recv
         recv = @recv.process opts, LEVEL_EXPR
       else
-        recv = SelfNode.new.generate opts, LEVEL_EXPR
+        @recv = SelfNode.new
+        recv = "self"
+        mid = '$' + mid
       end
 
-      # method id
-      mid = mid_to_jsid @mid
+      mid = mid_to_jsid(mid)
+
+      if @recv.is_a? SelfNode
+        recv_code = recv
+        recv_arg = recv
+      elsif @recv.is_a?(IdentifierNode) and @recv.local_variable?(opts)
+        recv_code = recv
+        recv_arg = recv
+      else
+        recv_code = "(#{tmp_recv} = #{recv})"
+        recv_arg = "#{tmp_recv}"
+      end
 
-      # Register our method_id to ensure $opal.mm gets it
-      opts[:top].register_mm_id @mid
 
       args = @args
       # normal args
@@ -367,18 +443,13 @@ class Opal::RubyParser < Racc::Parser
       end
 
       if @block
-        # tmp_self = opts[:scope].temp_local
-        tmp_args = opts[:scope].temp_local
         block = @block.generate opts, LEVEL_TOP
-        arg_res.unshift tmp_recv
+        arg_res.unshift recv_arg
 
-        code = "(#{tmp_recv} = #{recv}, #{tmp_args} = [#{arg_res.join ', '}]"
-        code += ", ($block.p = #{block}).$self = #{SelfNode.new.generate opts, level}"
-        code += ", ($block.f = #{tmp_recv}#{mid}).apply(#{tmp_recv}, #{tmp_args}))"
+        code = "($B.f = #{recv_code}#{mid}, ($B.p ="
+        code += "#{block}).$proc =[self], $B.f)(#{arg_res.join ', '})"
 
         opts[:scope].queue_temp tmp_recv
-        opts[:scope].queue_temp tmp_args
-
         code
 
       # &to_proc. Note, this must not reassign the $self for the proc.. we are
@@ -386,16 +457,12 @@ class Opal::RubyParser < Racc::Parser
       #
       # FIXME need to actually call to_proc.
       elsif args[3]
-        tmp_args = opts[:scope].temp_local
-
-        arg_res.unshift tmp_recv
+        arg_res.unshift recv_arg
 
-        code = "(#{tmp_recv} = #{recv}, #{tmp_args} = [#{arg_res.join ', '}]"
-        code += ", ($block.p = #{args[3].process opts, LEVEL_LIST})"
-        code += ", ($block.f = #{tmp_recv}#{mid}).apply(#{tmp_recv}, #{tmp_args}))"
+        code = "($B.p = #{args[3].process opts, LEVEL_LIST}, "
+        code += "$B.f = #{recv_code}#{mid})(#{arg_res.join ', '})"
 
         opts[:scope].queue_temp tmp_recv
-        opts[:scope].queue_temp tmp_args
 
         code
 
@@ -403,22 +470,20 @@ class Opal::RubyParser < Racc::Parser
       else
         # splat args
         if args[1]
-          arg_res.unshift tmp_recv
+          arg_res.unshift recv_arg
           splat = args[1].generate(opts, LEVEL_EXPR)
-          splat_args = arg_res.empty? ? splat : "[#{arg_res.join ', '}].concat(#{splat})"
+          splat_args = arg_res.empty? ? "#{splat}" : "[#{arg_res.join ', '}].concat(#{splat})"
           # when using splat, our this val for apply may need a tmp var
           # to save just outputting it twice (have to follow recv path twice)
           splat_recv = recv
-          result = "(#{tmp_recv} = #{recv})" + mid + ".apply(nil, #{splat_args})"
+          result = "#{recv_code}" + mid + ".apply(nil, #{splat_args})"
 
           opts[:scope].queue_temp tmp_recv
           result
         else
-          arg_res.unshift tmp_recv
+          arg_res.unshift recv_arg
 
-          result = "(#{tmp_recv} = #{recv})" + mid + '(' + arg_res.join(', ') + ')'
-
-          # requeue the tmp receiver as we are done with it and return
+          result = "#{recv_code}#{mid}(#{arg_res.join(', ')})"
           opts[:scope].queue_temp tmp_recv
           result
         end
@@ -466,7 +531,7 @@ class Opal::RubyParser < Racc::Parser
       if @base.nil?
         code += SelfNode.new.generate(opts, level)
       else
-        code += 'w'
+        code += @base.generate(opts, level)
       end
 
       code += ', '
@@ -479,9 +544,14 @@ class Opal::RubyParser < Racc::Parser
 
       # scope
       scope = { :indent => opts[:indent] + INDENT, :top => opts[:top], :scope => self }
+      @statements.returns
       stmt = @statements.generate scope, LEVEL_TOP
 
-      code += ('function() { var self = this; ' + stmt)
+      if @scope_vars.empty?
+        code += ('function(self) { ' + stmt)
+      else
+        code += "function(self) {var #{@scope_vars.join ', '};#{stmt}"
+      end
 
       # fix line ending
       code += fix_line_number opts, @end_line
@@ -495,7 +565,6 @@ class Opal::RubyParser < Racc::Parser
 
     def initialize(cls, path, sup, body, _end)
       super nil, body
-      @scope_vars << 'self = this'
       @line = cls[:line]
       @base = path[0]
       @cls_name = path[1]
@@ -507,7 +576,7 @@ class Opal::RubyParser < Racc::Parser
       code = '$class('
 
       # base
-      code += (@base.nil? ? SelfNode.new.generate(opts, level) : 'w')
+      code += (@base.nil? ? SelfNode.new.generate(opts, level) : @base.generate(opts, level))
       code += ', '
 
       # superclass
@@ -519,8 +588,14 @@ class Opal::RubyParser < Racc::Parser
 
       # scope
       scope = { :indent => opts[:indent] + INDENT, :top => opts[:top], :scope => self }
+      @statements.returns
       stmt = @statements.generate scope, level
-      code += "function() { var #{@scope_vars.join ', '};#{stmt}"
+
+      if @scope_vars.empty?
+        code += "function(self) {#{stmt}"
+      else
+        code += "function(self) { var #{@scope_vars.join ', '};#{stmt}"
+      end
 
       # fix trailing line number
       code += fix_line_number opts, @end_line
@@ -530,6 +605,41 @@ class Opal::RubyParser < Racc::Parser
     end
   end
 
+  class ClassShiftNode < ScopeNode
+
+    def initialize(cls, expr, body, endn)
+      super nil, body
+      @line = cls[:line]
+      @expr = expr
+      @end_line = endn[:line]
+    end
+
+    def generate(opts, level)
+      code = '$class('
+
+      # base
+      code += @expr.generate(opts, level)
+      code += ', nil, nil, '
+
+      # scope
+      scope = { :indent => opts[:indent] + INDENT, :top => opts[:top], :scope => self }
+      @statements.returns
+      stmt = @statements.generate scope, level
+
+      if @scope_vars.empty?
+        code += "function(self) {#{stmt}"
+      else
+        code += "function(self) { var #{@scope_vars.join ', '};#{stmt}"
+      end
+
+      # fix trailing line number
+      code += fix_line_number opts, @end_line
+
+      code += opts[:indent] + '}, 1)'
+      code
+    end
+  end
+
   class DefNode < ScopeNode
 
     def initialize(defn, singleton, fname, args, body, endn)
@@ -544,11 +654,11 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      code = '$def('
-
-      # singleton
-      code += (@singleton ? @singleton.generate(opts, level) : SelfNode.new.generate(opts, level))
-      code += ', '
+      if @singleton
+        code = "$defs(#{@singleton.generate opts, level}, "
+      else
+        code = "$defn(self, "
+      end
 
       # method id
       code += "'#{@fname[:value]}', "
@@ -571,6 +681,8 @@ class Opal::RubyParser < Racc::Parser
         end
       end
 
+      arity = method_args.length
+
       # optional args
       if args[1]
         args[1].each do |arg|
@@ -582,23 +694,27 @@ class Opal::RubyParser < Racc::Parser
 
       # rest args
       if args[2]
-        param_variable args[2][:value]
-        method_args << args[2][:value]
-        pre_code += "#{args[2][:value]} = [].slice.call(arguments, #{method_args.length});"
+        if args[2][:value] != "*"
+          param_variable args[2][:value]
+          method_args << args[2][:value]
+          pre_code += "#{args[2][:value]} = [].slice.call(arguments, #{method_args.length});"
+        end
       end
 
+      arity = (-arity) - 1 if args[1] or args[2]
+
       # block arg
       if args[3]
         param_variable args[3][:value]
         @block_arg_name = args[3][:value]
+        pre_code += "var #{args[3][:value]} = (($yy == $y.y) ? nil: $yy);"
       end
 
       @body.returns
       stmt = @body.generate scope, LEVEL_TOP
-
       method_args.unshift 'self'
 
-      code += "function(#{method_args.join ', '}) { "
+      code += "function(#{method_args.join ', '}) {"
 
       # local vars... only if we used any..
       unless @scope_vars.empty?
@@ -607,19 +723,23 @@ class Opal::RubyParser < Racc::Parser
 
       # ivars
       @ivars.each do |ivar|
-        pre_code += "if (self['#{ivar}'] == undefined) { self['#{ivar}'] = nil; }"
+        pre_code += "self['#{ivar}']==undefined&&(self['#{ivar}']=nil);"
       end
 
-      # block arg
+      # block support
       if @block_arg_name
-        pre_code += " var #{@block_arg_name} = ($block.f == arguments.callee)"
-        pre_code += " ? $block.p : nil; $block.p = $block.f = nil;"
+
+        block_code = "var $y = $B, $yy, $ys, $yb = $y.b;"
+        block_code += "if ($y.f == arguments.callee) { $yy = $y.p; }"
+        block_code += "else { $yy = $y.y; }"
+        block_code += "$y.f = nil ;$ys = $yy.$proc[0];"
+        pre_code = block_code + pre_code
       end
 
       code += (pre_code + stmt)
 
       # fix trailing end and 0/1 for normal/singleton
-      code += (fix_line_number(opts, @end_line) + "}, #{@singleton ? '1' : '0'})")
+      code += (fix_line_number(opts, @end_line) + "}, #{arity})")
 
       code
     end
@@ -685,8 +805,8 @@ class Opal::RubyParser < Racc::Parser
   class ArrayNode < BaseNode
 
     def initialize(parts, begn, endn)
-      @line = begn[:line]
-      @end_line = endn[:line]
+      @line = begn[:line] || 0
+      @end_line = endn[:line] || 0
       @args = parts
     end
 
@@ -694,15 +814,23 @@ class Opal::RubyParser < Racc::Parser
     # on a new line are indented to that of the array beg/end
     def generate(opts, level)
       parts = @args[0].map { |arg| arg.process opts, LEVEL_LIST }
-      "[#{parts.join ', '}#{fix_line_number opts, @end_line}]"
+      code = "[#{parts.join ', '}#{fix_line_number opts, @end_line}]"
+
+      if @args[1]
+        res = "#{code}.concat(#{@args[1].generate opts, LEVEL_EXPR})"
+      else
+        res = code
+      end
+
+      res
     end
   end
 
   class HashNode < BaseNode
 
     def initialize(parts, begn, endn)
-      @line = begn[:line]
-      @end_line = endn[:line]
+      @line = begn[:line] || 0
+      @end_line = endn[:line] || 0
       @parts = parts
     end
 
@@ -715,6 +843,7 @@ class Opal::RubyParser < Racc::Parser
   class IfNode < BaseNode
 
     def initialize(begn, expr, stmt, tail, endn)
+      @type = begn[:value]
       @line = begn[:line]
       @end_line = endn[:line]
       @expr = expr
@@ -740,9 +869,12 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      code, done_else, tail, old_indent = '', false, nil, opts[:indent]
+      code = ''
+      done_else = false
+      tail = nil
+      old_indent = opts[:indent]
 
-      opts[:indent] += INDENT
+      opts[:indent] = opts[:indent] + INDENT
 
       # stmt_level is level_top, unless we are an expression.. then it is level_top_closure..
       stmt_level = (level == LEVEL_EXPR ? LEVEL_TOP_CLOSURE : LEVEL_TOP)
@@ -752,20 +884,27 @@ class Opal::RubyParser < Racc::Parser
         @level_expr = true
       end
 
-      code += "if ((#{@expr.generate opts, LEVEL_EXPR}).$r) {#{@stmt.process opts, stmt_level}"
+      expr = @expr.generate opts, LEVEL_EXPR
+      expr = "(#{expr})" if @expr.is_a? NumericNode
+
+      # code += "if ((#{@expr.generate opts, LEVEL_EXPR}).$r) {#{@stmt.process opts, stmt_level}"
+      code += "if (#{@type == 'if' ? '' : '!'}#{expr}.$r) {#{@stmt.process opts, stmt_level}"
 
       @tail.each do |tail|
         opts[:indent] = old_indent
-        code += fix_line_number opts, tail[0][:line]
+        code = code + fix_line_number(opts, tail[0][:line])
 
         if tail[0][:value] == 'elsif'
-          code += "} else if ((#{tail[1].generate opts, LEVEL_EXPR}).$r) {"
-          opts[:indent] += INDENT
-          code += tail[2].process(opts, stmt_level)
+          expr = tail[1].generate opts, LEVEL_EXPR
+          expr = "(#{expr})" if tail[1].is_a? NumericNode
+          code += "} else if (#{expr}.$r) {"
+          # code += "} else if ((#{tail[1].generate opts, LEVEL_EXPR}).$r) {"
+          opts[:indent] = opts[:indent] + INDENT
+          code = code + tail[2].process(opts, stmt_level)
         else
           done_else = true
           code += '} else {'
-          opts[:indent] += INDENT
+          opts[:indent] = opts[:indent] + INDENT
           code += tail[1].process(opts, stmt_level)
         end
       end
@@ -780,11 +919,92 @@ class Opal::RubyParser < Racc::Parser
       code += (fix_line_number(opts, @end_line) + '}')
 
       # if we were an expression, we need to wrap ourself as closure
+      code = "(function() {#{code}})()" if level == LEVEL_EXPR
+      code
+    end
+  end
+
+  class CaseNode < BaseNode
+
+    def initialize(begn, expr, body, endn)
+      @line = begn[:line]
+      @expr = expr
+      @body = body
+      @end_line = endn[:line]
+    end
+
+    def returns
+      @body.each do |part|
+        if part[0][:value] == 'when'
+          part[2].returns
+        else
+          part[1].returns
+        end
+      end
+      self
+    end
+
+    def generate(opts, level)
+      code = ''
+      done_else = false
+      tail = nil
+      old_indent = opts[:indent]
+
+      opts[:indent] = opts[:indent] + INDENT
+
+      stmt_level = (level == LEVEL_EXPR ? LEVEL_TOP_CLOSURE : LEVEL_TOP)
+
+      if stmt_level == LEVEL_TOP_CLOSURE
+        returns
+        @level_expr = true
+      end
+
+      expr = @expr.generate opts, LEVEL_EXPR
+      case_ref = opts[:scope].temp_local
+
+      code += "#{case_ref} = #{expr};"
+
+      @body.each_with_index do |part, idx|
+        opts[:indent] = old_indent
+        code += fix_line_number opts, part[0][:line]
+
+        if part[0][:value] == 'when'
+          code += (idx == 0 ? "if" : "} else if")
+          parts = part[1].map do |expr|
+            CallNode.new(expr,
+                        {:value => '===' },
+                        [[TempNode.new(case_ref)]]
+            ).generate(opts, LEVEL_EXPR) + '.$r'
+          end
+          opts[:indent] = opts[:indent] + INDENT
+          code += " (#{parts.join ' || '}) {#{part[2].process opts, stmt_level}"
+        else
+          code += "} else {#{part[1].process opts, stmt_level}"
+        end
+      end
+
+      opts[:indent] = old_indent
+
+      opts[:scope].queue_temp case_ref
+      code += (fix_line_number(opts, @end_line) + '}')
+
       code = "(function() {#{code})()" if level == LEVEL_EXPR
       code
     end
   end
 
+  class TempNode < BaseNode
+
+    def initialize(val)
+      @val = val
+      @line = 0
+    end
+
+    def generate(opts, level)
+      @val
+    end
+  end
+
   class ConstantNode < BaseNode
 
     def initialize(name)
@@ -797,7 +1017,7 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      "rb_vm_cg(#{SelfNode.new.generate opts, level}, '#{@name}')"
+      "$cg(#{SelfNode.new.generate opts, level}, '#{@name}')"
     end
   end
 
@@ -811,7 +1031,7 @@ class Opal::RubyParser < Racc::Parser
 
     def generate(opts, level)
       # FIXME This should really be 'const at'.. const_get will relook all the way up chain
-      "rb_vm_cg(#{@lhs.generate opts, level}, '#{@name}')"
+      "$cg(#{@lhs.generate opts, level}, '#{@name}')"
     end
   end
 
@@ -840,17 +1060,22 @@ class Opal::RubyParser < Racc::Parser
         return "#{SelfNode.new.generate(opts, level)}['#{@lhs.value}'] = #{@rhs.generate(opts, LEVEL_EXPR)}"
 
       elsif @lhs.is_a? GvarNode
-        return "VM.gs('#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
+        return "$rb.gs('#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
 
       elsif @lhs.is_a? IdentifierNode
         opts[:scope].ensure_variable @lhs.value
+
+        # optimize yield assigning
+        if @rhs.is_a?(YieldNode) and level == LEVEL_TOP
+          return @rhs.generate_assign(opts, @lhs)
+        end
         return @lhs.value + " = " + @rhs.generate(opts, LEVEL_EXPR)
 
       elsif @lhs.is_a? ArefNode
         return AsetNode.new(@lhs.recv, @lhs.arefs, @rhs).process(opts, level)
 
       elsif @lhs.is_a? ConstantNode
-        return "rb_vm_cs(self, '#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
+        return "$rb.cs(self, '#{@lhs.value}', #{@rhs.generate(opts, LEVEL_EXPR)})"
 
       elsif @lhs.is_a? CallNode
         return CallNode.new(@lhs.recv, { :value => @lhs.mid + '=', :line => @line }, [[@rhs]]).generate(opts, level);
@@ -861,6 +1086,54 @@ class Opal::RubyParser < Racc::Parser
     end
   end
 
+  class MlhsAssignNode < BaseNode
+
+    def initialize(node, lhs, rhs)
+      @line = node[:line]
+      @lhs = lhs
+      @rhs = rhs
+    end
+
+    def generate(opts, level)
+      @lhs.inspect
+      @generator_opts = opts
+      '(' + generate_mlhs_context(@lhs, @rhs) + ')'
+    end
+
+    def generate_mlhs_context(arr, rhs)
+      puts "mlhs node at #@line"
+      parts = []
+
+      tmp_recv = @generator_opts[:scope].temp_local
+      tmp_len = @generator_opts[:scope].temp_local
+      rhs_code = rhs.generate @generator_opts, LEVEL_EXPR
+
+      parts << "#{tmp_recv} = #{rhs_code}"
+      parts << "(#{tmp_recv}.$flags & $rb.T_ARRAY) || (#{tmp_recv} = [#{tmp_recv}])"
+      parts << "#{tmp_len} = #{tmp_recv}.length"
+
+      if arr[0]
+        arr[0].each_with_index do |part, idx|
+          if part.is_a? Array
+            parts.push generate_mlhs_context part, rhs
+          else
+            assign = AssignNode.new part, TempNode.new("#{tmp_recv}[#{idx}]")
+            code = assign.generate @generator_opts, LEVEL_EXPR
+            parts.push "#{idx} < #{tmp_len} ? #{code} : nil"
+            # parts.push assign.generate @generator_opts, LEVE<D-/>L_EXPR
+          end
+        end
+      end
+
+      parts << tmp_recv
+
+      @generator_opts[:scope].queue_temp tmp_recv
+      @generator_opts[:scope].queue_temp tmp_len
+
+      parts.join ', '
+    end
+  end
+
   class OpAsgnNode < BaseNode
 
     def initialize(asgn, lhs, rhs)
@@ -900,7 +1173,6 @@ class Opal::RubyParser < Racc::Parser
   end
 
   class IdentifierNode < BaseNode
-
     attr_reader :value
 
     def initialize(val)
@@ -908,6 +1180,10 @@ class Opal::RubyParser < Racc::Parser
       @value = val[:value]
     end
 
+    def local_variable?(opts)
+      opts[:scope].find_variable(@value) ? true : false
+    end
+
     def generate(opts, level)
       if opts[:scope].find_variable @value
         @value
@@ -943,6 +1219,8 @@ class Opal::RubyParser < Racc::Parser
       elsif @parts.length == 1
         if @parts[0][0] == 'string_content'
           @join + @parts[0][1][:value] + @join
+        elsif @parts[0][0] == 'string_dbegin'
+          CallNode.new(@parts[0][1], { :value => 'to_s', :line => 0 }, [[]]).generate(opts, level)
         end
 
       else
@@ -1006,6 +1284,18 @@ class Opal::RubyParser < Racc::Parser
           args[0].each do |arg|
             param_variable arg[:value]
             method_args << arg[:value]
+
+            # Argument checking.. If normal args are required but not passed
+            # they just default to nil. Lambdas have the same effect as
+            # methods, so we check this by wrapping lambdas in an anon
+            # function that knows the arity of this block. So here, make all
+            # norm args nil if not present.
+            #
+            # Also, this is optional, and can be turned on/off for
+            # performance gains.
+            if true
+              pre_code += "if (#{arg[:value]} === undefined) { #{arg[:value]} = nil; }"
+            end
           end
         end
 
@@ -1015,17 +1305,26 @@ class Opal::RubyParser < Racc::Parser
             opt_arg_name = arg[0][:value]
             param_variable opt_arg_name
             method_args << arg[0][:value]
-            pre_code += "if (#{opt_arg_name} == undefined) { #{opt_arg_name} = #{arg[1].generate(opts, level)};}"
+            pre_code += "if (#{opt_arg_name} === undefined) { #{opt_arg_name} = #{arg[1].generate(opts, level)};}"
           end
         end
 
         # rest args
         if args[2]
+          # ignore rest arg if it is anonymous
+          unless args[2][:value] == '*'
           rest_arg_name = args[2][:value]
           # FIXME if we just pass '*', then we make a tmp variable name for it..
           param_variable rest_arg_name
           method_args << rest_arg_name
-          pre_code += "#{rest_arg_name} = [].slice.call(arguments, #{method_args.length});"
+          pre_code += "#{rest_arg_name} = [].slice.call($A, #{method_args.length});"
+          end
+        end
+
+        # block arg
+        if args[3]
+          param_variable args[3][:value]
+          @block_arg_name = args[3][:value]
         end
       end
 
@@ -1033,13 +1332,33 @@ class Opal::RubyParser < Racc::Parser
       stmt = @stmt.process scope, LEVEL_TOP
       method_args.unshift 'self'
 
+      block_var = opts[:scope].temp_local
+      # code += "(#{block_var} = "
+
       code += "function(#{method_args.join ', '}) {"
-      
+
       unless @scope_vars.empty?
         code += " var #{@scope_vars.join ', '};"
       end
 
+      # block arg
+      if @block_arg_name
+          pre_code += "var $yield, #@block_arg_name; if ($B.f == arguments.callee && $B.p != nil) { #@block_arg_name = "
+          pre_code += "$yield = $B.p; } else { #@block_arg_name = nil; "
+          pre_code += "$yield = $B.y; } $B.p = $B.f = nil;"
+          pre_code += "var $yself = $yield.$proc[0];"
+
+          stmt = "try{" + stmt
+
+          # catch break statements
+          stmt += "} catch (__err__) {if(__err__.$keyword == 2) {return __err__.$value;} throw __err__;}"
+      end
+
       code += (pre_code + stmt + fix_line_number(opts, @end_line) + "}")
+
+      # code += ", #{block_var}.$arity = 0, #{block_var}.$meth = null"
+      # code += ", #{block_var})"
+      opts[:scope].queue_temp block_var
       code
     end
   end
@@ -1123,7 +1442,8 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      (@arefs[0] ||= []) << @val
+      @arefs[0] || (@arefs[0] = [])
+      @arefs[0] << @val
       CallNode.new(@recv, { :line => @line, :value => '[]='}, @arefs ).generate(opts, level)
     end
   end
@@ -1160,36 +1480,239 @@ class Opal::RubyParser < Racc::Parser
     end
   end
 
-  class BlockGivenNode < BaseNode
+  class YieldNode < BaseNode
+
+    def initialize(start, args)
+      @line = start[:line]
+      @args = args
+    end
+
+    # Get basic yielding code yield(yself,...)
+    def yield_code(opts)
+      block_code = "$yy"
+
+      parts = []
+
+      if @args[0]
+        @args[0].each { |arg| parts << arg.generate(opts, LEVEL_EXPR) }
+      end
+
+      if @args[1]
+        parts.unshift '$ys'
+        code = "#{block_code}(null, [#{parts.join ', '}].concat(#{@args[1].generate(opts, LEVEL_EXPR)}))"
+      else
+        parts.unshift '$ys'
+        code = "#{block_code}(#{parts.join ', '})"
+      end
 
-    def initialize(given)
-      @line = given[:line]
+      code
     end
 
     def generate(opts, level)
-      name = opts[:scope].set_uses_block
-      "(#{name} !== nil ? Qtrue : Qfalse)"
+      # need to get block from nearest method
+      block = opts[:scope].set_uses_block
+      code = yield_code opts
+
+      if level == LEVEL_TOP
+        "if (#{code} == $yb) { return $yb.$value; }"
+      else
+        # basically we need to return out of this method and we are not
+        # top level so we will need to throw and error which is caught
+        # directly inside this method which just returns the break
+        # value. We should warn that the given code is going to cause
+        # a try/catch statement to be added to check for this. i.e. this
+        # can/should be optimized out in the source code
+        tmp = opts[:scope].temp_local
+        "((#{tmp} = #{code}) == $yb ? $break() : #{tmp})"
+      end
+    end
+
+    # special generator for assigning to variable. We know we will be
+    # top level if this is called.
+    def generate_assign(opts, lhs)
+      "if ((#{lhs.value} = #{yield_code opts}) == $yb) { return $yb.$value; }"
     end
   end
 
-  class YieldNode < BaseNode
+  class BreakNode < BaseNode
 
     def initialize(start, args)
       @line = start[:line]
       @args = args
     end
 
+    # as we either throw or return ourself we can ignore the
+    # request to return ourself if last statement
+    def returns
+      self
+    end
+
     def generate(opts, level)
-      # need to get block from nearest method
-      block = opts[:scope].set_uses_block
+      code = []
+
+      if @args[0]
+        @args[0].each { |arg| code << arg.generate(opts, LEVEL_EXPR) }
+      end
+
+      case code.length
+      when 0
+        code = "nil"
+      when 1
+        code = code[0]
+      else
+        code = '[' + code.join(', ') + ']'
+      end
+
+      if opts[:scope].in_while_scope?
+        while_scope = opts[:scope].while_scope
+        tmp_break_val = while_scope.set_captures_break
+        "#{tmp_break_val} = #{code}; break"
+      elsif opts[:scope].is_a? BlockNode
+        if level == LEVEL_TOP
+          "return ($B.b.$value = #{code}, $B.b)"
+        else
+          # block must have a try/catch wrapper inside to detect
+          # breaks and return the break value if a break is fired.
+          # We should also warn that the ruby code is not optimized
+          # and suggest it is reconfigured to avoid the (possibly)
+          # expensive try/catch block.
+          "$break(#{code})"
+        end
+      else
+        "$break(#{code})"
+      end
+    end
+  end
+
+  class NextNode < BaseNode
+
+    def initialize(start, args)
+      @line = start[:line]
+      @args = args
+    end
+
+    def returns
+      self
+    end
+
+    def generate(opts, level)
+      code = []
+
+      if @args[0]
+        @args[0].each { |arg| code << arg.generate(opts, LEVEL_EXPR) }
+      end
+
+      case code.length
+      when 0
+        code = "nil"
+      when 1
+        code = code[0]
+      else
+        code = '[' + code.join(', ') + ']'
+      end
+
+      if opts[:scope].in_while_scope?
+        "continue"
+      else
+      # if in block
+        "return #{code}"
+      # else if in while/until loop
+
+      end
+    end
+  end
+
+  class RedoNode < BaseNode
+
+    def initialize(start)
+      @line = start[:line]
+    end
+
+    def generate(opts, level)
+      if opts[:scope].in_while_scope?
+        "#{opts[:scope].while_scope.redo_var} = true"
+      else
+        "REDO()"
+      end
+    end
+  end
+
+  class WhileNode < BaseNode
+
+    attr_reader :redo_var
+
+    def initialize(begn, exp, stmt, endn)
+      @line = begn[:line]
+      @type = begn[:value]
+      @expr = exp
+      @stmt = stmt
+      @end_line = endn[:line]
+    end
+
+    def returns
+      @returns = true
+      self
+    end
+
+    def set_captures_break
+      tmp = @current_scope.temp_local
+      @captures_break = tmp
+    end
+
+    def generate(opts, level)
+      @current_scope = opts[:scope]
+      stmt_level = (level == LEVEL_EXPR ? LEVEL_TOP_CLOSURE : LEVEL_TOP)
+      truthy = @type == 'while' ? '' : '!'
+
+      if stmt_level == LEVEL_TOP_CLOSURE
+        returns
+        @level_expr = true
+      end
+
+      @redo_var = eval_expr = opts[:scope].temp_local
+      code = "#{eval_expr} = false; while (#{eval_expr} || #{truthy}("
+      code += @expr.generate opts, LEVEL_EXPR
+      code += ").$r) {#{eval_expr} = false;"
+
+      opts[:scope].push_while_scope self
+
+      code += @stmt.process opts, LEVEL_TOP
 
-      parts = ["#{block}.$self"]
+      opts[:scope].pop_while_scope
+
+      code += fix_line_number opts, @end_line
+      code += "}"
+
+      opts[:scope].queue_temp eval_expr
+
+      return_value = "nil"
+
+      if @captures_break
+        code = "#@captures_break = nil; #{code}"
+        opts[:scope].queue_temp @captures_break
+        return_value = @captures_break
+      end
+
+      code = "(function() {#{code} return #{return_value};})()" if stmt_level == LEVEL_TOP_CLOSURE
+      code
+    end
+  end
+
+  class SuperNode < BaseNode
+
+    def initialize(start, args)
+      @line = start[:line]
+      @args = args
+    end
+
+    def generate(opts, level)
+      parts = []
 
       if @args[0]
         @args[0].each { |arg| parts << arg.generate(opts, LEVEL_EXPR) }
       end
 
-      "#{block}(#{parts.join ', '})"
+      "$super(arguments.callee, self, [#{parts.join ', '}])"
     end
   end
 
@@ -1214,6 +1737,9 @@ class Opal::RubyParser < Racc::Parser
       else
         # this really should return array of return vals
         code = NilNode.new.generate opts, level
+        code = []
+        args[0].each { |arg| code << arg.generate(opts, LEVEL_EXPR) }
+        code = code = '[' + code.join(', ') + ']'
       end
 
       # if we are in a block, we need to throw return to nearest mthod
@@ -1241,16 +1767,16 @@ class Opal::RubyParser < Racc::Parser
     def generate(opts, level)
       code = "try {"
       old_indent = opts[:indent]
-      opts[:indent] += INDENT
+      opts[:indent] = opts[:indent] + INDENT
 
       code += @body.process opts, LEVEL_TOP
       code += "} catch (__err__) {"
 
       @body.opt_rescue.each do |res|
         code += "#{fix_line_number opts, res[0][:line]}if (true){"
-        opts[:indent] += INDENT
-        opts[:scope].ensure_variable res[2].value
-        code += (res[2].value + " = __err__;")
+        opts[:indent] = opts[:indent] + INDENT
+        opts[:scope].ensure_variable res[2].value if res[2]
+        code += (res[2].value + " = __err__;") if res[2]
         code += "#{res[3].process opts, LEVEL_TOP}}"
         opts[:indent] = old_indent + INDENT
       end
@@ -1262,6 +1788,20 @@ class Opal::RubyParser < Racc::Parser
     end
   end
 
+  class TernaryNode < BaseNode
+
+    def initialize(expr, truthy, falsy)
+      @line = expr.line
+      @expr = expr
+      @true = truthy
+      @false = falsy
+    end
+
+    def generate(opts, level)
+      "(#{@expr.generate opts, LEVEL_EXPR}.$r ? #{@true.generate opts, LEVEL_EXPR} : #{@false.generate opts, LEVEL_EXPR})"
+    end
+  end
+
   class GvarNode < BaseNode
 
     attr_reader :value
@@ -1272,7 +1812,7 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      "VM.gg('#{@value}')"
+      "$rb.gg('#{@value}')"
     end
   end
 
@@ -1295,8 +1835,89 @@ class Opal::RubyParser < Racc::Parser
     end
 
     def generate(opts, level)
-      @val
+      "(#{@val})"
+    end
+  end
+
+  class RegexpNode < BaseNode
+
+    def initialize(begn, parts)
+      @line = begn[:line]
+      @parts = parts
+    end
+
+    def generate(opts, level)
+      parts = @parts.map do |part|
+        if part[0] == 'string_content'
+          part[1][:value]
+        elsif part[0] == 'string_dbegin'
+          part[1].generate opts, LEVEL_EXPR
+        end
+      end
+
+      "/#{parts.join ''}/"
+    end
+  end
+
+  class WordsNode < BaseNode
+
+    def initialize(begn, parts, endn)
+      @line = begn[:line]
+      @parts = parts
+      @end_line = endn[:line]
+    end
+
+    def generate(opts, level)
+      parts = @parts.map do |part|
+        if part[0] == 'string_content'
+          part[1][:value].inspect
+        else
+          CallNode.new(part[1], {:value => 'to_s', :line => @line }, []).generate(opts, LEVEL_EXPR)
+        end
+      end
+
+      '[' + parts.join(', ') + ']'
+    end
+  end
+
+  class RangeNode < BaseNode
+
+    def initialize(range, beg, last)
+      @line = beg.line
+      @beg = beg
+      @last = last
+      @range = range[:value]
+      @end_line = last.line
+    end
+
+    def generate(opts, level)
+      beg = @beg.generate opts, LEVEL_EXPR
+      last = @last.generate opts, LEVEL_EXPR
+      excl = @range == '...'
+      "$range(#{beg}, #{last}, #{excl})"
+    end
+  end
+
+  class UndefNode < BaseNode
+
+    def initialize(start, parts)
+      @line = start[:line]
+      @parts = parts
+    end
+
+    def generate(opts, level)
+      parts = @parts.map do |a|
+        if a.is_a? SymbolNode
+          a.generate opts, level
+        else
+          '"' + a[:value] + '"'
+        end
+      end
+      parts.unshift 'self'
+      "$rb.um(#{parts.join ', '})"
     end
   end
 end
+end
+