opal 0.9.4 → 0.10.0.beta1

data/lib/opal/nodes/rescue.rb

@@ -16,7 +16,13 @@ module Opal
       end
 
       def compile
-        push "try {", expr(body), " } catch ($err) { ", expr(rescue_val), " }"
+        line "try {", expr(body), " } catch ($err) { "
+
+        indent do
+          line "if (Opal.rescue($err, [", expr(Sexp.new([:const, :StandardError])), "])) {"
+          line expr(rescue_val)
+          line "} else { throw $err; } }"
+        end
 
         wrap '(function() {', '})()' unless stmt?
       end
@@ -29,16 +35,56 @@ module Opal
 
       def compile
         push "try {"
-        line compiler.process(body_sexp, @level)
+
+        in_ensure do
+          line compiler.process(body_sexp, @level)
+        end
+
         line "} finally {"
-        line compiler.process(ensr_sexp, @level)
+
+        indent do
+          if has_rescue_else?
+            # $no_errors indicates thate there were no error raised
+            unshift "var $no_errors = true; "
+
+            # when there's a begin;rescue;else;ensure;end statement,
+            # ruby returns a result of the 'else' branch
+            # but invokes it before 'ensure'.
+            # so, here we
+            # 1. save the result of calling else to $rescue_else_result
+            # 2. call ensure
+            # 2. return $rescue_else_result
+            line "var $rescue_else_result;"
+            line "if ($no_errors) { "
+            indent do
+              line "$rescue_else_result = (function() {"
+              indent do
+                line compiler.process(compiler.returns(scope.rescue_else_sexp), @level)
+              end
+              line "})();"
+            end
+            line "}"
+            line compiler.process(ensr_sexp, @level)
+            line "if ($no_errors) { return $rescue_else_result; }"
+          else
+            line compiler.process(ensr_sexp, @level)
+          end
+        end
+
         line "}"
 
-        wrap '(function() {', '; })()' if wrap_in_closure?
+        wrap '(function() { ', '; })()' if wrap_in_closure?
       end
 
       def body_sexp
-        wrap_in_closure? ? compiler.returns(begn) : begn
+        if wrap_in_closure?
+          sexp = compiler.returns(begn)
+          # 'rescue' is an edge case that should be compiled to
+          # try { return function(){ ..rescue through try/catch.. }() }
+          sexp.type == :rescue ? s(:js_return, sexp) : sexp
+        else
+          sexp = begn
+        end
       end
 
       def ensr_sexp
@@ -46,7 +92,7 @@ module Opal
       end
 
       def wrap_in_closure?
-        recv? or expr?
+        recv? or expr? or has_rescue_else?
       end
     end
 
@@ -56,37 +102,74 @@ module Opal
       children :body
 
       def compile
-        handled_else = false
+        scope.rescue_else_sexp = children[1..-1].detect { |sexp| sexp.type != :resbody }
+        has_rescue_handlers = false
+
+        if handle_rescue_else_manually?
+          line "var $no_errors = true;"
+        end
 
         push "try {"
-        line(indent { process(body_code, @level) })
+        indent do
+          line process(body_code, @level)
+        end
         line "} catch ($err) {"
 
-        children[1..-1].each_with_index do |child, idx|
-          handled_else = true unless child.type == :resbody
+        indent do
+          if has_rescue_else?
+            line "$no_errors = false;"
+          end
 
-          push "else " unless idx == 0
-          push(indent { process(child, @level) })
-        end
+          children[1..-1].each_with_index do |child, idx|
+            # counting only rescue, ignoring rescue-else statement
+            if child.type == :resbody
+              has_rescue_handlers = true
 
-        # if no resbodys capture our error, then rethrow
-        unless handled_else
-          push "else { throw $err; }"
+              push " else " unless idx == 0
+              line process(child, @level)
+            end
+          end
+
+          # if no resbodys capture our error, then rethrow
+          push " else { throw $err; }"
         end
 
         line "}"
 
-        wrap '(function() { ', '})()' if expr?
+        if handle_rescue_else_manually?
+          # here we must add 'finally' explicitly
+          push "finally {"
+          indent do
+            line "if ($no_errors) { "
+            indent do
+              line "return (function() {"
+              indent do
+                line compiler.process(compiler.returns(scope.rescue_else_sexp), @level)
+              end
+              line "})();"
+            end
+            line "}"
+          end
+          push "}"
+        end
+
+        # Wrap a try{} catch{} into a function
+        # when it's an expression
+        # or when there's a method call after begin;rescue;end
+        wrap '(function() { ', '})()' if expr? or recv?
       end
 
       def body_code
         body_code = (body.type == :resbody ? s(:nil) : body)
+        body_code = compiler.returns body_code unless stmt?
+        body_code
+      end
 
