opal 1.7.4 → 1.8.0.beta1

data/lib/opal/nodes/hash.rb

@@ -27,14 +27,12 @@ module Opal
       end
 
       def simple_keys?
-        keys.all? { |key| %i[sym str].include?(key.type) }
+        keys.all? { |key| %i[sym str int].include?(key.type) }
       end
 
       def compile
         if has_kwsplat
           compile_merge
-        elsif simple_keys?
-          compile_hash2
         else
           compile_hash
         end
@@ -47,8 +45,6 @@ module Opal
       # Each kwsplat overrides previosly defined keys
       # Hash k/v pairs override previously defined kwsplat values
       def compile_merge
-        helper :hash
-
         result, seq = [], []
 
         children.each do |child|
@@ -76,38 +72,26 @@ module Opal
       end
 
       # Compiles a hash without kwsplats
-      # with complex keys.
+      # with simple or complex keys.
       def compile_hash
-        helper :hash
-
         children.each_with_index do |pair, idx|
           key, value = pair.children
           push ', ' unless idx == 0
-          push expr(key), ', ', expr(value)
-        end
-
-        wrap '$hash(', ')'
-      end
-
-      # Compiles a hash without kwsplats
-      # and containing **only** string/symbols as keys.
-      def compile_hash2
-        hash_obj, hash_keys = {}, []
-        helper :hash2
-
-        keys.size.times do |idx|
-          key = keys[idx].children[0].to_s.inspect
-          hash_keys << key unless hash_obj.include? key
-          hash_obj[key] = expr(values[idx])
+          if %i[sym str].include?(key.type)
+            push "[#{key.children[0].to_s.inspect}", ', ', expr(value), ']'
+          else
+            push '[', expr(key), ', ', expr(value), ']'
+          end
         end
 
-        hash_keys.each_with_index do |key, idx|
-          push ', ' unless idx == 0
-          push "#{key}: "
-          push hash_obj[key]
+        if keys.empty?
+          push '(new Map())'
+        elsif simple_keys?
+          wrap '(new Map([', ']))'
+        else
+          helper :hash_rehash
+          wrap '$hash_rehash(new Map([', ']))'
         end
-
-        wrap "$hash2([#{hash_keys.join ', '}], {", '})'
       end
     end
 

data/lib/opal/nodes/if.rb

@@ -392,45 +392,53 @@ module Opal
       end
     end
 
-    class IFlipFlop < Base
-      handle :iflipflop
-
-      children :from, :to
-
-      # Is this an exclusive flip flop? If no, run both branches
-      def excl
-        ""
-      end
+    class BaseFlipFlop < Base
+      children :start_condition, :end_condition
 
-      # We create a function that we put in the top scope, that stores the state of our
-      # flip-flop. We pass to it functions that are ran with the current binding.
       def compile
         helper :truthy
 
-        fun_name = top_scope.new_temp
-        ff = "#{fun_name}.$$ff"
-
-        push "(typeof #{fun_name} === 'undefined' ? (#{fun_name} = function(from, to){"
-        push "  if (typeof #{ff} === 'undefined') #{ff} = false;"
-        push "  var retval = #{ff};"
-        push "  if (!#{ff}) {"
-        push "    #{ff} = retval = $truthy(from());"
-        push "  }"
-        push "  #{excl}if (#{ff}) {"
-        push "    if ($truthy(to())) #{ff} = false;"
-        push "  }"
-        push "  return retval;"
-        push "}) : #{fun_name})("
-        push "  function() { ", stmt(compiler.returns(from)), " },"
-        push "  function() { ", stmt(compiler.returns(to)), " }"
+        func_name = top_scope.new_temp
+        flip_flop_state = "#{func_name}.$$ff"
+
+        # Start function definition, checking and initializing it if necessary
+        push "(#{func_name} = #{func_name} || function(_start_func, _end_func){"
+
+        # If flip flop state is not defined, set it to false
+        push "  var flip_flop = #{flip_flop_state} || false;"
+
+        # If flip flop state is false, call the 'start_condition' function and store its truthy result into flip flop state
+        push "  if (!flip_flop) #{flip_flop_state} = flip_flop = $truthy(_start_func());"
+
+        # If flip flop state is true, call the 'end_condition' function and set flip flop state to false if 'end_condition' is truthy
+        push "  #{excl}if (flip_flop && $truthy(_end_func())) #{flip_flop_state} = false;"
+
+        # Return current state of flip flop
+        push "  return flip_flop;"
+
+        # End function definition
+        push "})("
+
+        # Call the function with 'start_condition' and 'end_condition' arguments wrapped in functions to ensure correct binding and delay evaluation
+        push "  function() { ", stmt(compiler.returns(start_condition)), " },"
+        push "  function() { ", stmt(compiler.returns(end_condition)), " }"
         push ")"
       end
     end
 
