opal 0.10.6 → 0.11.0.rc1

data/lib/opal/nodes/call_special.rb

@@ -1,251 +1,65 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 require 'opal/nodes/call'
 
 module Opal
   module Nodes
-    # recv.mid = rhs
-    # s(:recv, :mid=, s(:arglist, rhs))
-    class AttrAssignNode < CallNode
-      handle :attrasgn
+    # recvr.JS[:prop]
+    # => recvr.prop
+    class JsAttrNode < Base
+      handle :jsattr
+      children :recvr, :property
 
-      children :recvr, :meth, :arglist
-
-      def default_compile
-        # Skip, for now, if the method has square brackets: []=
-        return super if meth.to_s !~ /#{REGEXP_START}\w+=#{REGEXP_END}/
-
-        with_temp do |args_tmp|
-          with_temp do |recv_tmp|
-            args = expr(arglist)
-            mid = mid_to_jsid meth.to_s
-            push "((#{args_tmp} = [", args, "]), "+
-                 "#{recv_tmp} = ", recv(recv_sexp), ", ",
-                 recv_tmp, mid, ".apply(#{recv_tmp}, #{args_tmp}), "+
-                 "#{args_tmp}[#{args_tmp}.length-1])"
-          end
-        end
+      def compile
+        push recv(recvr), '[', expr(property), ']'
       end
     end
 
-    # recv.JS[1] = rhs
-    class JsAttrAssignNode < CallNode
+    # recvr.JS[:prop] = value
+    # => recvr.prop = value
+    class JsAttrAsgnNode < Base
       handle :jsattrasgn
 
-      def record_method?
-        false
-      end
+      children :recvr, :property, :value
 
-      def default_compile
-        push recv(recv_sexp), '[', expr(arglist[1]), ']', '=', expr(arglist[2])
+      def compile
+        push recv(recvr), '[', expr(property), '] = ', expr(value)
       end
     end
 
-    # recv.JS.prop
-    # recv.JS[1]
-    # recv.JS.meth(arg1, arg2)
     class JsCallNode < CallNode
       handle :jscall
 
-      def record_method?
-        false
-      end
-
-      def default_compile
-        if meth == :[]
-          push recv(recv_sexp), '[', expr(arglist), ']'
-        else
-          mid = ".#{meth}"
-
-          splat = arglist[1..-1].any? { |a| a.first == :splat }
-
-          if Sexp === arglist.last and arglist.last.type == :block_pass
-            block = arglist.pop
-          elsif iter
-            block = iter
-          end
+      def initialize(*)
+        super
 
-          blktmp  = scope.new_temp if block
-          tmprecv = scope.new_temp if splat
-
-          # must do this after assigning temp variables
-          block = expr(block) if block
-
-          recv_code = recv(recv_sexp)
-          call_recv = s(:js_tmp, blktmp || recv_code)
-
-          if blktmp
-            arglist.push call_recv
-          end
-
-          args = expr(arglist)
-
-          if tmprecv
-            push "(#{tmprecv} = ", recv_code, ")#{mid}"
-          else
-            push recv_code, mid
-          end
-
-          if blktmp
-            unshift "(#{blktmp} = ", block, ", "
-            push ")"
-          end
-
-          if splat
-            push ".apply(", tmprecv, ", ", args, ")"
-          else
-            push "(", args, ")"
-          end
-
-          scope.queue_temp blktmp if blktmp
+        # For .JS. call we pass a block
+        # as a plain JS callback
+        if @iter
+          @arglist = @arglist << @iter
         end
+        @iter = nil
       end
-    end
-
-    # lhs =~ rhs
-    # s(:match3, lhs, rhs)
-    class Match3Node < Base
-      handle :match3
-
-      children :lhs, :rhs
-
-      def compile
-        sexp = s(:call, lhs, :=~, s(:arglist, rhs))
-        push process(sexp, @level)
-      end
-    end
-
-    # a ||= rhs
-    # s(:op_asgn_or, s(:lvar, :a), s(:lasgn, :a, rhs))
-    class OpAsgnOrNode < Base
-      handle :op_asgn_or
-
-      children :recvr, :rhs
 
       def compile
-        sexp = s(:or, recvr, rhs)
-        push expr(sexp)
+        default_compile
       end
-    end
-
-    # a &&= rhs
-    # s(:op_asgn_and, s(:lvar, :a), s(:lasgn, a:, rhs))
-    class OpAsgnAndNode < Base
-      handle :op_asgn_and
-
-      children :recvr, :rhs
 
-      def compile
-        sexp = s(:and, recvr, rhs)
-        push expr(sexp)
+      def method_jsid
+        "." + meth.to_s
       end
     end
 
