opal 1.8.0.alpha1 → 1.8.0

data/opal/corelib/constants.rb

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

data/opal/corelib/enumerator/arithmetic_sequence.rb

@@ -153,7 +153,7 @@ class ::Enumerator
     end
 
     def hash
-      [self.begin, self.end, step, exclude_end?].hash
+      [ArithmeticSequence, self.begin, self.end, step, exclude_end?].hash
     end
 
     def inspect

data/opal/corelib/error.rb

@@ -316,6 +316,16 @@ class ::KeyError
   end
 end
 
+class ::LocalJumpError
+  attr_reader :exit_value, :reason
+
+  def initialize(message, exit_value = nil, reason = :noreason)
+    super message
+    @exit_value = exit_value
+    @reason = reason
+  end
+end
+
 module ::JS
   class Error
   end

data/opal/corelib/hash.rb

@@ -1,4 +1,4 @@
-# helpers: yield1, hash_clone, hash_delete, hash_each, hash_get, hash_put, deny_frozen_access, freeze
+# helpers: yield1, hash_clone, hash_delete, hash_each, hash_get, hash_put, deny_frozen_access, freeze, opal32_init, opal32_add
 # backtick_javascript: true
 
 require 'corelib/enumerable'
@@ -210,7 +210,8 @@ class ::Hash < `Map`
   def clone
     %x{
       var hash = self.$class().$new();
-      return $hash_clone(self, hash);
+      $hash_clone(self, hash);
+      return self["$frozen?"]() ? hash.$freeze() : hash;
     }
   end
 
@@ -365,6 +366,10 @@ class ::Hash < `Map`
     item.dig(*keys)
   end
 
+  def dup
+    `$hash_clone(self, self.$class().$new())`
+  end
+
   def each(&block)
     return enum_for(:each) { size } unless block
 
@@ -481,41 +486,53 @@ class ::Hash < `Map`
     }
   end
 
+  `var $hash_ids`
+
   def hash
     %x{
-      var top = (Opal.hash_ids === undefined),
+      var top = ($hash_ids === undefined),
           hash_id = self.$object_id(),
-          result = ['Hash'],
-          key, item;
+          result = $opal32_init(),
+          key, item, i,
+          size = self.size, ary = new Int32Array(size);
 
-      try {
-        if (top) {
-          Opal.hash_ids = Object.create(null);
-        }
+      result = $opal32_add(result, 0x4);
+      result = $opal32_add(result, size);
 
-        if (Opal[hash_id]) {
-          return 'self';
-        }
+      if (top) {
+        $hash_ids = Object.create(null);
+      }
+      else if ($hash_ids[hash_id]) {
+        return $opal32_add(result, 0x01010101);
+      }
 
-        for (key in Opal.hash_ids) {
-          item = Opal.hash_ids[key];
+      try {
+        for (key in $hash_ids) {
+          item = $hash_ids[key];
           if (#{eql?(`item`)}) {
-            return 'self';
+            return $opal32_add(result, 0x01010101);
           }
         }
 
-        Opal.hash_ids[hash_id] = self;
+        $hash_ids[hash_id] = self;
+        i = 0
 
         $hash_each(self, false, function(key, value) {
-          result.push([key, value.$hash()]);
+          ary[i] = [0x70414952, key, value].$hash();
+          i++;
           return [false, false];
         });
 
-        return result.sort().join();
+        ary = ary.sort();
+
+        for (i = 0; i < ary.length; i++) {
+          result = $opal32_add(result, ary[i]);
+        }
 
+        return result;
       } finally {
         if (top) {
-          Opal.hash_ids = undefined;
+          $hash_ids = undefined;
         }
       }
     }
@@ -920,7 +937,6 @@ class ::Hash < `Map`
     `Array.from(self.values())`
   end
 
-  alias dup clone
   alias each_pair each
   alias eql? ==
   alias filter select

data/opal/corelib/kernel.rb

@@ -687,7 +687,6 @@ module ::Kernel
       }
 
       #{$!} = exception;
-      #{$@} = #{`exception`.backtrace};
 
       throw exception;
     }

data/opal/corelib/method.rb

@@ -77,6 +77,7 @@ class ::UnboundMethod
     @owner  = owner
     @method = method
     @name   = name
+    `self.$$method = method`
   end
 
   def arity

data/opal/corelib/module.rb

@@ -2,6 +2,22 @@
 # backtick_javascript: true
 
 class ::Module
