opal 1.1.0.rc1 → 1.2.0.beta1

data/lib/opal/rewriters/forward_args.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'opal/rewriters/base'
+
+module Opal
+  module Rewriters
+    class ForwardArgs < Base
+      def on_forward_args(_node)
+        process(
+          s(:args, s(:forward_arg, :"$"))
+        )
+      end
+
+      def on_args(node)
+        if node.children.last && node.children.last.type == :forward_arg
+          prev_children = node.children[0..-2]
+
+          node.updated(nil,
+            [
+              *prev_children,
+              s(:restarg, '$fwd_rest'),
+              s(:blockarg, '$fwd_block')
+            ]
+          )
+        else
+          super
+        end
+      end
+
+      def on_send(node)
+        if node.children.last &&
+           node.children.last.class != Symbol &&
+           node.children.last.type == :forwarded_args
+
+          prev_children = node.children[0..-2]
+
+          node.updated(nil,
+            [
+              *prev_children,
+              s(:splat,
+                s(:lvar, '$fwd_rest')
+              ),
+              s(:block_pass,
+                s(:lvar, '$fwd_block')
+              )
+            ]
+          )
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/opal/rewriters/logical_operator_assignment.rb

@@ -20,7 +20,7 @@ module Opal
           get_node = lhs.updated(get_type)              # lhs
           condition_node = s(root_type, get_node, rhs)  # lhs || rhs
 
-          if get_type == :const && root_type == :or
+          if %i[const cvar].include?(get_type) && root_type == :or
             # defined?(lhs)
             defined_node = s(:defined?, get_node)
             # LHS = defined?(LHS) ? (LHS || rhs) : rhs
@@ -51,7 +51,10 @@ module Opal
       GlobalVariableHandler = GET_SET[:gvar, :gvasgn]
 
       # Takes    `@@lhs ||= rhs`
-      # Produces `@@lhs = @@lhs || rhs`
+      # Produces `@@lhs = defined?(@@lhs) ? (@@lhs || rhs) : rhs`
+      #
+      # Takes    `@@lhs &&= rhs`
+      # Produces `@@lhs = @@lhs && rhs`
       ClassVariableHandler = GET_SET[:cvar, :cvasgn]
 
       # Takes    `recvr.meth ||= rhs`

data/lib/opal/rewriters/opal_engine_check.rb

@@ -9,14 +9,12 @@ module Opal
         test, true_body, false_body = *node.children
 
         if skip_check_present?(test)
-          false_body = s(:nil)
+          process(true_body || s(:nil))
+        elsif skip_check_present_not?(test)
+          process(false_body || s(:nil))
+        else
+          super
         end
-
-        if skip_check_present_not?(test)
-          true_body = s(:nil)
-        end
-
-        node.updated(nil, process_all([test, true_body, false_body]))
       end
 
       def skip_check_present?(test)

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.1.0.rc1'
+  VERSION = '1.2.0.beta1'
 end

data/opal.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rack-test'
   spec.add_development_dependency 'selenium-webdriver'
-  spec.add_development_dependency 'benchmark-ips'
+  spec.add_development_dependency 'benchmark-ips', '< 2.8'
   spec.add_development_dependency 'sinatra'
   spec.add_development_dependency 'rubocop', '~> 0.67.0'
   spec.add_development_dependency 'rubocop-performance', '~> 1.1.0'

data/opal/corelib/array.rb

@@ -196,7 +196,7 @@ class Array < `Array`
         result = result.concat(converted);
       }
 
-      return toArraySubclass(result, #{self.class});
+      return result;
     }
   end
 
@@ -361,7 +361,7 @@ class Array < `Array`
       }
 
       result = self.slice(from, to);
-      return toArraySubclass(result, self.$class());
+      return result;
     }
 
     function $array_slice_index_length(self, index, length) {
@@ -394,7 +394,7 @@ class Array < `Array`
 
         result = self.slice(index, index + length);
       }
