opal 0.9.4 → 0.10.0.beta1

data/lib/opal/nodes/args/post_kwargs.rb

@@ -0,0 +1,31 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    # A node responsible for extracting
+    # keyword arguments list
+    #
+    # If a method/block arguments have splat we can't
+    # find the place where **exactly** starts keyword arguments.
+    #
+    # @see PostArgsNode
+    #
+    class PostKwargsNode < Base
+      handle :post_kwargs
+
+      def compile
+        return if children.empty?
+
+        initialize_kw_args
+
+        children.each do |arg|
+          push process(arg)
+        end
+      end
+
+      def initialize_kw_args
+        line "$kwargs = Opal.extract_kwargs(#{scope.working_arguments});"
+      end
+    end
+  end
+end

data/lib/opal/nodes/args/restarg.rb

@@ -0,0 +1,33 @@
+require 'opal/nodes/base'
+
+module Opal
+  module Nodes
+    # A node responsible for extracting a rest argument
+    # (or splat argument)
+    #
+    # def m(*rest)
+    #
+    class RestargNode < Base
+      handle :restarg
+
+      def compile
+        restarg_name = @sexp[1]
+        return unless restarg_name
+        var_name = variable(restarg_name.to_sym)
+
+        add_temp var_name
+
+        if @sexp.meta[:post]
+          # post restarg case (in mlhs or in deoptimized arguments)
+          # splat is always the last item in scope.working_arguments
+          line "#{var_name} = #{scope.working_arguments};"
+        else
+          # inline restarg case
+          offset = @sexp.meta[:offset]
+          # restarg value should be taken directly from parameters
+          line "#{var_name} = $slice.call(arguments, #{offset}, arguments.length);"
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/base.rb

@@ -150,6 +150,18 @@ module Opal
       def while_loop
         @compiler.instance_variable_get(:@while_loop)
       end
+
+      def has_rescue_else?
+        scope.has_rescue_else?
+      end
+
+      def in_ensure(&block)
+        scope.in_ensure(&block)
+      end
+
+      def in_ensure?
+        scope.in_ensure?
+      end
     end
   end
 end

data/lib/opal/nodes/call.rb

@@ -36,63 +36,122 @@ module Opal
         default_compile
       end
 
-      def record_method?
-        true
-      end
+      private
 
       def default_compile
+        # blocks need to be assigned to temp variables in order to pass them
+        block_temp = scope.new_temp if block_being_passed
+
+        # can't use self for splats or blocks
+        temporary_receiver = scope.new_temp if splat? || block_temp
+
+        # must do this after assigning temp variables
+        has_break = compiler.has_break? { @block_being_passed = expr(@block_being_passed) } if block_being_passed
 
-        mid = mid_to_jsid meth.to_s
+        add_method temporary_receiver
 
-        splat = arglist[1..-1].any? { |a| a.first == :splat }
+        add_block block_temp if block_temp
 
-        if Sexp === arglist.last and arglist.last.type == :block_pass
-          block = arglist.pop
-        elsif iter
-          block = iter
+        add_invocation temporary_receiver
+
+        if has_break
+          unshift 'return '
+          unshift '(function(){var $brk = Opal.new_brk(); try {'
+          line '} catch (err) { if (err === $brk) { return err.$v } else { throw err } }})()'
         end
 
-        blktmp  = scope.new_temp if block
-        tmprecv = scope.new_temp if splat || blktmp
+        scope.queue_temp block_temp if block_temp
+      end
 
-        # must do this after assigning temp variables
-        block = expr(block) if block
+      def redefine_this?(temporary_receiver)
+        temporary_receiver != nil
+      end
 
-        recv_code = recv(recv_sexp)
-        call_recv = s(:js_tmp, tmprecv || recv_code)
+      def apply_call_target(temporary_receiver)
+        temporary_receiver || receiver_fragment
+      end
 