+  %x{
+    function ensure_symbol_or_string(name) {
+      if (name.$$is_string) {
+        return name;
+      };
+      var converted_name = #{::Opal.try_convert(`name`, ::String, :to_str)};
+      if (converted_name.$$is_string) {
+        return converted_name;
+      } else if (converted_name === nil) {
+        #{::Kernel.raise ::TypeError, "#{`name`} is not a symbol nor a string"}
+      } else {
+        #{::Kernel.raise ::TypeError, "can't convert #{`name`.class} to String (#{`name`.class}#to_str gives #{`converted_name`.class}"}
+      }
+    }
+  }
+
   def self.allocate
     %x{
       var module = Opal.allocate_module(nil, function(){});
@@ -388,9 +404,12 @@ class ::Module
 
       if (method === undefined && block === nil)
         #{::Kernel.raise ::ArgumentError, 'tried to create a Proc object without a block'}
+
+      name = ensure_symbol_or_string(name);
     }
 
-    block ||= case method
+    if `method !== undefined`
+      block = case method
               when ::Proc
                 method
 
@@ -398,15 +417,21 @@ class ::Module
                 `#{method.to_proc}.$$unbound`
 
               when ::UnboundMethod
-                ->(*args) {
-                  bound = method.bind(self)
-                  bound.call(*args)
-                }
+                `Opal.wrap_method_body(method.$$method)`
 
               else
-                ::Kernel.raise ::TypeError, "wrong argument type #{block.class} (expected Proc/Method)"
+                ::Kernel.raise ::TypeError, "wrong argument type #{method.class} (expected Proc/Method/UnboundMethod)"
               end
 
