opal 1.7.4 → 1.8.0.beta1

data/benchmark-ips/bm_slice_or_not.rb

@@ -0,0 +1,53 @@
+%x{
+  // Minify common function calls
+  var $call      = Function.prototype.call;
+  var $bind      = Function.prototype.bind;
+  var $has_own   = Object.hasOwn || $call.bind(Object.prototype.hasOwnProperty);
+  var $set_proto = Object.setPrototypeOf;
+  var $slice     = $call.bind(Array.prototype.slice);
+  var $splice    = $call.bind(Array.prototype.splice);
+
+  var cnt = 0;
+  var fun = function(a,b,c) {
+    cnt += a + b + c;
+  }
+}
+
+Benchmark.ips do |x|
+  ary = [1,2,3]
+  obj = `{0: 1, 1: 2, 2: 3, length: 3}`
+
+  x.report('Array.from(array)') do
+    `fun.apply(null, Array.from(ary))`
+  end
+
+  x.report('Array.from(obj)') do
+    `fun.apply(null, Array.from(obj))`
+  end
+
+  x.report('$slice(array)') do
+    `fun.apply(null, $slice(ary))`
+  end
+
+  x.report('$slice(obj)') do
+    `fun.apply(null, $slice(obj))`
+  end
+
+  x.report('array') do
+    `fun.apply(null, ary)`
+  end
+
+  x.report('obj') do
+    `fun.apply(null, obj)`
+  end
+
+  x.report('$slice?(array)') do
+    `fun.apply(null, ary.$$is_array ? ary : $slice(ary))`
+  end
+
+  x.report('$slice?(obj)') do
+    `fun.apply(null, obj.$$is_array ? obj : $slice(obj))`
+  end
+
+  x.compare!
+end

data/docs/bridging.md