-    # lhs[args] ||= rhs
-    # s(:op_asgn1, lhs, args, :||, rhs)
-    class OpAsgn1Node < Base
-      handle :op_asgn1
-
-      children :lhs, :args, :op, :rhs
-
-      def first_arg
-        args[1]
-      end
-
-      def compile
-        case op.to_s
-        when '||' then compile_or
-        when '&&' then compile_and
-        else compile_operator
-        end
-      end
-
-      def compile_operator
-        with_temp do |a| # args
-          with_temp do |r| # recv
-            cur = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
-            rhs = s(:call, cur, op.to_sym, s(:arglist, self.rhs))
-            call = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
-
-            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
-            push ", ", expr(call), ")"
-          end
-        end
-      end
-
-      def compile_or
-        with_temp do |a| # args
-          with_temp do |r| # recv
-            aref = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
-            aset = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
-            orop = s(:or, aref, aset)
-
-            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
-            push ", ", expr(orop), ")"
-          end
-        end
-      end
-
-      def compile_and
-        with_temp do |a| # args
-          with_temp do |r| # recv
-            aref = s(:call, s(:js_tmp, r), :[], s(:arglist, s(:js_tmp, a)))
-            aset = s(:call, s(:js_tmp, r), :[]=, s(:arglist, s(:js_tmp, a), rhs))
-            andop = s(:and, aref, aset)
-
-            push "(#{a} = ", expr(first_arg), ", #{r} = ", expr(lhs)
-            push ", ", expr(andop), ")"
-          end
-        end
-      end
-    end
-
-    # lhs.b += rhs
-    # s(:op_asgn2, lhs, :b=, :+, rhs)
-    class OpAsgn2Node < Base
-      handle :op_asgn2
-
-      children :lhs, :mid, :op, :rhs
+    # /regexp/ =~ rhs
+    # s(:match_with_lvasgn, lhs, rhs)
+    class Match3Node < Base
+      handle :match_with_lvasgn
 
-      def meth
-        mid.to_s[0..-2]
-      end
+      children :lhs, :rhs
 
       def compile
-        case op.to_s
-        when '||' then compile_or
-        when '&&' then compile_and
-        else compile_operator
-        end
-      end
-
-      def compile_or
-        with_temp do |tmp|
-          getr = s(:call, s(:js_tmp, tmp), meth, s(:arglist))
-          asgn = s(:call, s(:js_tmp, tmp), mid, s(:arglist, rhs))
-          orop = s(:or, getr, asgn)
-
-          push "(#{tmp} = ", expr(lhs), ", ", expr(orop), ")"
-        end
-      end
-
-      def compile_and
-        with_temp do |tmp|
-          getr = s(:call, s(:js_tmp, tmp), meth, s(:arglist))
-          asgn = s(:call, s(:js_tmp, tmp), mid, s(:arglist, rhs))
-          andop = s(:and, getr, asgn)
-
-          push "(#{tmp} = ", expr(lhs), ", ", expr(andop), ")"
-        end
-      end
-
-      def compile_operator
-        with_temp do |tmp|
-          getr = s(:call, s(:js_tmp, tmp), meth, s(:arglist))
-          oper = s(:call, getr, op, s(:arglist, rhs))
-          asgn = s(:call, s(:js_tmp, tmp), mid, s(:arglist, oper))
-
-          push "(#{tmp} = ", expr(lhs), ", ", expr(asgn), ")"
-        end
+        sexp = s(:send, lhs, :=~, rhs)
+        push process(sexp, @level)
       end
     end
   end

data/lib/opal/nodes/case.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -8,34 +9,43 @@ module Opal
       children :condition
 
       def compile
+        compiler.in_case do
+          compile_code
+
+          wrap '(function() {', '})()' if needs_closure?
+        end
+      end
+
+      def compile_code
         handled_else = false
 
-        compiler.in_case do
-          if condition
-            case_stmt[:cond] = true
-            add_local '$case'
+        if condition
+          case_stmt[:cond] = true
+          add_local '$case'
 
-            push "$case = ", expr(condition), ";"
-          end
+          push "$case = ", expr(condition), ";"
+        end
 
-          case_parts.each_with_index do |wen, idx|
-            if wen and wen.type == :when
-              compiler.returns(wen) if needs_closure?
+        case_parts.each_with_index do |wen, idx|
+          if wen
+            line
+            case wen.type
+            when :when
+              wen = compiler.returns(wen) if needs_closure?
               push "else " unless idx == 0
               push stmt(wen)
-            elsif wen # s(:else)
+            else # s(:else)
               handled_else = true
               wen = compiler.returns(wen) if needs_closure?
               push "else {", stmt(wen), "}"
             end
           end
+        end
 
-          # if we are having a closure, we must return a usable value
-          if needs_closure? and !handled_else
-            push "else { return nil }"
-          end
-
-          wrap '(function() {', '})()' if needs_closure?
+        # if we are having a closure, we must return a usable value
+        if needs_closure? and !handled_else
+          line
+          push "else { return nil }"
         end
       end
 
