opal 0.10.0 → 0.11.0.rc1

data/lib/opal/nodes/call.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
 require 'set'
 require 'pathname'
 require 'opal/nodes/base'
 require 'opal/nodes/runtime_helpers'
+require 'opal/rewriters/break_finder'
 
 module Opal
   module Nodes
     class CallNode < Base
-      handle :call
+      handle :send
 
-      children :recvr, :meth, :arglist, :iter
+      attr_reader :recvr, :meth, :arglist, :iter
 
       SPECIALS = {}
 
@@ -21,127 +23,134 @@ module Opal
         define_method("handle_#{name}", &handler)
       end
 
-      def compile
-        # handle some methods specially
-        handle_special
-
-        # some special methods need to skip compilation
-        return unless compile_default?
+      def initialize(*)
+        super
+        @recvr, @meth, *args = *@sexp
 
-        compiler.method_calls << meth.to_sym if record_method?
+        *rest, last_arg = *args
 
-        # if trying to access an lvar in irb mode
-        return compile_irb_var if using_irb?
+        if last_arg && [:iter, :block_pass].include?(last_arg.type)
+          @iter = last_arg
+          args = rest
+        end
 
-        default_compile
+        @arglist = s(:arglist, *args)
       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
+      def compile
+        # handle some methods specially
+        # some special methods need to skip compilation, so we pass the default as a block
+        handle_special do
+          compiler.method_calls << meth.to_sym if record_method?
 
-        # must do this after assigning temp variables
-        has_break = compiler.has_break? { @block_being_passed = expr(@block_being_passed) } if block_being_passed
+          # if trying to access an lvar in irb mode
+          return compile_irb_var if using_irb?
 
-        add_method temporary_receiver
+          default_compile
+        end
+      end
 
-        add_block block_temp if block_temp
+      private
 
-        add_invocation temporary_receiver
+      def iter_has_break?
+        return false unless iter
+
+        finder = Opal::Rewriters::BreakFinder.new
+        finder.process(iter)
+        finder.found_break?
+      end
+
+      # Opal has a runtime helper 'Opal.send_method_name' that assigns
+      # provided block to a '$$p' property of the method body
+      # and invokes a method using 'apply'.
+      #
+      # We have to compile a method call using this 'Opal.send_method_name' when a method:
+      # 1. takes a splat
+      # 2. takes a block
+      #
+      # Arguments that contain splat must be handled in a different way.
+      # @see #compile_arguments
+      #
+      # When a method takes a block we have to calculate all arguments
+      # **before** asigning '$$p' property (that stores a passed block)
+      # to a method body. This is some kind of protection from method calls
+      # like 'a(a {}) { 1 }'.
+      def invoke_using_send?
+        iter || splat?
+      end
 
-        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 } }})()'
+      def default_compile
+        if invoke_using_send?
+          compile_using_send
+        else
+          compile_simple_call_chain
         end
 
-        scope.queue_temp block_temp if block_temp
+        compile_break_catcher
       end
 
-      def redefine_this?(temporary_receiver)
-        temporary_receiver != nil
-      end
+      # Compiles method call using `Opal.send`
+      #
+      # @example
+      #   a.b(c, &block)
+      #
+      #   Opal.send(a, 'b', [c], block)
+      #
+      def compile_using_send
+        helper :send
 
-      def apply_call_target(temporary_receiver)
-        temporary_receiver || receiver_fragment
+        push '$send('
+        compile_receiver
+        compile_method_name
+        compile_arguments
+        compile_block_pass
+        push ')'
       end
 
-      def arguments_array?
-        splat?
+      def compile_receiver
+        push recv(receiver_sexp)
       end
 
-      def add_invocation(temporary_receiver)
-        args = arguments_fragment
-        if redefine_this?(temporary_receiver) || arguments_array?
-          if arguments_array?
-            push ".apply("
-          else
-            push ".call("
-          end
-
-          push apply_call_target(temporary_receiver)
+      def compile_method_name
+        push ", '#{meth}'"
+      end
 
-          if args.any?
-            push ", ", args
-          end
+      def compile_arguments
+        push ", "
 
-          push ")"
+        if splat?
+          push expr(arglist)
+        elsif arglist.children.empty?
+          push '[]'
         else
