opal 1.7.2 → 1.8.0.alpha1

data/lib/opal/nodes/if.rb

@@ -349,7 +349,7 @@ module Opal
           @switch_additional_rules = sexp.meta[:switch_additional_rules]
           compile_switch_case(sexp.meta[:switch_test])
         else
-          line "switch (", expr(@switch_first_test), ") {"
+          line "switch (", expr(@switch_first_test), ".valueOf()) {"
           indent do
             compile_switch_case(@switch_test)
           end
@@ -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

@@ -158,11 +158,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/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'
@@ -13,6 +14,12 @@ if RUBY_ENGINE == 'opal'
       else
         @source_pts = nil
       end
+
+      # Since parser v3.2.1 Parser::Lexer has @strings
+      if @strings
+        @strings.source_buffer = @source_buffer
+        @strings.source_pts = @source_pts
+      end
     end
   end
 

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.2'
+  VERSION = '1.8.0.alpha1'
 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
+# backtick_javascript: true
 
 require 'corelib/enumerable'
 require 'corelib/numeric'
@@ -68,6 +69,13 @@ 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};
+    }
   }
 
   def self.[](*objects)
@@ -135,13 +143,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 +168,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 +207,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`
@@ -696,11 +692,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 +846,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
@@ -1410,11 +1403,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)
@@ -1762,11 +1798,7 @@ 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);
@@ -1927,9 +1959,9 @@ class ::Array < `Array`
           break;
         case 2:
           i = #{rng.rand(`self.length`)};
-          j = #{rng.rand(`self.length`)};
-          if (i === j) {
-            j = i === 0 ? i + 1 : i - 1;
+          j = #{rng.rand(`self.length - 1`)};
+          if (i <= j) {
+            j++;
           }
           return [self[i], self[j]];
           break;
@@ -1981,7 +2013,7 @@ class ::Array < `Array`
           result = self.slice();
 
           for (var c = 0; c < count; c++) {
-            targetIndex = #{rng.rand(`self.length`)};
+            targetIndex = #{rng.rand(`self.length - c`)} + c;
             oldValue = result[c];
             result[c] = result[targetIndex];
             result[targetIndex] = oldValue;
@@ -2284,10 +2316,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 +2337,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)

data/opal/corelib/boolean.rb

@@ -1,4 +1,5 @@
 # use_strict: true
+# backtick_javascript: true
 
 class ::Boolean < `Boolean`
   `Opal.prop(self.$$prototype, '$$is_boolean', true)`

data/opal/corelib/class.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/module'
 
 class ::Class

data/opal/corelib/comparable.rb

@@ -1,4 +1,5 @@
 # helpers: truthy
+# backtick_javascript: true
 
 module ::Comparable
   %x{

data/opal/corelib/complex.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 require 'corelib/numeric'
 require 'corelib/complex/base'
 

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 ::RUBY_PLATFORM       = 'opal'
 ::RUBY_ENGINE         = 'opal'
 ::RUBY_VERSION        = '3.2.0'
-::RUBY_ENGINE_VERSION = '1.7.2'
-::RUBY_RELEASE_DATE   = '2023-01-20'
+::RUBY_ENGINE_VERSION = '1.8.0.alpha1'
+::RUBY_RELEASE_DATE   = '2023-08-04'
 ::RUBY_PATCHLEVEL     = 0
 ::RUBY_REVISION       = '0'
 ::RUBY_COPYRIGHT      = 'opal - Copyright (C) 2011-2023 Adam Beynon and the Opal contributors'

data/opal/corelib/dir.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Dir
   class << self
     def chdir(dir)

data/opal/corelib/enumerable.rb

@@ -1,4 +1,5 @@
 # helpers: truthy, coerce_to, yield1, yieldX, deny_frozen_access
+# backtick_javascript: true
 
 module ::Enumerable
   %x{
@@ -1251,10 +1252,10 @@ module ::Enumerable
         var param = #{::Opal.destructure(`arguments`)};
         var ary = #{::Opal.coerce_to?(`param`, ::Array, :to_ary)}, key, val;
         if (!ary.$$is_array) {
-          #{::Kernel.raise ::TypeError, "wrong element type #{`ary`.class} (expected array)"}
+          #{::Kernel.raise ::TypeError, "wrong element type #{`param`.class} (expected array)"}
         }
         if (ary.length !== 2) {
-          #{::Kernel.raise ::ArgumentError, "wrong array length (expected 2, was #{`ary`.length})"}
+          #{::Kernel.raise ::ArgumentError, "element has wrong array length (expected 2, was #{`ary`.length})"}
         }
         key = ary[0];
         val = ary[1];

data/opal/corelib/enumerator/arithmetic_sequence.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Enumerator
   class self::ArithmeticSequence < self
     `Opal.prop(self.$$prototype, '$$is_arithmetic_seq', true)`

data/opal/corelib/enumerator/chain.rb

@@ -1,4 +1,5 @@
 # helpers: deny_frozen_access
+# backtick_javascript: true
 
 class ::Enumerator
   class self::Chain < self

data/opal/corelib/enumerator/generator.rb

@@ -1,4 +1,5 @@
 # helpers: deny_frozen_access
+# backtick_javascript: true
 
 class Enumerator
   class Generator

data/opal/corelib/enumerator/lazy.rb

@@ -1,4 +1,5 @@
 # helpers: truthy, coerce_to, yield1, yieldX, deny_frozen_access
+# backtick_javascript: true
 
 class ::Enumerator
   class self::Lazy < self

data/opal/corelib/enumerator/yielder.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class Enumerator
   class Yielder
     def initialize(&block)

data/opal/corelib/enumerator.rb

@@ -1,4 +1,5 @@
 # helpers: slice, coerce_to, deny_frozen_access
+# backtick_javascript: true
 
 require 'corelib/enumerable'
 

data/opal/corelib/error/errno.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 module ::Errno
   errors = [
     [:EINVAL, 'Invalid argument', 22],

data/opal/corelib/error.rb

@@ -1,3 +1,5 @@
+# backtick_javascript: true
+
 class ::Exception < `Error`
   `Opal.prop(self.$$prototype, '$$is_exception', true)`
   `var stack_trace_limit`
@@ -36,6 +38,16 @@ class ::Exception < `Error`
     `self.message = (args.length > 0) ? args[0] : nil`
   end
 
+  # Those instance variables are not enumerable.
+  def copy_instance_variables(other)
+    super
+    %x{
+      self.message = other.message;
+      self.cause = other.cause;
+      self.stack = other.stack;
+    }
+  end
+
   %x{
     // Convert backtrace from any format to Ruby format
     function correct_backtrace(backtrace) {

data/opal/corelib/file.rb

@@ -1,4 +1,5 @@
 # helpers: truthy
+# backtick_javascript: true
 
 class ::File < ::IO
   Separator = SEPARATOR = '/'