-    class EFlipFlop < IFlipFlop
+    class IFlipFlop < BaseFlipFlop
+      handle :iflipflop
+
+      # Inclusive flip flop, check 'end_condition' in the same iteration when 'start_condition' is truthy
+      def excl
+        ""
+      end
+    end
+
+    class EFlipFlop < BaseFlipFlop
       handle :eflipflop
 
-      # Is this an exclusive flip flop? If yes, run only a single branch
+      # Exclusive flip flop, check 'end_condition' in the next iteration after 'start_condition' is truthy
       def excl
         "else "
       end

data/lib/opal/nodes/literal.rb

@@ -5,14 +5,10 @@ require 'opal/nodes/base'
 module Opal
   module Nodes
     class ValueNode < Base
-      handle :true, :false, :self, :nil
+      handle :true, :false, :nil
 
       def compile
-        if type == :self
-          push scope.self
-        else
-          push type.to_s
-        end
+        push type.to_s
       end
 
       def self.truthy_optimize?
@@ -20,6 +16,14 @@ module Opal
       end
     end
 
+    class SelfNode < Base
+      handle :self
+
+      def compile
+        push scope.self
+      end
+    end
+
     class NumericNode < Base
       handle :int, :float
 
@@ -158,11 +162,15 @@ module Opal
         case value
         when ''
           push('/(?:)/')
