opal 1.5.1 → 1.6.0.rc1

data/lib/opal/nodes/closure.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+module Opal
+  module Nodes
+    # This module takes care of providing information about the
+    # closure stack that we have for the nodes during compile time.
+    # This is not a typical node.
+    #
+    # Also, while loops are not closures per se, this module also
+    # takes a note about them.
+    #
+    # Then we can use this information for control flow like
+    # generating breaks, nexts, returns.
+    class Closure
+      NONE = 0
+
+      @types = {}
+
+      def self.add_type(name, value)
+        const_set(name, value)
+        @types[name] = value
+      end
+
+      def self.type_inspect(type)
+        @types.reject do |_name, value|
+          (type & value) == 0
+        end.map(&:first).join("|")
+      end
+
+      add_type(:JS_FUNCTION,    1 <<  0) # everything that generates an IIFE
+      add_type(:JS_LOOP,        1 <<  1) # exerything that generates a JS loop
+      add_type(:JS_LOOP_INSIDE, 1 <<  2) # everything that generates an inside of a loop
+
+      add_type(:DEF,            1 <<  3) # def
+      add_type(:LAMBDA,         1 <<  4) # lambda
+      add_type(:ITER,           1 <<  5) # iter, lambda
+      add_type(:MODULE,         1 <<  6)
+      add_type(:LOOP,           1 <<  7) # for building a catcher outside a loop
+      add_type(:LOOP_INSIDE,    1 <<  8) # for building a catcher inside a loop
+      add_type(:SEND,           1 <<  9) # to generate a break catcher after send with a block
+      add_type(:TOP,            1 << 10)
+      add_type(:RESCUE_RETRIER, 1 << 11) # a virtual loop to catch a retrier
+
+      ANY = 0xffffffff
+
+      def initialize(node, type, parent)
+        @node, @type, @parent = node, type, parent
+        @catchers = []
+        @throwers = {}
+      end
+
+      def register_catcher(type = :return)
+        @catchers << type unless @catchers.include? type
+
+        "$t_#{type}"
+      end
+
+      def register_thrower(type, id)
+        @throwers[type] = id
+      end
+
+      def is?(type)
+        (@type & type) != 0
+      end
+
+      def inspect
+        "#<Closure #{Closure.type_inspect(type)} #{@node.class}>"
+      end
+
+      attr_accessor :node, :type, :parent, :catchers, :throwers
+
+      module NodeSupport
+        def push_closure(type = JS_FUNCTION)
+          closure = Closure.new(self, type, select_closure)
+          @compiler.closure_stack << closure
+          @closure = closure
+        end
+
+        attr_accessor :closure
+
+        def pop_closure
+          compile_catcher
+          @compiler.closure_stack.pop
+          last = @compiler.closure_stack.last
+          @closure = last if last&.node == self
+        end
+
+        def in_closure(type = JS_FUNCTION)
+          closure = push_closure(type)
+          out = yield closure
+          pop_closure
+          out
+        end
+
+        def select_closure(type = ANY, break_after: NONE)
+          @compiler.closure_stack.reverse.find do |i|
+            break if (i.type & break_after) != 0
+            (i.type & type) != 0
+          end
+        end
+
+        def generate_thrower(type, closure, value)
+          id = closure.register_catcher(type)
+          closure.register_thrower(type, id)
+          push id, '.$throw(', expr_or_empty(value), ')'
+          id
+        end
+
+        def generate_thrower_without_catcher(type, closure, value)
+          helper :thrower
+
+          if closure.throwers.key? type
+            id = closure.throwers[type]
+          else
+            id = compiler.unique_temp('t_')
+            scope = closure.node.scope&.parent || top_scope
+            scope.add_scope_temp("#{id} = $thrower('#{type}')")
+            closure.register_thrower(type, id)
+          end
+          push id, '.$throw(', expr_or_empty(value), ')'
+          id
+        end
+
+        def thrower(type, value = nil)
+          case type
+          when :return
+            thrower_closure = select_closure(DEF, break_after: MODULE | TOP)
+            last_closure = select_closure(JS_FUNCTION)
+
+            if !thrower_closure
+              iter_closure = select_closure(ITER, break_after: DEF | MODULE | TOP)
+              if iter_closure
+                generate_thrower_without_catcher(:return, iter_closure, value)
+              elsif compiler.eval?
+                push 'Opal.t_eval_return.$throw(', expr_or_empty(value), ')'
+              else
+                error 'Invalid return'
+              end
+            elsif thrower_closure == last_closure
+              push 'return ', expr_or_nil(value)
+            else
+              id = generate_thrower(:return, thrower_closure, value)
+              # Additionally, register our thrower on the surrounding iter, if present
+              iter_closure = select_closure(ITER, break_after: DEF | MODULE | TOP)
+              iter_closure.register_thrower(:return, id) if iter_closure
+            end
+          when :eval_return
+            thrower_closure = select_closure(DEF | LAMBDA, break_after: MODULE | TOP)
+
+            if thrower_closure
+              thrower_closure.register_catcher(:eval_return)
+            end
+          when :next, :redo
+            thrower_closure = select_closure(ITER | LOOP_INSIDE, break_after: DEF | MODULE | TOP)
+            last_closure = select_closure(JS_FUNCTION | JS_LOOP_INSIDE)
+
+            if !thrower_closure
+              error 'Invalid next'
+            elsif thrower_closure == last_closure
+              if thrower_closure.is? LOOP_INSIDE
+                push 'continue'
+              elsif thrower_closure.is? ITER | LAMBDA
+                push 'return ', expr_or_nil(value)
+              end
+            else
+              generate_thrower(:next, thrower_closure, value)
+            end
+          when :break
+            thrower_closure = select_closure(SEND | LAMBDA | LOOP, break_after: DEF | MODULE | TOP)
+            last_closure = select_closure(JS_FUNCTION | JS_LOOP)
+
+            if !thrower_closure
+              iter_closure = select_closure(ITER, break_after: DEF | MODULE | TOP)
+              if iter_closure
+                generate_thrower_without_catcher(:break, iter_closure, value)
+              else
+                error 'Invalid break'
+              end
+            elsif thrower_closure == last_closure
+              if thrower_closure.is? JS_FUNCTION | LAMBDA
+                push 'return ', expr_or_nil(value)
+              elsif thrower_closure.is? LOOP
+                push 'break'
+              end
+            else
+              generate_thrower(:break, thrower_closure, value)
+            end
+          when :retry
+            thrower_closure = select_closure(RESCUE_RETRIER, break_after: DEF | MODULE | TOP)
+            last_closure = select_closure(JS_LOOP_INSIDE)
+
+            if !thrower_closure
+              error 'Invalid retry'
+            elsif thrower_closure == last_closure
+              push 'continue'
+            else
+              generate_thrower(:retry, thrower_closure, value)
+            end
+          end
+        end
+
+        def closure_is?(type)
+          @closure.is?(type)
+        end
+
+        # Generate a catcher if thrower has been used
+        def compile_catcher
+          catchers = @closure.catchers
+
+          return if catchers.empty?
+
+          helper :thrower
+
+          push "} catch($e) {"
+          indent do
+            @closure.catchers.each do |type|
+              case type
+              when :eval_return
+                line "if ($e === Opal.t_eval_return) return $e.$v;"
+              else
+                line "if ($e === $t_#{type}) return $e.$v;"
+              end
+            end
+            line "throw $e;"
+          end
+          line "}"
+
+          unshift "return " if closure_is? SEND
+
+          unshift "var ", catchers.map { |type| "$t_#{type} = $thrower('#{type}')" }.join(", "), "; "
+          unshift "try { "
+
+          unless closure_is? JS_FUNCTION
+            if scope.await_encountered
+              wrap "(await (async function(){", "})())"
+            else
+              wrap "(function(){", "})()"
+            end
+          end
+        end
+      end
+
+      module CompilerSupport
+        def closure_stack
+          @closure_stack ||= []
+        end
+      end
+    end
+  end
+end