+      if `!method.$$is_proc`
+        owner = method.owner
+        if `owner.$$is_class` && !(self <= owner) # rubocop:disable Style/InverseMethods
+          message = `owner.$$is_singleton` ? "can't bind singleton method to a different class" : "bind argument must be a subclass of #{owner}"
+          ::Kernel.raise ::TypeError, message
+        end
+      end
+    end
+
     %x{
       if (typeof(Proxy) !== 'undefined') {
         var meta = Object.create(null)
@@ -414,15 +439,17 @@ class ::Module
         block.$$proxy_target = block
         block = new Proxy(block, {
           apply: function(target, self, args) {
-            var old_name = target.$$jsid
+            var old_name = target.$$jsid, old_lambda = target.$$is_lambda;
             target.$$jsid = name;
+            target.$$is_lambda = true;
             try {
               return target.apply(self, args);
             } catch(e) {
               if (e === target.$$brk || e === target.$$ret) return e.$v;
               throw e;
             } finally {
-              target.$$jsid = old_name
+              target.$$jsid = old_name;
+              target.$$is_lambda = old_lambda;
             }
           }
         })
@@ -453,10 +480,7 @@ class ::Module
   def remove_method(*names)
     %x{
       for (var i = 0; i < names.length; i++) {
-        var name = names[i];
-        if (!(typeof name === "string" || name.$$is_string)) {
-          #{raise ::TypeError, "#{name} is not a symbol nor a string"}
-        }
+        var name = ensure_symbol_or_string(names[i]);
         $deny_frozen_access(self);
 
         Opal.rdef(self, "$" + name);
@@ -705,13 +729,10 @@ class ::Module
   def undef_method(*names)
     %x{
       for (var i = 0; i < names.length; i++) {
-        var name = names[i];
-        if (!(typeof name === "string" || name.$$is_string)) {
-          #{raise ::TypeError, "#{name} is not a symbol nor a string"}
-        }
+        var name = ensure_symbol_or_string(names[i]);
         $deny_frozen_access(self);
 
-        Opal.udef(self, "$" + names[i]);
+        Opal.udef(self, "$" + name);
       }
     }
 
@@ -733,11 +754,50 @@ class ::Module
     }
   end
 
-  def dup
-    copy = super
-    copy.copy_class_variables(self)
-    copy.copy_constants(self)
-    copy
+  %x{
+    function copyInstanceMethods(from, to) {
+      var i, method_names = Opal.own_instance_methods(from);
+      for (i = 0; i < method_names.length; i++) {
+        var name = method_names[i],
+            jsid = $jsid(name),
+            body = from.$$prototype[jsid],
+            wrapped = Opal.wrap_method_body(body);
+
+        wrapped.$$jsid = name;
+        Opal.defn(to, jsid, wrapped);
+      }
+    }
+
+    function copyIncludedModules(from, to) {
+      var modules = from.$$own_included_modules;
+      for (var i = modules.length - 1; i >= 0; i--) {
+        Opal.append_features(modules[i], to);
+      }
+    }
+
+    function copyPrependedModules(from, to) {
+      var modules = from.$$own_prepended_modules;
+      for (var i = modules.length - 1; i >= 0; i--) {
+        Opal.prepend_features(modules[i], to);
+      }
+    }
+  }
+
+  def initialize_copy(other)
+    %x{
+      copyInstanceMethods(other, self);
+      copyIncludedModules(other, self);
+      copyPrependedModules(other, self);
+      self.$$cloned_from = other.$$cloned_from.concat(other);
+    }
+    copy_class_variables(other)
+    copy_constants(other)
+  end
+
+  def initialize_dup(other)
+    super
+    # Unlike other classes, Module's singleton methods are copied on Object#dup.
+    copy_singleton_methods(other)
   end
 
   def copy_class_variables(other)

data/opal/corelib/number.rb

@@ -1,4 +1,5 @@
 # backtick_javascript: true
+# use_strict: true
 
 require 'corelib/numeric'
 
@@ -6,6 +7,7 @@ class ::Number < ::Numeric
   ::Opal.bridge(`Number`, self)
   `Opal.prop(self.$$prototype, '$$is_number', true)`
   `self.$$is_number_class = true`
+  `var number_id_map = new Map()`
 
   class << self
     def allocate
@@ -36,7 +38,32 @@ class ::Number < ::Numeric
   end
 
   def __id__
-    `(self * 2) + 1`
+    %x{
+      // Binary-safe integers
+      if (self|0 === self) {
+        return (self * 2) + 1;
+      }
+      else {
+        if (number_id_map.has(self)) {
+          return number_id_map.get(self);
+        }
+        var id = Opal.uid();
+        number_id_map.set(self, id);
+        return id;
+      }
+    }
+  end
+
+  def hash
+    %x{
+      // Binary-safe integers
+      if (self|0 === self) {
+        return #{__id__}
+      }
+      else {
+        return self.toString().$hash();
+      }
+    }
   end
 
   def +(other)

data/opal/corelib/range.rb

@@ -19,7 +19,8 @@ class ::Range
   end
 
   def ===(value)
-    include? value
+    return false if `value.$$is_range`
+    cover? value
   end
 
   %x{
@@ -44,13 +45,34 @@ class ::Range
   end
 
   def cover?(value)
-    beg_cmp = (@begin.nil? && -1) || (@begin <=> value) || false
-    end_cmp = (@end.nil? && -1) || (value <=> @end) || false
-    if @excl
-      end_cmp && end_cmp < 0
-    else
-      end_cmp && end_cmp <= 0
-    end && beg_cmp && beg_cmp <= 0
+    compare = ->(a, b) {
+      a <=> b || 1
+    }
+
+    if `value.$$is_range`
+      val_begin = value.begin
+      val_end = value.end
+      val_excl = value.exclude_end?
+      if (@begin && val_begin.nil?) ||
+         (@end && val_end.nil?) ||
+         (val_begin && val_end && compare.call(val_begin, val_end).then { |c| val_excl ? c >= 0 : c > 0 }) ||
+         (val_begin && !cover?(val_begin))
+        return false
+      end
+
+      cmp = compare.call(@end, val_end)
+      return cmp >= 0 if @excl == val_excl
+      return cmp > 0 if @excl
+      return true if cmp >= 0
+
+      val_max = value.max
+      return !val_max.nil? && compare.call(val_max, @end) <= 0
+    end
+
+    return false if @begin && compare.call(@begin, value) > 0
+    return true if @end.nil?
+    end_cmp = compare.call(value, @end)
+    @excl ? end_cmp < 0 : end_cmp <= 0
   end
 
   def each(&block)
@@ -113,6 +135,29 @@ class ::Range
     super
   end
 
+  def include?(val)
+    if `self.begin.$$is_number || self.end.$$is_number` ||
+       @begin.is_a?(::Time) || @end.is_a?(::Time) ||
+       ::Integer.try_convert(@begin) || ::Integer.try_convert(@end)
+      return cover?(val)
+    end
+
+    if `self.begin.$$is_string || self.end.$$is_string`
+      if `self.begin.$$is_string && self.end.$$is_string`
+        return @begin.upto(@end, @excl).any? { |s| s == val }
+      elsif @begin.nil?
+        cmp = val <=> @end
+        return !cmp.nil? && (@excl ? cmp < 0 : cmp <= 0)
+      elsif @end.nil?
+        cmp = @begin <=> val
+        return !cmp.nil? && cmp <= 0
+      end
+    end
+
+    # invoke Enumerable#include?
+    super
+  end
+
   def last(n = undefined)
     ::Kernel.raise ::RangeError, 'cannot get the maximum of endless range' if @end.nil?
     return @end if `n == null`
@@ -315,10 +360,9 @@ class ::Range
   end
 
   def hash
-    [@begin, @end, @excl].hash
+    [::Range, @begin, @end, @excl].hash
   end
 
   alias == eql?
-  alias include? cover?
-  alias member? cover?
+  alias member? include?
 end

data/opal/corelib/rational.rb

@@ -244,7 +244,7 @@ class ::Rational < ::Numeric
   end
 
   def hash
-    "Rational:#{@num}:#{@den}"
+    [::Rational, @num, @den].hash
   end
 
   def inspect