-        when /\(\?<=|\(\?<!/
+        when /\(\?[(<>#]|[*+?]\+/
           # Safari/WebKit will not execute javascript code if it contains a lookbehind literal RegExp
           # and they fail with "Syntax Error". This tricks their parser by disguising the literal RegExp
           # as string for the dynamic $regexp helper. Safari/Webkit will still fail to execute the RegExp,
           # but at least they will parse and run everything else.
+          #
+          # Also, let's compile a couple of more patterns into $regexp calls, as there are many syntax
+          # errors in RubySpec when ran in reverse, while there shouldn't be (they should be catchable
+          # errors) - at least since Node 17.
           static_as_dynamic(value)
         else
           push "#{Regexp.new(value).inspect}#{flags.join}"

data/lib/opal/nodes/rescue.rb

@@ -211,7 +211,7 @@ module Opal
               line stmt(rescue_body)
             end
           end
-          line '} finally { Opal.pop_exception(); }'
+          line '} finally { Opal.pop_exception($err); }'
         end
         line '}'
       end

data/lib/opal/nodes/x_string.rb

@@ -6,6 +6,19 @@ module Opal
       handle :xstr
 
       def compile
+        if compiler.backtick_javascript_or_warn?
+          compile_javascript
+        else
+          compile_send
+        end
+      end
+
+      def compile_send
+        sexp = s(:send, nil, :`, s(:dstr, *children))
+        push process(sexp, @level)
+      end
+
+      def compile_javascript
         @should_add_semicolon = false
         unpacked_children = unpack_return(children)
         stripped_children = XStringNode.strip_empty_children(unpacked_children)

data/lib/opal/parser/patch.rb

@@ -1,3 +1,4 @@
+# backtick_javascript: true
 # frozen_string_literal: true
 
 if RUBY_ENGINE == 'opal'

data/lib/opal/rewriters/for_rewriter.rb

@@ -34,40 +34,52 @@ module Opal
       #   j = nil
       #   [[1, 2], [3, 4]].each { |__jstmp| i, j = __jstmp }
       #
-      def on_for(node)
-        loop_variable, iterating_value, loop_body = *node
 
-        iterating_lvars        = LocalVariableAssigns.find(loop_variable) # [:i]
-        lvars_declared_in_body = LocalVariableAssigns.find(loop_body)     # [:j]
+      def on_for(node)
+        loop_variable, loop_range, loop_body = *node
 
-        # i = nil; j = nil
-        outer_assigns = (iterating_lvars + lvars_declared_in_body).map do |lvar_name|
-          s(:lvdeclare, lvar_name)
-        end
+        # Declare local variables used in the loop and the loop body at the outer scope
+        outer_assignments = generate_outer_assignments(loop_variable, loop_body)
 
-        # :__jstmp
+        # Generate temporary loop variable
         tmp_loop_variable = self.class.next_tmp
         get_tmp_loop_variable = s(:js_tmp, tmp_loop_variable)
 
-        loop_variable_assignment = case loop_variable.type
-                                   when :mlhs # multiple left-hand statement like in "for i,j in [[1, 2], [3, 4]]"
-                                     # i, j = __jstmp
-                                     loop_variable.updated(:masgn, [loop_variable, get_tmp_loop_variable])
-                                   else # single argument like "for i in (0..3)"
-                                     # i = __jstmp
-                                     loop_variable << get_tmp_loop_variable
-                                   end
+        # Assign the loop variables in the loop body
+        loop_body = prepend_to_body(loop_body, assign_loop_variable(loop_variable, get_tmp_loop_variable))
+
+        # Transform the for-loop into each-loop with updated loop body
+        node = transform_for_to_each_loop(node, loop_range, tmp_loop_variable, loop_body)
+
+        node.updated(:begin, [*outer_assignments, node])
+      end
 
-        loop_body = prepend_to_body(loop_body, loop_variable_assignment)
+      private
 
-        node = node.updated(:send, [iterating_value, :each,                                    # (0..3).each {
-                                    node.updated(:iter, [s(:args, s(:arg, tmp_loop_variable)), #                |__jstmp|
-                                                         process(loop_body)]                   #                          i = __jstmp; j = i + 1 }
-                                    )]
-        )
+      def generate_outer_assignments(loop_variable, loop_body)
+        loop_local_vars = LocalVariableAssigns.find(loop_variable)
+        body_local_vars = LocalVariableAssigns.find(loop_body)
+
+        (loop_local_vars + body_local_vars).map { |lvar_name| s(:lvdeclare, lvar_name) }
+      end
+
+      def assign_loop_variable(loop_variable, tmp_loop_variable)
+        case loop_variable.type
+        when :mlhs # multiple left-hand statement like in "for i,j in [[1, 2], [3, 4]]"
+          loop_variable.updated(:masgn, [loop_variable, tmp_loop_variable])
+        else # single argument like "for i in (0..3)"
+          loop_variable << tmp_loop_variable
+        end
+      end
 
-        node.updated(:begin, [*outer_assigns, node])
+      # rubocop:disable Layout/MultilineMethodCallBraceLayout,Layout/MultilineArrayBraceLayout
+      def transform_for_to_each_loop(node, loop_range, tmp_loop_variable, loop_body)
+        node.updated(:send, [loop_range, :each,                                         # (0..3).each {
+                             node.updated(:iter, [s(:args, s(:arg, tmp_loop_variable)), # |__jstmp|
+                                                  process(loop_body)                    # i = __jstmp; j = i + 1 }
+                                                 ])])
       end
+      # rubocop:enable Layout/MultilineMethodCallBraceLayout,Layout/MultilineArrayBraceLayout
 
       class LocalVariableAssigns < Base
         attr_reader :result

data/lib/opal/source_map/file.rb

@@ -134,7 +134,7 @@ class Opal::SourceMap::File
         absolute_mapping.map do |absolute_segment|
           segment = []
 
-          segment[0] = absolute_segment[0] -  reference_segment[0]
+          segment[0] = absolute_segment[0] - reference_segment[0]
           segment[1] = absolute_segment[1] - (reference_segment[1] || 0)
           segment[2] = absolute_segment[2] - (reference_segment[2] || 0)
           segment[3] = absolute_segment[3] - (reference_segment[3] || 0)

data/lib/opal/version.rb

@@ -3,5 +3,5 @@
 module Opal
   # WHEN RELEASING:
   # Remember to update RUBY_ENGINE_VERSION in opal/corelib/constants.rb too!
-  VERSION = '1.7.4'
+  VERSION = '1.8.0.beta1'
 end

data/opal/corelib/array/pack.rb

@@ -1,4 +1,5 @@
 # helpers: coerce_to
+# backtick_javascript: true
 
 require 'corelib/pack_unpack/format_string_parser'
 

data/opal/corelib/array.rb

@@ -1,4 +1,5 @@
-# helpers: truthy, falsy, hash_ids, yield1, hash_get, hash_put, hash_delete, coerce_to, respond_to, deny_frozen_access, freeze
+# helpers: truthy, falsy, yield1, hash_get, hash_put, hash_delete, coerce_to, respond_to, deny_frozen_access, freeze, opal32_init, opal32_add
+# backtick_javascript: true
 
 require 'corelib/enumerable'
 require 'corelib/numeric'
@@ -68,6 +69,29 @@ class ::Array < `Array`
 
       if (raised) throw raised;
     }
+
+    function convertToArray(array) {
+      if (!array.$$is_array) {
+        array = $coerce_to(array, #{::Array}, 'to_ary');
+      }
+      return #{`array`.to_a};
+    }
+
+    function fast_push(arr, objects) {
+      // push.apply() for arrays longer than 32767 may cause various argument errors in browsers
+      // but it is significantly faster than a for loop, which pushes each element separately
+      // but apply() has a overhead by itself, for a small number of elements
+      // the for loop is significantly faster
+      // this is using the best option depending on objects.length
+      var length = objects.length;
+      if (length > 6 && length < 32767) {
+        arr.push.apply(arr, objects);
+      } else {
+        for (var i = 0; i < length; i++) {
+          arr.push(objects[i]);
+        }
+      }
+    }
   }
 
   def self.[](*objects)
@@ -91,7 +115,7 @@ class ::Array < `Array`
       }
 
       if (arguments.length === 0) {
-        self.splice(0, self.length);
+        if (self.length > 0) self.splice(0, self.length);
         return self;
       }
 
@@ -135,13 +159,13 @@ class ::Array < `Array`
   end
 
   def &(other)
-    other = if ::Array === other
-              other.to_a
-            else
-              `$coerce_to(other, #{::Array}, 'to_ary')`.to_a
-            end
-
     %x{
+      other = convertToArray(other)
+
+      if (self.length === 0 || other.length === 0) {
+        return [];
+      }
+
       var result = [], hash = #{{}}, i, length, item;
 
       for (i = 0, length = other.length; i < length; i++) {
@@ -160,11 +184,7 @@ class ::Array < `Array`
   end
 
   def |(other)
-    other = if ::Array === other
-              other.to_a
-            else
-              `$coerce_to(other, #{::Array}, 'to_ary')`.to_a
-            end
+    other = `convertToArray(other)`
 
     %x{
       var hash = #{{}}, i, length, item;
@@ -203,21 +223,13 @@ class ::Array < `Array`
   end
 
   def +(other)
-    other = if ::Array === other
-              other.to_a
-            else
-              `$coerce_to(other, #{::Array}, 'to_ary')`.to_a
-            end
+    other = `convertToArray(other)`
 
     `self.concat(other)`
   end
 
   def -(other)
-    other = if ::Array === other
-              other.to_a
-            else
-              `$coerce_to(other, #{::Array}, 'to_ary')`.to_a
-            end
+    other = `convertToArray(other)`
 
     return [] if `self.length === 0`
     return `self.slice()` if `other.length === 0`
@@ -257,7 +269,7 @@ class ::Array < `Array`
     end
 
     %x{
-      if (#{hash} === #{other.hash}) {
+      if (#{self} === #{other}) {
         return 0;
       }
 
@@ -696,11 +708,12 @@ class ::Array < `Array`
     return enum_for(:collect) { size } unless block_given?
 
     %x{
-      var result = [];
+      var length = self.length;
+      var result = new Array(length);
 
-      for (var i = 0, length = self.length; i < length; i++) {
+      for (var i = 0; i < length; i++) {
         var value = $yield1(block, self[i]);
-        result.push(value);
+        result[i] = value;
       }
 
       return result;
@@ -849,11 +862,7 @@ class ::Array < `Array`
     `$deny_frozen_access(self)`
 
     others = others.map do |other|
-      other = if ::Array === other
-                other.to_a
-              else
-                `$coerce_to(other, #{::Array}, 'to_ary')`.to_a
-              end
+      `other = convertToArray(other)`
 
       if other.equal?(self)
         other = other.dup
@@ -1223,7 +1232,7 @@ class ::Array < `Array`
             result.push(ary);
             break;
           default:
-            result.push.apply(result, _flatten(ary, level - 1));
+            fast_push(result, _flatten(ary, level - 1));
           }
         }
         return result;
@@ -1267,27 +1276,31 @@ class ::Array < `Array`
     `$freeze(self)`
   end
 
+  `var $hash_ids`
+
   def hash
     %x{
       var top = ($hash_ids === undefined),
-          result = ['A'],
+          result = $opal32_init(),
           hash_id = self.$object_id(),
           item, i, key;
 
-      try {
-        if (top) {
-          $hash_ids = Object.create(null);
-        }
+      result = $opal32_add(result, 0xA);
+      result = $opal32_add(result, self.length);
 
-        // return early for recursive structures
-        if ($hash_ids[hash_id]) {
-          return 'self';
-        }
+      if (top) {
+        $hash_ids = Object.create(null);
+      }
+      // return early for recursive structures
+      else if ($hash_ids[hash_id]) {
+        return $opal32_add(result, 0x01010101);
+      }
 
+      try {
         for (key in $hash_ids) {
           item = $hash_ids[key];
           if (#{eql?(`item`)}) {
-            return 'self';
+            return $opal32_add(result, 0x01010101);
           }
         }
 
@@ -1295,10 +1308,10 @@ class ::Array < `Array`
 
         for (i = 0; i < self.length; i++) {
           item = self[i];
-          result.push(item.$hash());
+          result = $opal32_add(result, item.$hash());
         }
 
-        return result.join(',');
+        return result;
       } finally {
         if (top) {
           $hash_ids = undefined;
@@ -1410,11 +1423,54 @@ class ::Array < `Array`
   end
 
   def intersection(*arrays)
-    arrays.reduce(to_a.dup) { |a, b| a & b }
+    %x{
+      if (arrays.length === 0) {
+        return #{to_a.dup};
+      }
+      arrays = arrays.map(convertToArray);
+      if (self.length === 0) {
+        return [];
+      }
+    }
+
+    arrays = arrays.sort_by(&:length)
+    # When self is the smallest among the arrays
+    if `self.length < arrays[0].length`
+      return arrays.reduce(self, &:&)
+    end
+
+    # First, calculate intersection of argument arrays.
+    # Array#& is faster when the argument size is small.
+    # So `largest & shortest & second_shortest & ...` would be the fastest.
+    largest = `arrays.pop()`
+    intersection_of_args = arrays.reduce(largest, &:&)
+
+    # self array must come last to maintain the order
+    self & intersection_of_args
   end
 
   def intersect?(other)
-    !intersection(other).empty?
+    %x{
+      var small, large, hash = #{{}}, i, length;
+      if (self.length < other.length) {
+        small = self;
+        large = other;
+      } else {
+        small = other;
+        large = self;
+      }
+
+      for (i = 0, length = small.length; i < length; i++) {
+        $hash_put(hash, small[i], true);
+      }
+
+      for (i = 0, length = large.length; i < length; i++) {
+        if ($hash_get(hash, large[i])) {
+          return true;
+        }
+      }
+      return false;
+    }
   end
 
   def join(sep = nil)
@@ -1705,9 +1761,7 @@ class ::Array < `Array`
     %x{
       $deny_frozen_access(self);
 
-      for (var i = 0, length = objects.length; i < length; i++) {
-        self.push(objects[i]);
-      }
+      fast_push(self, objects);
     }
 
     self
@@ -1762,15 +1816,11 @@ class ::Array < `Array`
   def replace(other)
     `$deny_frozen_access(self)`
 
-    other = if ::Array === other
-              other.to_a
-            else
-              `$coerce_to(other, #{::Array}, 'to_ary')`.to_a
-            end
+    other = `convertToArray(other)`
 
     %x{
-      self.splice(0, self.length);
-      self.push.apply(self, other);
+      if (self.length > 0) self.splice(0, self.length);
+      fast_push(self, other);
     }
 
     self
@@ -2284,10 +2334,10 @@ class ::Array < `Array`
       for (i = 0; i < len; i++) {
         ary = #{::Opal.coerce_to?(`array[i]`, ::Array, :to_ary)};
         if (!ary.$$is_array) {
-          #{::Kernel.raise ::TypeError, "wrong element type #{`ary`.class} at #{`i`} (expected array)"}
+          #{::Kernel.raise ::TypeError, "wrong element type #{`array[i]`.class} at #{`i`} (expected array)"}
         }
         if (ary.length !== 2) {
-          #{::Kernel.raise ::ArgumentError, "wrong array length at #{`i`} (expected 2, was #{`ary`.length})"}
+          #{::Kernel.raise ::ArgumentError, "element has wrong array length at #{`i`} (expected 2, was #{`ary`.length})"}
         }
         key = ary[0];
         val = ary[1];
@@ -2305,11 +2355,7 @@ class ::Array < `Array`
     max    = nil
 
     each do |row|
-      row = if ::Array === row
-              row.to_a
-            else
-              `$coerce_to(row, #{::Array}, 'to_ary')`.to_a
-            end
+      `row = convertToArray(row)`
 
       max ||= `row.length`
 

data/opal/corelib/basic_object.rb

@@ -1,4 +1,5 @@
 # use_strict: true
+# backtick_javascript: true
 
 class ::BasicObject
   def initialize(*)

data/opal/corelib/binding.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Binding
   # @private
   def initialize(jseval, scope_variables = [], receiver = undefined, source_location = nil)