-          push "(", args, ")"
+          push '[', expr(arglist), ']'
         end
       end
 
-      def add_method(temporary_receiver)
-        if temporary_receiver
-          push "(#{temporary_receiver} = ", receiver_fragment, ")#{method_jsid}"
-        else
-          push receiver_fragment, method_jsid
+      def compile_block_pass
+        if iter
+          push ", ", expr(iter)
         end
       end
 
-      def add_block(block_temp)
-        unshift "(#{block_temp} = "
-        push ", #{block_temp}.$$p = ", block_being_passed, ", #{block_temp})"
-      end
-
-      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
+      def compile_break_catcher
+        if iter_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
       end
 
-      def arguments_sexp
-        # arguments_without_block is an array, not an sexp
-        only_args = arguments_without_block
-        s(:arglist, *only_args)
+      def compile_simple_call_chain
+        push recv(receiver_sexp), method_jsid, "(", expr(arglist), ")"
       end
 
-      def arguments_without_block
-        @arguments_without_block ||= begin
-          arglist[1..-1]
-        end
+      def splat?
+        arglist.children.any? { |a| a.type == :splat }
       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
+      def receiver_sexp
+        recvr || s(:self)
       end
 
       def method_jsid
@@ -152,67 +161,45 @@ module Opal
         true
       end
 
-      def attr_assignment?
-        @assignment ||= meth.to_s =~ /#{REGEXP_START}[\da-z]+\=#{REGEXP_END}/i
-      end
-
       # Used to generate the code to use this sexp as an ivar var reference
       def compile_irb_var
         with_temp do |tmp|
-          lvar = variable(meth)
-          call = s(:call, s(:self), meth.intern, s(:arglist))
+          lvar = meth
+          call = s(:send, s(:self), meth.intern, s(:arglist))
           push "((#{tmp} = Opal.irb_vars.#{lvar}) == null ? ", expr(call), " : #{tmp})"
         end
       end
 
-      def compile_assignment
-        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
-      end
-
       # a variable reference in irb mode in top scope might be a var ref,
       # or it might be a method call
       def using_irb?
         @compiler.irb? and scope.top? and arglist == s(:arglist) and recvr.nil? and iter.nil?
       end
 
+      def sexp_with_arglist
+        @sexp.updated(nil, [recvr, meth, arglist])
+      end
+
       # Handle "special" method calls, e.g. require(). Subclasses can override
       # this method. If this method returns nil, then the method will continue
       # to be generated by CallNode.
-      def handle_special
-        @compile_default = true
-
+      def handle_special(&compile_default)
         if SPECIALS.include? meth
-          @compile_default = false
-          __send__("handle_#{meth}")
+          method = method("handle_#{meth}")
+          method.arity == 1 ? method[compile_default] : method[]
         elsif RuntimeHelpers.compatible?(recvr, meth, arglist)
-          @compile_default = false
-          push(RuntimeHelpers.new(@sexp, @level, @compiler).compile)
+          push(RuntimeHelpers.new(sexp_with_arglist, @level, @compiler).compile)
+        else
+          compile_default.call
         end
       end
 
-      def compile_default!
-        @compile_default = true
-      end
-
-      def compile_default?
-        @compile_default
-      end
-
       OPERATORS.each do |operator, name|
-        add_special(operator.to_sym) do
+        add_special(operator.to_sym) do |compile_default|
           if compiler.inline_operators?
             compiler.method_calls << operator.to_sym if record_method?
             compiler.operator_helpers << operator.to_sym
-            lhs, rhs = expr(recvr), expr(arglist[1])
+            lhs, rhs = expr(recvr), expr(arglist)
 
             push fragment("$rb_#{name}(")
             push lhs
@@ -220,58 +207,56 @@ module Opal
             push rhs
             push fragment(")")
           else
-            compile_default!
+            compile_default.call
           end
         end
       end
 
-      add_special :require do
-        compile_default!
-        str = DependencyResolver.new(compiler, arglist[1]).resolve
+      add_special :require do |compile_default|
+        str = DependencyResolver.new(compiler, arglist.children[0]).resolve
         compiler.requires << str unless str.nil?