-      return toArraySubclass(result, self.$class());
+      return result;
     }
   }
 
@@ -883,7 +883,9 @@ class Array < `Array`
     self
   end
 
-  alias difference -
+  def difference(*arrays)
+    arrays.reduce(to_a.dup) { |a, b| a - b }
+  end
 
   def dig(idx, *idxs)
     item = self[idx]
@@ -1180,7 +1182,7 @@ class Array < `Array`
         level = $coerce_to(level, #{Integer}, 'to_int');
       }
 
-      return toArraySubclass(_flatten(self, level), #{self.class});
+      return _flatten(self, level);
     }
   end
 
@@ -1335,7 +1337,9 @@ class Array < `Array`
     }
   end
 
-  alias intersection &
+  def intersection(*arrays)
+    arrays.reduce(to_a.dup) { |a, b| a & b }
+  end
 
   def join(sep = nil)
     return '' if `self.length === 0`
@@ -2165,10 +2169,19 @@ class Array < `Array`
   end
 
   def to_a
-    self
+    %x{
+      if (self.$$class === Opal.Array) {
+        return self;
+      }
+      else {
+        return Opal.Array.$new(self);
+      }
+    }
   end
 
-  alias to_ary to_a
+  def to_ary
+    self
+  end
 
   def to_h(&block)
     array = self
@@ -2224,7 +2237,9 @@ class Array < `Array`
     result
   end
 
-  alias union |
+  def union(*arrays)
+    arrays.reduce(uniq) { |a, b| a | b }
+  end
 
   def uniq(&block)
     %x{
@@ -2248,7 +2263,7 @@ class Array < `Array`
         }
       }
 
-      return toArraySubclass(#{`hash`.values}, #{self.class});
+      return #{`hash`.values};
     }
   end
 
@@ -2276,12 +2291,23 @@ class Array < `Array`
 
   def unshift(*objects)
     %x{
-      for (var i = objects.length - 1; i >= 0; i--) {
-        self.unshift(objects[i]);
+      var selfLength = self.length
+      var objectsLength = objects.length
+      if (objectsLength == 0) return self;
+      var index = selfLength - objectsLength
+      for (var i = 0; i < objectsLength; i++) {
+        self.push(self[index + i])
+      }
+      var len = selfLength - 1
+      while (len - objectsLength >= 0) {
+        self[len] = self[len - objectsLength]
+        len--
+      }
+      for (var j = 0; j < objectsLength; j++) {
+        self[j] = objects[j]
       }
+      return self;
     }
-
-    self
   end
 
   alias prepend unshift
@@ -2332,12 +2358,8 @@ class Array < `Array`
         if (o.$$is_array) {
           continue;
         }
-        if (o.$$is_enumerator) {
-          if (o.$size() === Infinity) {
-            others[j] = o.$take(size);
-          } else {
-            others[j] = o.$to_a();
-          }
+        if (o.$$is_range || o.$$is_enumerator) {
+          others[j] = o.$take(size);
           continue;
         }
         others[j] = #{(

data/opal/corelib/array/pack.rb

@@ -442,7 +442,12 @@ class Array
         output = output.concat(part);
       });
 
-      return output;
+      if (format.match(/^(U\*?)+$/)) {
+        return output;
+      }
+      else {
+        return Opal.enc(output, "binary");
+      }
     }
   end
 end

data/opal/corelib/complex.rb

@@ -245,6 +245,8 @@ class Complex < Numeric
 
   alias rectangular rect
 
+  undef step
+
   def to_f
     unless @imag == 0
       raise RangeError, "can't convert #{self} into Float"

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
-RUBY_VERSION        = '3.0.0'
-RUBY_ENGINE_VERSION = '1.1.0.rc1'
-RUBY_RELEASE_DATE   = '2021-01-28'
+RUBY_VERSION        = '3.0.2'
+RUBY_ENGINE_VERSION = '1.2.0.beta1'
+RUBY_RELEASE_DATE   = '2021-07-23'
 RUBY_PATCHLEVEL     = 0
 RUBY_REVISION       = '0'
 RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2021 Adam Beynon and the Opal contributors'