@@ -0,0 +1,112 @@
+# Opal Bridging
+
+## Intro
+
+Opal's "bridging" makes JavaScript objects become Ruby object in Opal, boosting language interoperability and performance by using native JavaScript versions of certain Ruby classes.
+
+## Bridging Basics
+
+Opal modifies the prototype chain of a JavaScript constructor function by injecting a Ruby class and its superclasses, enabling bridged JavaScript classes to inherit Ruby behaviors.
+
+Prototype chain pre-bridging: 
+
+- constructor (window.String)
+  - JavaScript prototype chain (window.Object)
+    - null
+
+After bridging with `::Object`:
+
+- constructor (window.String)
+  - Ruby superclass chain (Opal.Object, Opal.Kernel, Opal.BasicObject)
+    - JavaScript prototype chain (window.Object)
+      - null
+
+The `Opal.bridge` function is used for this, allowing the JavaScript class to become a Ruby class. You can also use a syntax like: ```class MyCar < `Car` ``` which counterintuitively doesn't mean inheritance - `MyCar`'s superclass will be Object, but `MyCar` will be bridged into native JavaScript `Car` class.
+
+The bridged JavaScript classes are usable in Ruby, but with an adapted interface: JavaScript methods accessed from Ruby use x-strings and Ruby methods accessed from JavaScript use $-prefixed method names (e.g., reduce->$reduce). 
+
+This strategy avoids type casting for bridged objects and boosts performance by utilizing native JavaScript objects. 
+
+Example:
+
+JavaScript `Car` class:
+
+```javascript
+class Car {
+  constructor(make, model) {
+    this.make = make;
+    this.model = model;
+  }
+
+  getCarInfo() {
+    return `${this.make} ${this.model}`;
+  }
+}
+```
+
+Bridged Ruby `MyCar` class:
+
+```ruby
+class MyCar < `Car`
+  def self.new(make, model)
+    `new Car(make, model)`
+  end
+
+  def car_info
+    `self.getCarInfo()`
+  end
+end
+
+car = MyCar.new('Toyota', 'Corolla')
+puts car.car_info  # Outputs: "Toyota Corolla"
+```
+
+This bridges `Car` to `MyCar`, creating a `Car` instance with `new Car(make, model)`. We call `getCarInfo()` via `self`, referencing the same JavaScript and Ruby object due to bridging. Thus, creating a `MyCar` instance makes a `Car` instance, and `car_info` on the `car` object outputs `"Toyota Corolla"`. This shows seamless Ruby-JavaScript interaction via bridging.
+
+## Inheritance & Bridging
+
+Creating a subclass of a native JavaScript class is possible. Bridging doesn't affect JavaScript's behavior or inheritance hierarchy.
+
+## Bridging Considerations
+
+### Bridged Class Methods
+
+Access JavaScript class methods as properties on the constructor with `class.$$constructor`, where `class` is a Ruby class. You can access it using `self`.
+
+### Performance
+
+Bridging is quicker than wrapping as no wrapper object is used, but altering the prototype chain could affect JavaScript engine performance.
+
+### Exception Handling
+
+JavaScript `Error` is bridged to Ruby `Exception` for unified error handling.
+
+### Native JavaScript Interactions
+
+Use x-strings for interacting with native JavaScript. The `Native` class wraps JavaScript objects and offers a Ruby-like API.
+
+### Type Conversions
+
+With bridging creating equivalent Ruby and JavaScript objects, no explicit type conversion is needed. The `Native` library's `#to_n` is how you convert non-bridged objects.
+
+## Bridged Classes in Corelib
+
+Opal's core library bridges several commonly used JavaScript classes, including `Array`, `Boolean`, `Number` (think: `Float` which also may act as an `Integer`), `Proc`, `Time`, `RegExp`, and `String`, allowing interaction with these JavaScript instances as their Ruby equivalents. Also `Hash` bridges the Javascript `Map` class and works very well between Javascript and Opal if primitives of the Javascript types "string", "number" and "symbol" (which must be global, generated with `Symbol.for()`) are used as keys. When other types or objects are used as keys, there may be issues retrieving the Map entries from each language, because the original references of the objects that have been used as keys are required for retrieval. When using a `Map` with object keys passed from Javascript as Hash in Opal, calling `Hash#rehash` may resolve issues and make entries accessible.
+
+However, Opal doesn't bridge common JavaScript classes like `Set` due to significant differences in behavior and interfaces between Ruby and JavaScript.
+
+## Drawbacks
+
+Bridging effectively utilizes JavaScript objects within Ruby, but it does have its downsides.
+
+The main drawback of Opal bridging is that it modifies the prototypes of JavaScript classes, potentially leading to prototype pollution. This can cause conflicts with other JavaScript code expecting the prototype in its original state, potentially causing hard-to-trace bugs or slower code execution due to changes impacting the JavaScript engine's performance.
+
+Additionally, bridging requires comprehensive knowledge of both Ruby and JavaScript, and understanding how Opal implements the bridge. Incorrect usage can lead to complex, hard-to-debug issues.
+
+An alternative to bridging is using `Native::Wrapper`. This module in Opal's standard library allows interaction with JavaScript objects without modifying their prototypes. It offers a Ruby-friendly API for accessing and calling JavaScript methods, as well as handling JavaScript properties, thus avoiding the prototype pollution issue.
+
+In conclusion, bridging provides powerful functionality for Ruby-JavaScript code interaction, but it should be used cautiously and with a deep understanding of its implications. Depending on your needs, `Native::Wrapper` may be a safer and more intuitive alternative.
+
+## Conclusion
+
+Opal's bridging mechanism offers an enticing method for combining Ruby and JavaScript's strengths into a single environment. Despite requiring caution due to potential drawbacks, bridging enables developers to create Ruby idiomatic APIs for accessing JavaScript code. By leveraging this mechanism, we can redefine conventional web programming paradigms and create more vibrant, dynamic applications.

data/docs/compiled_ruby.md