data/lib/opal/nodes/def.rb

@@ -56,22 +56,18 @@ module Opal
 
           inline_params = process(inline_args)
 
-          stmt_code = stmt(compiler.returns(stmts))
+          in_closure(Closure::DEF | Closure::JS_FUNCTION) do
+            stmt_code = stmt(compiler.returns(stmts))
 
-          compile_block_arg
+            compile_block_arg
 
-          add_temp 'self = this' if @define_self
+            add_temp 'self = this' if @define_self
 
-          compile_arity_check
+            compile_arity_check
 
-          unshift "\n#{current_indent}", scope.to_vars
+            unshift "\n#{current_indent}", scope.to_vars
 
-          line stmt_code
-
-          if scope.catch_return
-            unshift "try {\n"
-            line '} catch ($returner) { if ($returner === Opal.returner) { return $returner.$v }'
-            push ' throw $returner; }'
+            line stmt_code
           end
         end
 

data/lib/opal/nodes/definitions.rb

@@ -54,9 +54,11 @@ module Opal
         elsif children.size == 1
           compile_inline_children(returned_children, @level)
         else
-          compile_children(returned_children, @level)
+          in_closure do
+            compile_children(returned_children, @level)
+          end
 
-          if scope.parent.await_encountered
+          if scope.parent&.await_encountered
             wrap '(await (async function() {', '})())'
           else
             wrap '(function() {', '})()'