-        push fragment('')
+        compile_default.call
       end
 
-      add_special :require_relative do
-        arg = arglist[1]
+      add_special :require_relative do |_compile_default|
+        arg = arglist.children[0]
         file = compiler.file
-        if arg[0] == :str
+        if arg.type == :str
           dir = File.dirname(file)
-          compiler.requires << Pathname(dir).join(arg[1]).cleanpath.to_s
+          compiler.requires << Pathname(dir).join(arg.children[0]).cleanpath.to_s
         end
         push fragment("self.$require(#{file.inspect}+ '/../' + ")
         push process(arglist)
         push fragment(')')
       end
 
-      add_special :autoload do
+      add_special :autoload do |compile_default|
         if scope.class_scope?
-          compile_default!
-          str = DependencyResolver.new(compiler, arglist[2]).resolve
+          str = DependencyResolver.new(compiler, arglist.children[1]).resolve
           compiler.requires << str unless str.nil?
-          push fragment('')
+          compile_default.call
         end
       end
 
-      add_special :require_tree do
-        arg = arglist[1]
-        if arg[0] == :str
-          relative_path = arg[1]
+      add_special :require_tree do |compile_default|
+        first_arg, *rest = *arglist.children
+        if first_arg.type == :str
+          relative_path = first_arg.children[0]
           compiler.required_trees << relative_path
 
           dir = File.dirname(compiler.file)
           full_path = Pathname(dir).join(relative_path).cleanpath.to_s
-          arg[1] = full_path
+          first_arg = first_arg.updated(nil, [full_path])
         end
-        compile_default!
-        push fragment('')
+        @arglist = arglist.updated(nil, [first_arg] + rest)
+        compile_default.call
       end
 
-      add_special :block_given? do
+      add_special :block_given? do |compile_default|
         push compiler.handle_block_given_call @sexp
       end
 
-      add_special :__callee__ do
+      add_special :__callee__ do |compile_default|
         if scope.def?
           push fragment scope.mid.to_s.inspect
         else
@@ -279,7 +264,7 @@ module Opal
         end
       end
 
-      add_special :__method__ do
+      add_special :__method__ do |compile_default|
         if scope.def?
           push fragment scope.mid.to_s.inspect
         else
@@ -287,14 +272,41 @@ module Opal
         end
       end
 
-      add_special :debugger do
+      add_special :debugger do |compile_default|
         push fragment 'debugger'
       end
 
-      add_special :__OPAL_COMPILER_CONFIG__ do
+      add_special :__OPAL_COMPILER_CONFIG__ do |compile_default|
         push fragment "Opal.hash({ arity_check: #{compiler.arity_check?} })"
       end
 
+      add_special :nesting do |compile_default|
+        recv, method, *args = children
+        push_nesting = push_nesting?(children)
+        push '(Opal.Module.$$nesting = $nesting, ' if push_nesting
+        compile_default.call
+        push ')' if push_nesting
+      end
+
+      add_special :constants do |compile_default|
+        recv, method, *args = children
+        push_nesting = push_nesting?(children)
+        push '(Opal.Module.$$nesting = $nesting, ' if push_nesting
+        compile_default.call
+        push ')' if push_nesting
+      end
+
+      def push_nesting?(recv)
+        recv = children.first
+
+        children.size == 2 && (           # only receiver and method
+          recv.nil? || (                  # and no receiver
+            recv.type == :const &&        # or receiver
+            recv.children.last == :Module # is Module
+          )
+        )
+      end
+
       class DependencyResolver
         def initialize(compiler, sexp)
           @compiler = compiler
@@ -309,13 +321,13 @@ module Opal
           type = sexp.type
 
           if type == :str
-            return sexp[1]
-          elsif type == :call
-            _, recv, meth, args = sexp
+            return sexp.children[0]
+          elsif type == :send
+            recv, meth, *args = sexp.children
 
-            parts = args[1..-1].map { |s| handle_part s }
+            parts = args.map { |s| handle_part s }
 
-            if recv == [:const, :File]
+            if ::Opal::AST::Node === recv && recv.type == :const && recv.children.last == :File
               if meth == :expand_path
                 return expand_path(*parts)
               elsif meth == :join