data/opal/corelib/hash.rb

@@ -762,53 +762,51 @@ class Hash
 
   alias member? has_key?
 
-  def merge(other, &block)
-    dup.merge!(other, &block)
+  def merge(*others, &block)
+    dup.merge!(*others, &block)
   end
 
-  def merge!(other, &block)
+  def merge!(*others, &block)
     %x{
-      if (!other.$$is_hash) {
-        other = #{Opal.coerce_to!(other, Hash, :to_hash)};
-      }
-
-      var i, other_keys = other.$$keys, length = other_keys.length, key, value, other_value;
-
-      if (block === nil) {
-        for (i = 0; i < length; i++) {
-          key = other_keys[i];
-
-          if (key.$$is_string) {
-            other_value = other.$$smap[key];
-          } else {
-            other_value = key.value;
-            key = key.key;
+      var i, j, other, other_keys, length, key, value, other_value;
+      for (i = 0; i < others.length; ++i) {
+        other = #{Opal.coerce_to!(`others[i]`, Hash, :to_hash)};
+        other_keys = other.$$keys, length = other_keys.length;
+
+        if (block === nil) {
+          for (j = 0; j < length; j++) {
+            key = other_keys[j];
+
+            if (key.$$is_string) {
+              other_value = other.$$smap[key];
+            } else {
+              other_value = key.value;
+              key = key.key;
+            }
+
+            Opal.hash_put(self, key, other_value);
           }
+        } else {
+          for (j = 0; j < length; j++) {
+            key = other_keys[j];
 
-          Opal.hash_put(self, key, other_value);
-        }
+            if (key.$$is_string) {
+              other_value = other.$$smap[key];
+            } else {
+              other_value = key.value;
+              key = key.key;
+            }
 
-        return self;
-      }
+            value = Opal.hash_get(self, key);
 
-      for (i = 0; i < length; i++) {
-        key = other_keys[i];
+            if (value === undefined) {
+              Opal.hash_put(self, key, other_value);
+              continue;
+            }
 
-        if (key.$$is_string) {
-          other_value = other.$$smap[key];
-        } else {
-          other_value = key.value;
-          key = key.key;
-        }
-
-        value = Opal.hash_get(self, key);
-
-        if (value === undefined) {
-          Opal.hash_put(self, key, other_value);
-          continue;
+            Opal.hash_put(self, key, block(key, value, other_value));
+          }
         }
-
-        Opal.hash_put(self, key, block(key, value, other_value));
       }
 
       return self;

data/opal/corelib/module.rb

@@ -204,13 +204,8 @@ class Module
 
   def class_variable_get(name)
     name = Opal.class_variable_name!(name)
-    %x{
-      var value = Opal.class_variables(self)[name];
-      if (value == null) {
-        #{raise NameError.new("uninitialized class variable #{name} in #{self}", name)}
-      }
-      return value;
-    }
+
+    `Opal.class_variable_get(self, name, false)`
   end
 
   def class_variable_set(name, value)

data/opal/corelib/number.rb

@@ -379,7 +379,7 @@ class Number < Numeric
   end
 
   def chr(encoding = undefined)
-    `String.fromCharCode(self)`
+    `Opal.enc(String.fromCharCode(self), encoding || "BINARY")`
   end
 
   def denominator
@@ -668,184 +668,6 @@ class Number < Numeric
     end
   end
 
-  def step(limit = undefined, step = undefined, to: undefined, by: undefined, &block)
-    %x{
-      if (limit !== undefined && to !== undefined) {
-        #{raise ArgumentError, 'to is given twice'}
-      }
-
-      if (step !== undefined && by !== undefined) {
-        #{raise ArgumentError, 'step is given twice'}
-      }
-
-      function validateParameters() {
-        if (to !== undefined) {
-          limit = to;
-        }
-
-        if (limit === undefined) {
-          limit = nil;
-        }
-
-        if (step === nil) {
-          #{raise TypeError, 'step must be numeric'}
-        }
-
-        if (step === 0) {
-          #{raise ArgumentError, "step can't be 0"}
-        }
-
-        if (by !== undefined) {
-          step = by;
-        }
-
-        if (step === nil || step == null) {
-          step = 1;
-        }
-
-        var sign = #{step <=> 0};
-
-        if (sign === nil) {
-          #{raise ArgumentError, "0 can't be coerced into #{step.class}"}
-        }
-
-        if (limit === nil || limit == null) {
-          limit = sign > 0 ? #{Float::INFINITY} : #{-Float::INFINITY};
-        }
-
-        #{Opal.compare(self, limit)}
-      }
-
-      function stepFloatSize() {
-        if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
-          return 0;
-        } else if (step === Infinity || step === -Infinity) {
-          return 1;
-        } else {
-          var abs = Math.abs, floor = Math.floor,
-              err = (abs(self) + abs(limit) + abs(limit - self)) / abs(step) * #{Float::EPSILON};
-
-          if (err === Infinity || err === -Infinity) {
-            return 0;
-          } else {
-            if (err > 0.5) {
-              err = 0.5;
-            }
-
-            return floor((limit - self) / step + err) + 1
-          }
-        }
-      }
-
-      function stepSize() {
-        validateParameters();
-
-        if (step === 0) {
-          return Infinity;
-        }
-
-        if (step % 1 !== 0) {
-          return stepFloatSize();
-        } else if ((step > 0 && self > limit) || (step < 0 && self < limit)) {
-          return 0;
-        } else {
-          var ceil = Math.ceil, abs = Math.abs,
-              lhs = abs(self - limit) + 1,
-              rhs = abs(step);
-
-          return ceil(lhs / rhs);
-        }
-      }
-    }
-
-    unless block_given?
-      positional_args = []
-      keyword_args = {}
-
-      %x{
-        if (limit !== undefined) {
-          positional_args.push(limit);
-        }
-
-        if (step !== undefined) {
-          positional_args.push(step);
-        }
-
-        if (to !== undefined) {
-          Opal.hash_put(keyword_args, "to", to);
-        }
-
-        if (by !== undefined) {
-          Opal.hash_put(keyword_args, "by", by);
-        }
-
-        if (#{keyword_args.any?}) {
-          positional_args.push(keyword_args);
-        }
-      }
-
-      return enum_for(:step, *positional_args) { `stepSize()` }
-    end
-
-    %x{
-      validateParameters();
-
-      if (step === 0) {
-        while (true) {
-          block(self);
-        }
-      }
-
-      if (self % 1 !== 0 || limit % 1 !== 0 || step % 1 !== 0) {
-        var n = stepFloatSize();
-
-        if (n > 0) {
-          if (step === Infinity || step === -Infinity) {
-            block(self);
-          } else {
-            var i = 0, d;
-
-            if (step > 0) {
-              while (i < n) {
-                d = i * step + self;
-                if (limit < d) {
-                  d = limit;
-                }
-                block(d);
-                i += 1;
-              }
-            } else {
-              while (i < n) {
-                d = i * step + self;
-                if (limit > d) {
-                  d = limit;
-                }
-                block(d);
-                i += 1
-              }
-            }
-          }
-        }
-      } else {
-        var value = self;
-
-        if (step > 0) {
-          while (value <= limit) {
-            block(value);
-            value += step;
-          }
-        } else {
-          while (value >= limit) {
-            block(value);
-            value += step
-          }
-        }
-      }
-
-      return self;
-    }
-  end
-
   alias succ next
 
   def times(&block)
@@ -865,7 +687,7 @@ class Number < Numeric
   end
 
   def to_i
-    `parseInt(self, 10)`
+    `self < 0 ? Math.ceil(self) : Math.floor(self)`
   end
 
   alias to_int to_i