data/lib/opal/nodes/if.rb

@@ -27,6 +27,8 @@ module Opal
       end
 
       def compile_with_if
+        push_closure if expects_expression?
+
         truthy = self.truthy
         falsy = self.falsy
 
@@ -60,15 +62,23 @@ module Opal
           line 'return nil;' if expects_expression?
         end
 
+        pop_closure if expects_expression?
+
         if expects_expression?
+          return_kw = 'return ' if returning_if?
+
           if scope.await_encountered
-            wrap '(await (async function() {', '})())'
+            wrap "#{return_kw}(await (async function() {", '})())'
           else
-            wrap '(function() {', '})()'
+            wrap "#{return_kw}(function() {", '})()'
           end
         end
       end
 
+      def returning_if?
+        @sexp.meta[:returning]
+      end
+
       def truthy
         returnify(true_body)
       end

data/lib/opal/nodes/iter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'opal/nodes/node_with_args'
-require 'opal/rewriters/break_finder'
 
 module Opal
   module Nodes
@@ -18,12 +17,17 @@ module Opal
         blockopts = []
         blockopts << "$$arity: #{arity}"
         blockopts << "$$s: #{scope.self}" if @define_self
-        blockopts << "$$brk: $brk" if contains_break?
+        blockopts << "$$brk: #{@closure.throwers[:break]}" if @closure&.throwers&.key? :break
+        blockopts << "$$ret: #{@closure.throwers[:return]}" if @closure&.throwers&.key? :return
 
         if compiler.arity_check?
           blockopts << "$$parameters: #{parameters_code}"
         end
 
+        if compiler.enable_source_location?
+          blockopts << "$$source_location: #{source_location}"
+        end
+
         # MRI expands a passed argument if the block:
         # 1. takes a single argument that is an array
         # 2. has more that one argument
@@ -62,18 +66,14 @@ module Opal
 
           compile_arity_check
 
-          body_code = stmt(returned_body)
-
-          add_temp "self = #{identity}.$$s == null ? this : #{identity}.$$s" if @define_self
+          in_closure(Closure::JS_FUNCTION | Closure::ITER | (@is_lambda ? Closure::LAMBDA : 0)) do
+            body_code = stmt(returned_body)
 
-          to_vars = scope.to_vars
+            add_temp "self = #{identity}.$$s == null ? this : #{identity}.$$s" if @define_self
 
-          line body_code
+            to_vars = scope.to_vars
 
-          if scope.catch_return
-            unshift "try {\n"
-            line '} catch ($returner) { if ($returner === Opal.returner) { return $returner.$v }'
-            push ' throw $returner; }'
+            line body_code
           end
         end
 
@@ -135,12 +135,6 @@ module Opal
       def arity_check_node
         s(:iter_arity_check, original_args)
       end
-
-      def contains_break?
-        finder = Opal::Rewriters::BreakFinder.new
-        finder.process(@sexp)
-        finder.found_break?
-      end
     end
   end
 end

data/lib/opal/nodes/logic.rb

@@ -8,13 +8,7 @@ module Opal
       handle :next
 
       def compile
-        if in_while?
-          push 'continue;'
-        elsif scope.iter?
-          push 'return ', expr_or_nil(value), ';'
-        else
-          error 'Invalid next'
-        end
+        thrower(:next, value)
       end
 
       def value
@@ -35,35 +29,7 @@ module Opal
       children :value
 
       def compile
-        if in_while?
-          compile_while
-        elsif scope.iter?
-          compile_iter
-        else
-          error 'void value expression: cannot use break outside of iter/while'
-        end
-      end
-
-      def compile_while
-        if while_loop[:closure]
-          push 'return ', expr_or_nil(value)
-        else
-          push 'break;'
-        end
-      end
-
-      def compile_iter
-        error 'break must be used as a statement' unless stmt?
-
-        line 'Opal.brk(', break_val, ', $brk)'
-      end
-
-      def break_val
-        if value.nil?
-          expr(s(:nil))
-        else
-          expr(value)
-        end
+        thrower(:break, value)
       end
     end
 
@@ -81,8 +47,8 @@ module Opal
       end
 
       def compile_while
-        while_loop[:use_redo] = true
-        push "#{while_loop[:redo_var]} = true; continue;"
+        push "#{while_loop[:redo_var]} = true;"
+        thrower(:redo)
       end
 
       def compile_iter