-        if blktmp and !splat
-          arglist.insert 1, call_recv
-        end
+      def arguments_array?
+        splat?
+      end
 
-        args = expr(arglist)
+      def add_invocation(temporary_receiver)
+        args = arguments_fragment
+        if redefine_this?(temporary_receiver) || arguments_array?
+          if arguments_array?
+            push ".apply("
+          else
+            push ".call("
+          end
 
-        if tmprecv
-          push "(#{tmprecv} = ", recv_code, ")#{mid}"
-        else
-          push recv_code, mid
-        end
+          push apply_call_target(temporary_receiver)
 
-        if blktmp
-          unshift "(#{blktmp} = "
-          push ", #{blktmp}.$$p = ", block, ", #{blktmp})"
-        end
+          if args.any?
+            push ", ", args
+          end
 
-        if splat
-          push ".apply(", (tmprecv || recv_code), ", ", args, ")"
-        elsif blktmp
-          push ".call(", args, ")"
+          push ")"
         else
           push "(", args, ")"
         end
+      end
+
+      def add_method(temporary_receiver)
+        if temporary_receiver
+          push "(#{temporary_receiver} = ", receiver_fragment, ")#{method_jsid}"
+        else
+          push receiver_fragment, method_jsid
+        end
+      end
+
+      def add_block(block_temp)
+        unshift "(#{block_temp} = "
+        push ", #{block_temp}.$$p = ", block_being_passed, ", #{block_temp})"
+      end
 
-        scope.queue_temp blktmp if blktmp
+      def splat?
+        arguments_without_block.any? { |a| a.first == :splat }
       end
 
       def recv_sexp
         recvr || s(:self)
       end
 
+      def receiver_fragment
+        recv recv_sexp
+      end
+
+      def arguments_fragment
+        expr arguments_sexp
+      end
+
+      def arguments_sexp
+        # arguments_without_block is an array, not an sexp
+        only_args = arguments_without_block
+        s(:arglist, *only_args)
+      end
+
+      def arguments_without_block
+        @arguments_without_block ||= begin
+          arglist[1..-1]
+        end
+      end
+
+      def block_being_passed
+        @block_being_passed ||= begin
+          args = arguments_without_block
+          Sexp === args.last && args.last.type == :block_pass ? args.pop : iter
+        end
+      end
+
+      def method_jsid
+        mid_to_jsid meth.to_s
+      end
+
+      def record_method?
+        true
+      end
+
       def attr_assignment?
         @assignment ||= meth.to_s =~ /#{REGEXP_START}[\da-z]+\=#{REGEXP_END}/i
       end

data/lib/opal/nodes/def.rb

@@ -1,31 +1,21 @@
-require 'opal/nodes/scope'
+require 'opal/nodes/node_with_args'
 
 module Opal
   module Nodes
     # FIXME: needs rewrite
-    class DefNode < ScopeNode
+    class DefNode < NodeWithArgs
       handle :def
 
       children :recvr, :mid, :args, :stmts
 
-      def opt_args
-        @opt_args ||= args[1..-1].select { |arg| arg.first == :optarg }
-      end
-
-      def rest_arg
-        @rest_arg ||= args[1..-1].find { |arg| arg.first == :restarg }
-      end
+      attr_accessor :block_arg
 
-      def keyword_args
-        @keyword_args ||= args[1..-1].select do |arg|
-          [:kwarg, :kwoptarg, :kwrestarg].include? arg.first
+      def extract_block_arg
+        if args.last.is_a?(Sexp) && args.last.type == :blockarg
+          @block_arg = args.pop
         end
       end
 
-      def block_arg
-        @block_arg ||= args[1..-1].find { |arg| arg.first == :blockarg }
-      end
-
       def argc
         return @argc if @argc
 
@@ -38,7 +28,10 @@ module Opal
       end
 
       def compile
-        params = nil
+        extract_block_arg
+        split_args
+
+        inline_params = nil
         scope_name = nil
 
         # block name (&block)