@@ -64,12 +74,16 @@ module Opal
           push ' || ' unless idx == 0
 
           if check.type == :splat
-            push "(function($splt) { for (var i = 0; i < $splt.length; i++) {"
-            push "if ($splt[i]['$===']($case)) { return true; }"
-            push "} return false; })(", expr(check[1]), ")"
+            push "(function($splt) { for (var i = 0, ii = $splt.length; i < ii; i++) {"
+            if case_stmt[:cond]
+              push "if ($splt[i]['$===']($case)) { return true; }"
+            else
+              push "if (", js_truthy(check), ")) { return true; }"
+            end
+            push "} return false; })(", expr(check.children[0]), ")"
           else
             if case_stmt[:cond]
-              call = s(:call, check, :===, s(:arglist, s(:js_tmp, '$case')))
+              call = s(:send, check, :===, s(:arglist, s(:js_tmp, '$case')))
               push expr(call)
             else
               push js_truthy(check)
@@ -81,7 +95,7 @@ module Opal
       end
 
       def when_checks
-        whens.children
+        children[0..-2]
       end
 
       def case_stmt
@@ -89,7 +103,7 @@ module Opal
       end
 
       def body_code
-        body || s(:nil)
+        children.last || s(:nil)
       end
     end
   end

data/lib/opal/nodes/class.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/module'
 
 module Opal
@@ -11,14 +12,14 @@ module Opal
         name, base = name_and_base
         helper :klass
 
-        push "(function($base, $super) {"
+        push "(function($base, $super, $parent_nesting) {"
         line "  function $#{name}(){};"
         line "  var self = $#{name} = $klass($base, $super, '#{name}', $#{name});"
 
         in_scope do
           scope.name = name
           add_temp "#{scope.proto} = self.$$proto"
-          add_temp "$scope = self.$$scope"
+          add_temp '$nesting = [self].concat($parent_nesting)'
 
           body_code = self.body_code
           empty_line
@@ -27,7 +28,7 @@ module Opal
           line body_code
         end
 
-        line "})(", base, ", ", self.super_code, ")"
+        line "})(", base, ", ", self.super_code, ", $nesting)"
       end
 
       def super_code

data/lib/opal/nodes/constants.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/base'
 
 module Opal
@@ -5,25 +6,38 @@ module Opal
     class ConstNode < Base
       handle :const
 
-      children :name
+      children :const_scope, :name
 
       def compile
-        if name == :DATA and compiler.eof_content
+        if magical_data_const?
           push("$__END__")
+        elsif const_scope
+          push "Opal.const_get_qualified(", recv(const_scope), ", '#{name}')"
+        elsif compiler.eval?
+          push "Opal.const_get_relative($nesting, '#{name}')"
         else
-          push "$scope.get('#{name}')"
+          push "Opal.const_get_relative($nesting, '#{name}')"
         end
       end
-    end
 
-    class ConstDeclarationNode < Base
-      handle :cdecl
+      # Ruby has a magical const DATA
+      # that should be processed in a different way:
+      # 1. When current file contains __END__ in the end of the file
+      #    DATA const should be resolved to the string located after __END__
+      # 2. When current file doesn't have __END__ section
+      #    DATA const should be resolved to a regular ::DATA constant
+      def magical_data_const?
+        const_scope.nil? && name == :DATA and compiler.eof_content
+      end
+    end
 
-      children :name, :base
+    # ::CONST
+    # s(:const, s(:cbase), :CONST)
+    class CbaseNode < Base
+      handle :cbase
 
       def compile
-        push expr(base)
-        wrap "Opal.cdecl($scope, '#{name}', ", ")"
+        push "'::'"
       end
     end
 
@@ -33,45 +47,11 @@ module Opal
       children :base, :name, :value
 
       def compile
-        push "Opal.casgn("
-        push expr(base)
-        push ", '#{name}', "
-        push expr(value)
-        push ")"
-      end
-    end
-
-    class ConstGetNode < Base
-      handle :colon2
-
-      children :base, :name
-
-      def compile
-        push "(("
-        push expr(base)
-        push ").$$scope.get('#{name}'))"
-      end
-    end
-
-    class TopConstNode < Base
-      handle :colon3
-
-      children :name
-
-      def compile
-        push "Opal.get('#{name}')"
-      end
-    end
-
-    class TopConstAssignNode < Base
-      handle :casgn3
-
-      children :name, :value
-
-      def compile
-        push "Opal.casgn(Opal.Object, '#{name}', "
-        push expr(value)
-        push ")"
+        if base
+          push "Opal.const_set(", expr(base), ", '#{name}', ", expr(value), ")"
+        else
+          push "Opal.const_set($nesting[0], '#{name}', ", expr(value), ")"
+        end
       end
     end
   end