opal 0.10.0 → 0.11.0

data/lib/opal/nodes/call_special.rb

@@ -1,251 +1,74 @@
+# 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
-
-          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
+      def initialize(*)
+        super
 
-          scope.queue_temp blktmp if blktmp
+        # For .JS. call we pass a block
+        # as a plain JS callback
+        if @iter
+          @arglist = @arglist << @iter
         end
-      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)
-      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)
-      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]
+        @iter = nil
       end
 
       def compile
-        case op.to_s
-        when '||' then compile_or
-        when '&&' then compile_and
-        else compile_operator
-        end
+        default_compile
       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
+      def method_jsid
+        ".#{meth}"
       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
+      def compile_using_send
+        push recv(receiver_sexp), method_jsid, ".apply(null"
+        compile_arguments
+        if iter
+          push ".concat(", expr(iter), ")"
         end
+        push ")"
       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

data/lib/opal/nodes/csend.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'opal/nodes/call'
+
+module Opal
+  module Nodes
+
+    # Safe navigator recv&.meth(arglist, &block)
+    class CSendNode < CallNode
+      handle :csend
+
+      def default_compile
+        helper :send
+
+        conditional_send(recv(receiver_sexp)) do |receiver_temp|
+          push "$send(", receiver_temp
+          compile_method_name
+          compile_arguments
+          compile_block_pass
+          push ')'
+        end
+      end
+    end
+
+  end
+end

data/lib/opal/nodes/def.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'opal/nodes/node_with_args'
 
 module Opal
@@ -6,13 +7,19 @@ module Opal
     class DefNode < NodeWithArgs
       handle :def
 
-      children :recvr, :mid, :args, :stmts
+      children :mid, :args, :stmts
 
       attr_accessor :block_arg
 
       def extract_block_arg
-        if args.last.is_a?(Sexp) && args.last.type == :blockarg
-          @block_arg = args.pop[1]
+        *regular_args, last_arg = args.children
+        if last_arg && last_arg.type == :blockarg
+          @block_arg = last_arg.children[0]
+          @sexp = @sexp.updated(nil, [
+            mid,
+            s(:args, *regular_args),
+            stmts
+          ])
         end
       end
 
@@ -25,12 +32,12 @@ module Opal
 
         # block name (&block)
         if block_arg
-          block_name = variable(block_arg).to_sym
+          block_name = block_arg
         end
 
         in_scope do
           scope.mid = mid
-          scope.defs = true if recvr
+          scope.defs = true if @sexp.type == :defs
 
           if block_name
             scope.uses_block!
@@ -40,6 +47,7 @@ module Opal
           scope.block_name = block_name || '$yield'
 
           inline_params = process(inline_args_sexp)
+
           stmt_code = stmt(compiler.returns(stmts))
 
           add_temp 'self = this'
@@ -58,13 +66,12 @@ module Opal
 
           if scope.uses_zuper
             add_local '$zuper'
-            add_local '$zuper_index'
-            add_local '$zuper_length'
+            add_local '$zuper_i'
+            add_local '$zuper_ii'
 
-            line "$zuper = [];"
-            line
-            line "for($zuper_index = 0; $zuper_index < arguments.length; $zuper_index++) {"
-            line "  $zuper[$zuper_index] = arguments[$zuper_index];"
+            line "// Prepare super implicit arguments"
+            line "for($zuper_i = 0, $zuper_ii = arguments.length, $zuper = new Array($zuper_ii); $zuper_i < $zuper_ii; $zuper_i++) {"
+            line "  $zuper[$zuper_i] = arguments[$zuper_i];"
             line "}"
           end
 
@@ -79,8 +86,15 @@ module Opal
           end
         end
 
-        #     This is a special utf8 char ---v
-        function_name = valid_name?(mid) ? " ː#{mid}" : ''
+        # There are some special utf8 chars that can be used as valid JS
+        # identifiers, some examples:
+        #
+        # utf8_pond = 'ⵌ'
+        # utf8_question = 'ʔ̣'
+        # utf8_exclamation 'ǃ'
+        #
+        # For now we're just using $$, to maintain compatibility with older IEs.
+        function_name = valid_name?(mid) ? " $$#{mid}" : ''
 
         unshift ") {"
         unshift(inline_params)
@@ -94,19 +108,34 @@ module Opal
           push ", #{scope_name}.$$parameters = #{parameters_code}"
         end
 
-        if    recvr                         then unshift 'Opal.defs(', recv(recvr), ", '$#{mid}', "
-        elsif scope.iter?                   then unshift "Opal.def(self, '$#{mid}', "
+        if compiler.parse_comments?
+          push ", #{scope_name}.$$comments = #{comments_code}"
+        end
+
+        if compiler.enable_source_location?
+          push ", #{scope_name}.$$source_location = #{source_location}"
+        end
+
+        wrap_with_definition
+      end
+
+      def wrap_with_definition
+        if    scope.iter?                   then unshift "Opal.def(self, '$#{mid}', "
         elsif scope.module? || scope.class? then unshift "Opal.defn(self, '$#{mid}', "
-        elsif scope.sclass? && scope.defs   then unshift "Opal.defs(self, '$#{mid}', "
         elsif scope.sclass?                 then unshift "Opal.defn(self, '$#{mid}', "
         elsif compiler.eval?                then unshift "Opal.def(self, '$#{mid}', "
         elsif scope.top?                    then unshift "Opal.defn(Opal.Object, '$#{mid}', "
         elsif scope.def?                    then unshift "Opal.def(self, '$#{mid}', "
         else raise "Unsupported use of `def`; please file a bug at https://github.com/opal/opal/issues/new reporting this message."
         end
+
         push ')'
 
-        wrap '(', ", nil) && '#{mid}'" if expr?
+        if expr?
+          wrap '(', ", nil) && '#{mid}'"
+        else
+          unshift "\n#{current_indent}"
+        end
       end
 
       # Returns code used in debug mode to check arity of method call
@@ -117,6 +146,17 @@ module Opal
           push " if (#{arity_checks.join(' || ')}) { Opal.ac($arity, #{arity}, this, #{meth}); }"
         end
       end
+
+      def source_location
+        file = @sexp.loc.expression.source_buffer.name
+        line = @sexp.loc.line
+
+        "['#{file}.rb', #{line}]"
+      end
+
+      def comments_code
+        '[' + comments.map { |comment| comment.text.inspect }.join(', ') + ']'
+      end
     end
   end
 end