@@ -61,29 +54,27 @@ module Opal
 
           scope.block_name = block_name || '$yield'
 
-          params = process(args)
+          inline_params = process(inline_args_sexp)
           stmt_code = stmt(compiler.returns(stmts))
 
           add_temp 'self = this'
 
-          compile_rest_arg
-          compile_opt_args
-          compile_keyword_args
+          compile_inline_args
+          compile_post_args
 
-          # must do this after opt args incase opt arg uses yield
           scope_name = scope.identity
 
           compile_block_arg
 
-          if rest_arg
-            scope.locals.delete(rest_arg[1])
-          end
+          line arity_code if arity_code
 
           if scope.uses_zuper
             add_local '$zuper'
             add_local '$zuper_index'
+            add_local '$zuper_length'
 
             line "$zuper = [];"
+            line
             line "for($zuper_index = 0; $zuper_index < arguments.length; $zuper_index++) {"
             line "  $zuper[$zuper_index] = arguments[$zuper_index];"
             line "}"
@@ -91,8 +82,6 @@ module Opal
 
           unshift "\n#{current_indent}", scope.to_vars
 
-          line arity_code if arity_code
-
           line stmt_code
 
           if scope.catch_return
@@ -102,9 +91,12 @@ module Opal
           end
         end
 
+        #     This is a special utf8 char ---v
+        function_name = valid_name?(mid) ? " ː#{mid}" : ''
+
         unshift ") {"
-        unshift(params)
-        unshift "function("
+        unshift(inline_params)
+        unshift "function#{function_name}("
         unshift "#{scope_name} = " if scope_name
         line "}"
 
@@ -122,6 +114,9 @@ module Opal
             unshift "Opal.defn(self, '$#{mid}', "
           end
           push ')'
+        elsif compiler.eval?
+          unshift "Opal.def(self, '$#{mid}', "
+          push ')'
         elsif scope.top?
           unshift "Opal.defn(Opal.Object, '$#{mid}', "
           push ')'
@@ -132,109 +127,6 @@ module Opal
         wrap '(', ", nil) && '#{mid}'" if expr?
       end
 