-        if !stmt?
-          compiler.returns body_code
-        else
-          body_code
-        end
+      # Returns true when there's no 'ensure' statement
+      #  wrapping current rescue.
+      #
+      def handle_rescue_else_manually?
+        !scope.in_ensure? && scope.has_rescue_else?
       end
     end
 
@@ -96,36 +179,31 @@ module Opal
       children :args, :body
 
       def compile
-        push "if ("
+        push "if (Opal.rescue($err, ["
         if rescue_exprs.empty?
-          # if no expressions are given, then catch all errors
-          push "true"
+          # if no expressions are given, then catch StandardError only
+          push expr(Sexp.new([:const, :StandardError]))
         else
-          push "Opal.rescue($err, ["
           rescue_exprs.each_with_index do |rexpr, idx|
             push ', ' unless idx == 0
             push expr(rexpr)
           end
-          push "])"
         end
-        push ") {"
-
-        if variable = rescue_variable
-          variable[2] = s(:js_tmp, '$err')
-          push expr(variable), ';'
-        end
-
-        # Need to ensure we clear the current exception out after the rescue block ends
-        line "try {"
-        indent do
-          line process(rescue_body, @level)
-        end
-        line "} finally {"
+        push "])) {"
         indent do
-          line 'Opal.gvars["!"] = Opal.exceptions.pop() || Opal.nil;'
+          if variable = rescue_variable
+            variable[2] = s(:js_tmp, '$err')
+            push expr(variable), ';'
+          end
+
+          # Need to ensure we clear the current exception out after the rescue block ends
+          line "try {"
+          indent do
+            line process(rescue_body, @level)
+          end
+          line '} finally { Opal.pop_exception() }'
         end
         line "}"
-        line "}"
       end
 
       def rescue_variable?(variable)
@@ -144,7 +222,7 @@ module Opal
 
       def rescue_body
         body_code = (body || s(:nil))
-        body_code = compiler.returns(body_code) if !stmt?
+        body_code = compiler.returns(body_code) unless stmt?
         body_code
       end
     end

data/lib/opal/nodes/scope.rb

@@ -30,7 +30,9 @@ module Opal
       attr_accessor :uses_super
       attr_accessor :uses_zuper
 
-      attr_accessor :catch_return
+      attr_accessor :catch_return, :has_break
+
+      attr_accessor :rescue_else_sexp
 
       def initialize(*)
         super
@@ -169,14 +171,15 @@ module Opal
       end
 
       def has_local?(local)
-        return true if @locals.include? local or @args.include? local
+        return true if @locals.include? local or @args.include? local or @temps.include? local
         return @parent.has_local?(local) if @parent and @type == :iter
-
         false
       end
 
-      def add_scope_temp(*tmps)
-        @temps.push(*tmps)
+      def add_scope_temp(tmp)
+        return if has_temp?(tmp)
+
+        @temps.push(tmp)
       end
 
       def has_temp?(tmp)
@@ -277,6 +280,22 @@ module Opal
       def uses_block?
         @uses_block
       end
+
+      def has_rescue_else?
+        !!rescue_else_sexp
+      end
+
+      def in_ensure
+        return unless block_given?
+
+        @in_ensure = true
+        result = yield
+        @in_ensure = false
+      end
+
+      def in_ensure?
+        !!@in_ensure
+      end
     end
   end
 end

data/lib/opal/nodes/super.rb

@@ -5,92 +5,160 @@ module Opal
     # This base class is used just to child the find_super_dispatcher method
     # body. This is then used by actual super calls, or a defined?(super) style
     # call.
-    class BaseSuperNode < Base
-      children :arglist, :iter
+    class BaseSuperNode < CallNode
+      children :arglist, :raw_iter
 
-      def compile_dispatcher
-        if arglist or iter
-          iter = expr(iter_sexp)
-        else
-          scope.uses_block!
-          iter = '$iter'
-        end
+      def compile
         if scope.def?
           scope.uses_block!
-          scope_name = scope.identify!
-          class_name = scope.parent.name ? "$#{scope.parent.name}" : 'self.$$class.$$proto'
+        end
+
+        default_compile
+      end
+
+      private
+
+      # always on self
+      def recvr
+        s(:self)
+      end
 
-          if scope.defs
-            push "Opal.find_super_dispatcher(self, '#{scope.mid.to_s}', #{scope_name}, "
-            push iter
-            push ", #{class_name})"
+      def iter
+        # Need to support passing block up even if it's not referenced in this method at all
+        @iter ||= begin
+          if raw_iter
+            raw_iter
+          elsif arglist # TODO: Better understand this elsif vs. the else code path
+            s(:js_tmp, 'null')
           else
-            push "Opal.find_super_dispatcher(self, '#{scope.mid.to_s}', #{scope_name}, "
-            push iter
-            push ")"
+            scope.uses_block!
+            s(:js_tmp, '$iter')
           end