@@ -78,18 +78,17 @@ Ruby syntaxes for word arrays etc are also supported.
 
 #### Hash
 
-Inside a generated Ruby script, a function `Opal.hash` is available which
-creates a new hash. This is also available in JavaScript as `Opal.hash`
-and simply returns a new instance of the `Hash` class.
+Inside Javascript `new Map()` can be used, which
+creates simply a new instance of the `Hash` class.
 
 ```ruby
-{ :foo => 100, :baz => 700 }    # => Opal.hash("foo", 100, "baz", 700)
-{ foo: 42, bar: [1, 2, 3] }     # => Opal.hash("foo", 42, "bar", [1, 2, 3])
+{ :foo => 100, :baz => 700 }    # => new Map([["foo", 100], ["baz", 700]])
+{ foo: 42, bar: [1, 2, 3] }     # => new Map([["foo", 42], ["bar", [1, 2, 3]]])
 ```
 
 #### Range
 
-Similar to hash, there is a function `Opal.range` available to create
+There is a function `Opal.range` available to create
 range instances.
 
 ```ruby
@@ -598,10 +597,10 @@ array.$map(); // => [2,4,6]
 
 ### Hash
 
-Since Ruby hashes are implemented directly with an Opal class, there's no "toll-free" bridging available (unlike with strings and arrays, for example). However, it's quite possible to interact with hashes from JavaScript:
+Since Ruby hashes are bridged to `Map`. It's quite possible to interact with hashes from JavaScript:
 
 ```javascript
-var myHash = Opal.hash({a: 1, b: 2});
+var myHash = new Map([['a', 1], ['b', 2]]);
 // output of $inspect: {"a"=>1, "b"=>2}
 myHash.$store('a', 10);
 // output of $inspect: {"a"=>10, "b"=>2}
@@ -609,10 +608,11 @@ myHash.$fetch('b','');
 // 2
 myHash.$fetch('z','');
 // ""
-myHash.$update(Opal.hash({b: 20, c: 30}));
+myHash.$update(new Map([['b', 20], ['c', 30]]));
 // output of $inspect: {"a"=>10, "b"=>20, "c"=>30}
 myHash.$to_n(); // provided by the Native module
-// output: {"a": 10, "b": 20, "c": 30} aka a standard JavaScript object
+// output: Map(2) {'b' => 20, 'c' => 30}
+// aka a standard JavaScript Map
 ```
 
 NOTE: Be aware `Hash#to_n` produces a duplicate copy of the hash.

data/docs/getting_started.md

@@ -1,10 +1,10 @@
 # Getting Started
 
-Opal is a ruby to javascript compiler, an implementation of the ruby corelib and stdlib, and associated gems for building fast client side web applications in ruby.
+Opal is a Ruby to JavaScript compiler, an implementation of the Ruby corelib and stdlib, and associated gems for building fast client-side web applications in Ruby.
 
 ## Installation
 
-Opal is available as a gem, and can be installed via:
+Opal is available as a gem and can be installed via:
 
 ```
 $ gem install opal
@@ -16,49 +16,45 @@ Or added to your Gemfile as:
 gem 'opal'
 ```
 
-## Getting started with Opal
+## Getting Started with Opal
 
-At its very core, opal provides a simple method of compiling a string of ruby into javascript that can run on top of the opal runtime, provided by `opal.js`:
+At its core, Opal provides a simple method of compiling a string of Ruby into JavaScript that can run on top of the Opal runtime:
 
 ```ruby
 Opal.compile("[1, 2, 3].each { |a| puts a }")
 # => "(function() { ... })()"
 ```
 
-`opal` includes sprockets support for compiling Ruby (and ERB) assets, and treating them as first class JavaScript citizens. It works in a similar way to CoffeeScript, where JavaScript files can simply require Ruby sources, and Ruby sources can require JavaScript and other Ruby files.
+Opal allows for Ruby (and ERB) assets to be compiled and treated as first-class JavaScript citizens. Ruby sources can require JavaScript and other Ruby files, working similar to CoffeeScript.
 