-      def compile_block_arg
-        if scope.uses_block?
-          scope_name  = scope.identity
-          yielder     = scope.block_name
-
-          add_temp "$iter = #{scope_name}.$$p"
-          add_temp "#{yielder} = $iter || nil"
-
-          line "#{scope_name}.$$p = null;"
-        end
-      end
-
-      def compile_rest_arg
-        if rest_arg and rest_arg[1]
-          splat = variable(rest_arg[1].to_sym)
-          add_local '$splat_index'
-          line "var array_size = arguments.length - #{argc};"
-          line "if(array_size < 0) array_size = 0;"
-          line "var #{splat} = new Array(array_size);"
-          line "for($splat_index = 0; $splat_index < array_size; $splat_index++) {"
-          line "  #{splat}[$splat_index] = arguments[$splat_index + #{argc}];"
-          line "}"
-        end
-      end
-
-      def compile_opt_args
-        opt_args.each do |arg|
-          next if arg[2][2] == :undefined
-          line "if (#{variable(arg[1])} == null) {"
-          line "  #{variable(arg[1])} = ", expr(arg[2])
-          line "}"
-        end
-      end
-
-      def compile_keyword_args
-        return if keyword_args.empty?
-        helper :hash2
-
-        if rest_arg
-          with_temp do |tmp|
-            rest_arg_name = variable(rest_arg[1].to_sym)
-            line "#{tmp} = #{rest_arg_name}[#{rest_arg_name}.length - 1];"
-            line "if (#{tmp} == null || !#{tmp}.$$is_hash) {"
-            line "  $kwargs = $hash2([], {});"
-            line "} else {"
-            line "  $kwargs = #{rest_arg_name}.pop();"
-            line "}"
-          end
-        elsif last_opt_arg = opt_args.last
-          opt_arg_name = variable(last_opt_arg[1])
-          line "if (#{opt_arg_name} == null) {"
-          line "  $kwargs = $hash2([], {});"
-          line "}"
-          line "else if (#{opt_arg_name}.$$is_hash) {"
-          line "  $kwargs = #{opt_arg_name};"
-          line "  #{opt_arg_name} = ", expr(last_opt_arg[2]), ";"
-          line "}"
-          line "else if ($kwargs == null) {"
-          line "  $kwargs = $hash2([], {});"
-          line "}"
-        else
-          line "if ($kwargs == null) {"
-          line "  $kwargs = $hash2([], {});"
-          line "}"
-        end
-
-        line "if (!$kwargs.$$is_hash) {"
-        line "  throw Opal.ArgumentError.$new('expecting keyword args');"
-        line "}"
-
-        keyword_args.each do |kwarg|
-          case kwarg.first
-          when :kwoptarg
-            arg_name = kwarg[1]
-            var_name = variable(arg_name.to_s)
-            add_local var_name
-            line "if ((#{var_name} = $kwargs.$$smap['#{arg_name}']) == null) {"
-            line "  #{var_name} = ", expr(kwarg[2])
-            line "}"
-          when :kwarg
-            arg_name = kwarg[1]
-            var_name = variable(arg_name.to_s)
-            add_local var_name
-            line "if ((#{var_name} = $kwargs.$$smap['#{arg_name}']) == null) {"
-            line "  throw new Error('expecting keyword arg: #{arg_name}')"
-            line "}"
-          when :kwrestarg
-            arg_name = kwarg[1]
-            var_name = variable(arg_name.to_s)
-            add_local var_name
-
-            kwarg_names = keyword_args.select do |kw|
-              [:kwoptarg, :kwarg].include? kw.first
-            end.map { |kw| "#{kw[1].to_s.inspect}: true" }
-
-            used_args = "{#{kwarg_names.join ','}}"
-            line "#{var_name} = Opal.kwrestargs($kwargs, #{used_args});"
-          else
-            raise "unknown kwarg type #{kwarg.first}"
-          end
-        end
-      end
-
       # Returns code used in debug mode to check arity of method call
       def arity_check(args, opt, splat, kwargs, block_name, mid)
         meth = mid.to_s.inspect
@@ -246,7 +138,7 @@ module Opal
 
         arity -= (kwargs.size)
 
-        arity -= 1 if block_name
+        # arity -= 1 if block_name
         arity = -arity - 1 if !opt.empty? or !kwargs.empty? or splat
 
         # $arity will point to our received arguments count
@@ -255,7 +147,7 @@ module Opal
         if arity < 0 # splat or opt args
           min_arity = -(arity + 1)
           max_arity = args.size - 1
-          max_arity -= 1 if block_name
+          # max_arity -= 1 if block_name
           checks = []
           checks << "$arity < #{min_arity}" if min_arity > 0
           checks << "$arity > #{max_arity}" if max_arity and not(splat)
@@ -265,40 +157,5 @@ module Opal
         end
       end
     end
-
-    # def args list
-    class ArgsNode < Base
-      handle :args
-
-      def compile
-        done_kwargs = false
-        have_rest   = false
-
-        children.each_with_index do |child, idx|
-          case child.first
-          when :kwarg, :kwoptarg, :kwrestarg
-            unless done_kwargs
-              done_kwargs = true
-              push ', ' unless idx == 0 || have_rest
-              scope.add_arg '$kwargs'
-              push '$kwargs'
-            end
-
-          when :blockarg
-            # we ignore it because we don't need it
-
-          when :restarg
-            have_rest = true
-
-          else
-            child = child[1].to_sym
-            push ', ' unless idx == 0
-            child = variable(child)
-            scope.add_arg child.to_sym
-            push child.to_s
-          end
-        end
-      end
-    end
   end
 end