-        elsif scope.iter?
-          chain, cur_defn, mid = scope.get_super_chain
-          trys = chain.map { |c| "#{c}.$$def" }.join(' || ')
+        end
+      end
+
+      def method_jsid
+        raise 'Not implemented, see #add_method'
+      end
+
+      # Need a way to pass self into the method invocation
+      def redefine_this?(temporary_receiver)
+        true
+      end
+
+      def arguments_array?
+        # zuper is an implicit super argument array
+        super || @implicit_args
+      end
+
+      def containing_def_scope
+        return scope if scope.def?
+
+        # using super in a block inside a method is allowed, e.g.
+        # def a
+        #  { super }
+        # end
+        scope.find_parent_def
+      end
+
+      def defined_check_param
+        'false'
+      end
 
-          push "Opal.find_iter_super_dispatcher(self, #{mid}, (#{trys} || #{cur_defn}), null)"
+      def implicit_arguments_param
+        @implicit_args ? 'true' : 'false'
+      end
+
+      def super_method_invocation
+        def_scope = containing_def_scope
+        method_jsid = def_scope.mid.to_s
+        current_func = def_scope.identify!
+
+        if def_scope.defs
+          class_name = def_scope.parent.name ? "$#{def_scope.parent.name}" : 'self.$$class.$$proto'
+          "Opal.find_super_dispatcher(self, '#{method_jsid}', #{current_func}, #{defined_check_param}, #{class_name})"
         else
-          raise "Cannot call super() from outside a method block"
+          "Opal.find_super_dispatcher(self, '#{method_jsid}', #{current_func}, #{defined_check_param})"
         end
       end
 
-      def args
-        arglist || s(:arglist)
+      def super_block_invocation
+        chain, cur_defn, mid = scope.get_super_chain
+        trys = chain.map { |c| "#{c}.$$def" }.join(' || ')
+        implicit = @implicit_args.to_s
+
+        "Opal.find_iter_super_dispatcher(self, #{mid}, (#{trys} || #{cur_defn}), #{defined_check_param}, #{implicit_arguments_param})"
       end
 
-      def iter_sexp
-        iter || s(:js_tmp, 'null')
+      def add_method(temporary_receiver)
+        super_call = if scope.def?
+          super_method_invocation
+        elsif scope.iter?
+          super_block_invocation
+        else
+          raise 'unexpected compilation error'
+        end
+
+        if temporary_receiver
+          push "(#{temporary_receiver} = ", receiver_fragment, ", ", super_call, ")"
+        else
+          push super_call
+        end
       end
     end
 
     class DefinedSuperNode < BaseSuperNode
       handle :defined_super
 
-      def compile
-        # insert method body to find super method
-        self.compile_dispatcher
+      def defined_check_param
+        'true'
+      end
 
-        wrap '((', ') != null ? "super" : nil)'
+      def compile
+        add_method(nil)
+        # will never come back null with method missing on
+        if compiler.method_missing?
+          wrap '(!(', '.$$stub) ? "super" : nil)'
+        else
+          # TODO: With method_missing support off, something breaks in runtime.js's chain
+          wrap '((', ') != null ? "super" : nil)'
+        end
       end
     end
 
     class SuperNode < BaseSuperNode
       handle :super
 
-      children :arglist, :iter
-
       def compile
-        if arglist or iter
-          splat = has_splat?
-          args = expr(self.args)
-
-          unless splat
-            args = [fragment('['), args, fragment(']')]
-          end
-        else
-          if scope.def?
-            scope.uses_zuper = true
-            args = fragment('$zuper')
+        if arglist == nil
+          @implicit_args = true
+          if containing_def_scope
+            containing_def_scope.uses_zuper = true
+            @arguments_without_block = [s(:js_tmp, '$zuper')]
+            # If the method we're in has a block and we're using a default super call with no args, we need to grab the block
+            # If an iter (block via braces) is provided, that takes precedence
+            if (block_arg = formal_block_parameter) && !iter
+              expr = s(:block_pass, s(:lvar, block_arg[1]))
+              @arguments_without_block << expr
+            end
           else
-            args = fragment('$slice.call(arguments)')
+            @arguments_without_block = []
           end
         end
-
-        # compile our call to runtime to get super method
-        self.compile_dispatcher
-
-        push ".apply(self, "
-        push(*args)
-        push ")"
+        super
       end
 
-      def has_splat?
-        args.children.any? { |child| child.type == :splat }
+      private
+
+      def formal_block_parameter
+        case containing_def_scope
+          when Opal::Nodes::IterNode
+            containing_def_scope.extract_block_arg
+          when Opal::Nodes::DefNode
+            containing_def_scope.block_arg
+          else
+            raise "Don't know what to do with scope #{containing_def_scope}"
+        end
       end
     end
   end