-This relies on the Opal load path. Any gem containing opal code registers that directory to the Opal load path. Opal will then use all Opal load paths when running sprockets instances. For rails applications, `opal-rails` does this automatically. For building a simple application, we have to do this manually.
+This relies on the Opal load path. Any gem containing Opal code registers that directory to the Opal load path. Opal will then use all Opal load paths when running instances.
 
+### Adding Lookup Paths
 
-### Adding lookup paths
+Opal uses a load path to create a set of locations from which Opal can require files. If you want to add a directory to this load path, you can add it to the global environment.
 
-Opal uses a load path which works with sprockets to create a set of locations which opal can require files
-from. If you want to add a directory to this load path, you can add it to the global environment.
-
-In the `Opal` module, a property `paths` is used to hold the load paths which
-`Opal` uses to require files from. You can add a directory to this:
+In the `Opal` module, a property `paths` is used to hold the load paths which `Opal` uses to require files from. You can add a directory to this:
 
 ```ruby
 Opal.append_path '../my_lib'
 ```
 
-Now, any ruby files in this directory can be discovered.
-
+Now, any Ruby files in this directory can be discovered.
 
 ## FAQ
 
-### Why does Opal exist?
+### Why Does Opal Exist?
 
-To try and keep ruby relevant in a world where client-side applications are making javascript the primary development platform.
+Opal aims to keep Ruby relevant in a world where client-side applications are making JavaScript the primary development platform.
 
-### How compatible is Opal?
+### How Compatible is Opal?
 