@@ -110,6 +76,13 @@ module Opal
       end
     end
 
+    class RetryNode < Base
+      handle :retry
+
+      def compile
+        thrower(:retry)
+      end
+    end
 
     class ReturnNode < Base
       handle :return
@@ -118,37 +91,16 @@ module Opal
 
       def return_val
         if value.nil?
-          expr(s(:nil))
+          s(:nil)
         elsif children.size > 1
-          expr(s(:array, *children))
+          s(:array, *children)
         else
-          expr(value)
+          value
         end
       end
 
-      def return_in_iter?
-        if (scope.iter? && !scope.lambda?) && parent_def = scope.find_parent_def
-          parent_def
-        end
-      end
-
-      def return_expr_in_def?
-        return scope if expr? && (scope.def? || scope.lambda?)
-      end
-
-      def scope_to_catch_return
-        return_in_iter? || return_expr_in_def?
-      end
-
       def compile
-        if def_scope = scope_to_catch_return
-          def_scope.catch_return = true
-          push 'Opal.ret(', return_val, ')'
-        elsif stmt?
-          push 'return ', return_val
-        else
-          error 'void value expression: cannot return as an expression'
-        end
+        thrower(:return, return_val)
       end
     end
 

data/lib/opal/nodes/module.rb

@@ -24,7 +24,9 @@ module Opal
           line "  var self = $module($base, '#{name}');"
           in_scope do
             scope.name = name
-            compile_body
+            in_closure(Closure::MODULE | Closure::JS_FUNCTION) do
+              compile_body
+            end
           end
 
           if await_encountered

data/lib/opal/nodes/rescue.rb

@@ -10,6 +10,8 @@ module Opal
       children :begn, :ensr
 
       def compile
+        push_closure if wrap_in_closure?
+
         push 'try {'
 
         in_ensure do
@@ -49,6 +51,8 @@ module Opal
 
         line '}'
 
+        pop_closure if wrap_in_closure?
+
         if wrap_in_closure?
           if scope.await_encountered
             wrap '(await (async function() { ', '; })())'
@@ -79,6 +83,10 @@ module Opal
         rescue_else_code = compiler.returns(rescue_else_code) unless stmt?
         rescue_else_code
       end
+
+      def has_rescue_else?
+        @sexp.meta[:has_rescue_else]
+      end
     end
 
     class RescueNode < Base
@@ -94,6 +102,15 @@ module Opal
           line 'var $no_errors = true;'
         end
 
+        closure_type = Closure::NONE
+        closure_type |= Closure::JS_FUNCTION if expr? || recv?
+        if has_retry?
+          closure_type |= Closure::JS_LOOP        \
+                       |  Closure::JS_LOOP_INSIDE \
+                       |  Closure::RESCUE_RETRIER
+        end
+        push_closure(closure_type) if closure_type != Closure::NONE
+
         in_rescue(self) do
           push 'try {'
           indent do
@@ -133,10 +150,12 @@ module Opal
             end
             push '}'
           end
-
-          wrap "#{retry_id}: do { ", ' break; } while(1)' if retry_id
         end
 
+        pop_closure if closure_type != Closure::NONE
+
+        wrap 'do { ', ' break; } while(1)' if has_retry?
+
         # Wrap a try{} catch{} into a function
         # when it's an expression
         # or when there's a method call after begin;rescue;end
@@ -168,11 +187,9 @@ module Opal
         !in_ensure? && has_rescue_else?
       end
 
-      def gen_retry_id
-        @retry_id ||= scope.gen_retry_id
+      def has_retry?
+        @sexp.meta[:has_retry]
       end
-
-      attr_reader :retry_id
     end
 
     class ResBodyNode < Base
@@ -209,14 +226,5 @@ module Opal
         body_code
       end
     end
-
-    class RetryNode < Base
-      handle :retry
-
-      def compile
-        error 'Invalid retry' unless in_resbody?
-        push "continue #{scope.current_rescue.gen_retry_id}"
-      end
-    end
   end
 end

data/lib/opal/nodes/scope.rb

@@ -197,6 +197,12 @@ module Opal
         @temps.push(tmp)
       end
 
+      def prepend_scope_temp(tmp)
+        return if has_temp?(tmp)
+
+        @temps.unshift(tmp)
+      end
+
       def has_temp?(tmp)
         @temps.include? tmp
       end
@@ -405,7 +411,7 @@ module Opal
         add_temp "#{self.block_name} = #{scope_name}.$$p || nil"
 
         unless @block_prepared
-          line "delete #{scope_name}.$$p;"
+          line "#{scope_name}.$$p = null;"
           @block_prepared = true
         end
       end