-We run opal against the [ruby spec](https://github.com/ruby/spec) as our primary testing setup. We try to make Opal as compatible as possible, whilst also taking into account restrictions of JavaScript when applicable. Opal supports the majority of ruby syntax features, as well as a very large part of the corelib implementation. We support method\_missing, modules, classes, instance\_exec, blocks, procs and lots lots more. Opal can compile and run RSpec unmodified, as well as self hosting the compiler at runtime.
+Opal is tested against the [Ruby spec](https://github.com/ruby/spec) as our primary testing setup. The goal is to make Opal as compatible as possible while also considering the restrictions of JavaScript when applicable. Opal supports the majority of Ruby syntax features, as well as a very large part of the corelib implementation. Opal can compile and run RSpec unmodified, as well as self-host the compiler at runtime.
 
-### What version of ruby does Opal target?
+### What Version of Ruby Does Opal Target?
 
-We are running tests under ruby 3.0.0 conditions, but are mostly compatible with 2.6 level features.
+Opal's tests are run under Ruby 3.2.0 conditions, but it remains mostly compatible with 2.6 level features.
 
-### Why doesn't Opal support mutable strings?
+### Why Doesn't Opal Support Mutable Strings?
 
-All strings in Opal are immutable because ruby strings just get compiled directly into javascript strings, which are immutable. Wrapping ruby strings as a custom JavaScript object would add a lot of overhead as well as making interaction between ruby and javascript libraries more difficult.
+All strings in Opal are immutable because Ruby strings are compiled directly into JavaScript strings, which are immutable. Wrapping Ruby strings as a custom JavaScript object would add a lot of overhead and complicate interaction between Ruby and JavaScript libraries.

data/docs/releasing.md

@@ -8,21 +8,14 @@ _This guide is a work-in-progress._
 
 All of the following is now covered by `bin/rake release:prepare VERSION=v1.2.3`
 
-### Updating the version
-
-- Update `lib/opal/version.rb`
-- Update `opal/corelib/constants.rb` with the same version number along with release dates
-
-### Updating the changelog
-
-- Ensure all the unreleased changes are documented in UNRELEASED.md
-- [skip for pre-releases] Run `bin/rake changelog VERSION=v1.2.3` specifying the version number you're about to release
-- [skip for pre-releases] Empty UNRELEASED.md
-
-### The commit
-
-- Commit the updated changelog along with the version bump using this commit message:
-  "Release v1.2.3"
+1. Update the version
+  - Update `lib/opal/version.rb`
+  - Update `opal/corelib/constants.rb` with the same version number along with release dates
+2. Update the changelog
+  - Ensure all the unreleased changes are documented in UNRELEASED.md
+  - [skip for pre-releases] Run `bin/rake changelog VERSION=v1.2.3` specifying the version number you're about to release
+  - [skip for pre-releases] Empty UNRELEASED.md
+3. Commit the updated changelog along with the version bump using this commit message: "Release v1.2.3"
 
 ---
 
@@ -56,4 +49,3 @@ All of the following is now covered by `bin/rake release:prepare VERSION=v1.2.3`
 - Create a new pull request that:
   - Updates a version to `v1.x.0.dev` in both `lib/opal/version.rb` and `opal/corelib/constants.rb`
 - Remember to merge that PR before merging anything else next once we decide to not release any more point releases from `master`.
-

data/lib/opal/cli_runners/chrome_cdp_interface.rb

@@ -1,3 +1,4 @@
+# backtick_javascript: true
 # frozen_string_literal: true
 
 # This script I converted into Opal, so that I don't have to write

data/lib/opal/cli_runners/firefox_cdp_interface.rb

@@ -1,3 +1,4 @@
+# backtick_javascript: true
 # frozen_string_literal: true
 
 # This script I converted into Opal, so that I don't have to write

data/lib/opal/compiler.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+if RUBY_ENGINE == 'opal'
+  require 'corelib/string/unpack'
+end
 require 'set'
 require 'opal/parser'
 require 'opal/fragment'
@@ -8,6 +11,7 @@ require 'opal/eof_content'
 require 'opal/errors'
 require 'opal/magic_comments'
 require 'opal/nodes/closure'
+require 'opal/source_map'
 
 module Opal
   # Compile a string of ruby code into javascript.
@@ -184,6 +188,30 @@ module Opal
     # Adds comments for every method definition
     compiler_option :parse_comments, default: false, as: :parse_comments?
 
+    # @!method backtick_javascript?
+    #
+    # Allows use of a backtick operator (and `%x{}``) to embed verbatim JavaScript.
+    # If false, backtick operator will
+    compiler_option :backtick_javascript, default: nil, as: :backtick_javascript?, magic_comment: true
+
+    # Warn about impending compatibility break
+    def backtick_javascript_or_warn?
+      case backtick_javascript?
+      when true
+        true
+      when nil
+        @backtick_javascript_warned ||= begin
+          warning 'Backtick operator usage interpreted as intent to embed JavaScript; this code will ' \
+                  'break in Opal 2.0; add a magic comment: `# backtick_javascript: true`'
+          true
+        end
+
+        true
+      when false
+        false
+      end
+    end
+
     compiler_option :scope_variables, default: []
 
     # @!method async_await
@@ -572,7 +600,11 @@ module Opal
       when :return, :js_return, :returnable_yield
         sexp
       when :xstr
-        sexp.updated(nil, [s(:js_return, *sexp.children)])
+        if backtick_javascript_or_warn?
+          sexp.updated(nil, [s(:js_return, *sexp.children)])
+        else
+          sexp
+        end
       when :if
         cond, true_body, false_body = *sexp
         sexp.updated(

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

@@ -16,12 +16,13 @@ module Opal
         children :lvar_name, :default_value
 
         def compile
+          helper :hash_get
           key_name = @sexp.meta[:arg_name]
           scope.used_kwargs << key_name
 
           add_temp lvar_name
 
-          line "#{lvar_name} = $kwargs.$$smap[#{key_name.to_s.inspect}];"
+          line "#{lvar_name} = $hash_get($kwargs, #{key_name.to_s.inspect});"
 
           return if default_value.children[1] == :undefined
 

data/lib/opal/nodes/call.rb

@@ -366,7 +366,7 @@ module Opal
       end
 
       add_special :__OPAL_COMPILER_CONFIG__ do
-        push fragment "Opal.hash({ arity_check: #{compiler.arity_check?} })"
+        push fragment "(new Map([['arity_check', #{compiler.arity_check?}]]))"
       end
 
       add_special :lambda do |compile_default|

data/lib/opal/nodes/call_special.rb

@@ -60,8 +60,8 @@ module Opal
       end
     end
 
-    # /regexp/ =~ rhs
-    # s(:match_with_lvasgn, lhs, rhs)
+    # Handles match_with_lvasgn nodes which represent matching a regular expression
+    # with a right-hand side value and assigning the match result to a left-hand side variable.
     class Match3Node < Base
       handle :match_with_lvasgn
 
@@ -69,58 +69,82 @@ module Opal
 
       def compile
         sexp = s(:send, lhs, :=~, rhs)
+
         # Handle named matches like: /(?<abc>b)/ =~ 'b'
         if lhs.type == :regexp && lhs.children.first.type == :str
-          re = lhs.children.first.children.first
-          names = re.scan(/\(\?<([^>]*)>/).flatten.map(&:to_sym)
-          unless names.empty?
-            # $m3names = $~ ? $~.named_captures : {}
-            names_def = s(:lvasgn, :$m3names,
-              s(:if,
-                s(:gvar, :$~),
-                s(:send, s(:gvar, :$~), :named_captures),
-                s(:hash)
-              )
-            )
+          names = extract_names(lhs)
 
-            names = names.map do |name|
-              # abc = $m3names[:abc]
-              s(:lvasgn, name,
-                s(:send,
-                  s(:lvar, :$m3names),
-                  :[],
-                  s(:sym, name)
-                )
-              )
-            end
-
-            if stmt?
-              # We don't care about a return value of this one, so we
-              # ignore it and just assign the local variables.
-              #
-              # (/(?<abc>b)/ =~ 'f')
-              # $m3names = $~ ? $~.named_captures : {}
-              # abc = $m3names[:abc]
-              sexp = s(:begin, sexp, names_def, *names)
-            else
-              # We actually do care about a return value, so we must
-              # keep it saved.
-              #
-              # $m3tmp = (/(?<abc>b)/ =~ 'f')
-              # $m3names = $~ ? $~.named_captures : {}
-              # abc = $m3names[:abc]
-              # $m3tmp
-              sexp = s(:begin,
-                s(:lvasgn, :$m3tmp, sexp),
-                names_def,
-                *names,
-                s(:lvar, :$m3tmp)
-              )
-            end
+          unless names.empty?
+            names_def = generate_names_definition
+            names_assignments = generate_names_assignments(names)
+
+            sexp = if stmt?
+                     handle_statement(sexp, names_def, names_assignments)
+                   else
+                     handle_non_statement(sexp, names_def, names_assignments)
+                   end
           end
         end
+
         push process(sexp, @level)
       end
+
+      private
+
+      def extract_names(regexp_node)
+        re = regexp_node.children.first.children.first
+        re.scan(/\(\?<([^>]*)>/).flatten.map(&:to_sym)
+      end
+
+      def generate_names_definition
+        # Generate names definition: $m3names = $~ ? $~.named_captures : {}
+        s(:lvasgn, :$m3names,
+          s(:if,
+            s(:gvar, :$~),
+            s(:send, s(:gvar, :$~), :named_captures),
+            s(:hash)
+          )
+        )
+      end
+
+      def generate_names_assignments(names)
+        # Generate names assignments: abc = $m3names[:abc]
+        names.map do |name|
+          s(:lvasgn, name,
+            s(:send,
+              s(:lvar, :$m3names),
+              :[],
+              s(:sym, name)
+            )
+          )
+        end
+      end
+
+      def handle_statement(sexp, names_def, names_assignments)
+        # We don't care about a return value of this one, so we
+        # ignore it and just assign the local variables.
+        #
+        # (/(?<abc>b)/ =~ 'f')
+        # $m3names = $~ ? $~.named_captures : {}
+        # abc = $m3names[:abc]
+        s(:begin, sexp, names_def, *names_assignments)
+      end
+
+      def handle_non_statement(sexp, names_def, names_assignments)
+        # We actually do care about a return value, so we must
+        # keep it saved.
+        #
+        # $m3tmp = (/(?<abc>b)/ =~ 'f')
+        # $m3names = $~ ? $~.named_captures : {}
+        # abc = $m3names[:abc]
+        # $m3tmp
+        s(:begin,
+          s(:lvasgn, :$m3tmp, sexp),
+          names_def,
+          *names_assignments,
+          s(:lvar, :$m3tmp)
+        )
+      end
     end
   end
 end

data/lib/opal/nodes/closure.rb

@@ -102,7 +102,7 @@ module Opal
         def generate_thrower(type, closure, value)
           id = closure.register_catcher(type)
           closure.register_thrower(type, id)
-          push id, '.$throw(', expr_or_empty(value), ')'
+          push id, '.$throw(', expr_or_nil(value), ', ', scope.identify!, '.$$is_lambda)'
           id
         end
 
@@ -113,11 +113,11 @@ module Opal
             id = closure.throwers[type]
           else
             id = compiler.unique_temp('t_')
-            scope = closure.node.scope&.parent || top_scope
-            scope.add_scope_temp("#{id} = $thrower('#{type}')")
+            parent_scope = closure.node.scope&.parent || top_scope
+            parent_scope.add_scope_temp("#{id} = $thrower('#{type}')")
             closure.register_thrower(type, id)
           end
-          push id, '.$throw(', expr_or_empty(value), ')'
+          push id, '.$throw(', expr_or_nil(value), ', ', scope.identify!, '.$$is_lambda)'
           id
         end
 
@@ -132,7 +132,7 @@ module Opal
               if iter_closure
                 generate_thrower_without_catcher(:return, iter_closure, value)
               elsif compiler.eval?
-                push 'Opal.t_eval_return.$throw(', expr_or_empty(value), ')'
+                push 'Opal.t_eval_return.$throw(', expr_or_nil(value), ', false)'
               else
                 error 'Invalid return'
               end
@@ -211,9 +211,11 @@ module Opal
 
           helper :thrower
 
+          catchers_without_eval_return = catchers.grep_v(:eval_return)
+
           push "} catch($e) {"
           indent do
-            @closure.catchers.each do |type|
+            catchers.each do |type|
               case type
               when :eval_return
                 line "if ($e === Opal.t_eval_return) return $e.$v;"
@@ -225,9 +227,15 @@ module Opal
           end
           line "}"
 
+          unless catchers_without_eval_return.empty?
+            push " finally {", *catchers_without_eval_return.map { |type| "$t_#{type}.is_orphan = true;" }, "}"
+          end
+
           unshift "return " if closure_is? SEND
 
-          unshift "var ", catchers.map { |type| "$t_#{type} = $thrower('#{type}')" }.join(", "), "; "
+          unless catchers_without_eval_return.empty?
+            unshift "var ", catchers_without_eval_return.map { |type| "$t_#{type} = $thrower('#{type}')" }.join(", "), "; "
+          end
           unshift "try { "
 
           unless closure_is? JS_FUNCTION

data/lib/opal/nodes/defined.rb

@@ -80,7 +80,7 @@ module Opal
         push '  if (Opal.rescue($err, [Opal.Exception])) {'
         push '    try {'
         push '      return false;'
-        push '    } finally { Opal.pop_exception() }'
+        push '    } finally { Opal.pop_exception($err); }'
         push '  } else { throw $err; }'
         push '}})())'