opal 1.5.0 → 1.6.0.alpha1

data/opal/corelib/array.rb

@@ -1,4 +1,4 @@
-# helpers: truthy, falsy, hash_ids, yield1, hash_get, hash_put, hash_delete, coerce_to, respond_to
+# helpers: truthy, falsy, hash_ids, yield1, hash_get, hash_put, hash_delete, coerce_to, respond_to, deny_frozen_access, freeze
 
 require 'corelib/enumerable'
 require 'corelib/numeric'
@@ -76,6 +76,8 @@ class ::Array < `Array`
 
   def initialize(size = nil, obj = nil, &block)
     %x{
+      $deny_frozen_access(self);
+
       if (obj !== nil && block !== nil) {
         #{::Kernel.warn('warning: block supersedes default value argument')}
       }
@@ -239,6 +241,7 @@ class ::Array < `Array`
   end
 
   def <<(object)
+    `$deny_frozen_access(self)`
     `self.push(object)`
 
     self
@@ -441,6 +444,8 @@ class ::Array < `Array`
   end
 
   def []=(index, value, extra = undefined)
+    `$deny_frozen_access(self)`
+
     data = nil
     %x{
       var i, size = self.length;
@@ -668,6 +673,8 @@ class ::Array < `Array`
   end
 
   def clear
+    `$deny_frozen_access(self)`
+
     `self.splice(0, self.length)`
 
     self
@@ -704,6 +711,8 @@ class ::Array < `Array`
     return enum_for(:collect!) { size } unless block_given?
 
     %x{
+      $deny_frozen_access(self);
+
       for (var i = 0, length = self.length; i < length; i++) {
         var value = $yield1(block, self[i]);
         self[i] = value;
@@ -819,6 +828,8 @@ class ::Array < `Array`
 
   def compact!
     %x{
+      $deny_frozen_access(self);
+
       var original = self.length;
 
       for (var i = 0, length = self.length; i < length; i++) {
@@ -835,6 +846,8 @@ class ::Array < `Array`
   end
 
   def concat(*others)
+    `$deny_frozen_access(self)`
+
     others = others.map do |other|
       other = if ::Array === other
                 other.to_a
@@ -866,6 +879,8 @@ class ::Array < `Array`
 
       for (var i = 0, length = original; i < length; i++) {
         if (#{`self[i]` == object}) {
+          $deny_frozen_access(self);
+
           self.splice(i, 1);
 
           length--;
@@ -885,6 +900,8 @@ class ::Array < `Array`
 
   def delete_at(index)
     %x{
+      $deny_frozen_access(self);
+
       index = $coerce_to(index, #{::Integer}, 'to_int');
 
       if (index < 0) {
@@ -905,7 +922,11 @@ class ::Array < `Array`
 
   def delete_if(&block)
     return enum_for(:delete_if) { size } unless block_given?
-    %x{filterIf(self, $falsy, block)}
+    %x{
+      $deny_frozen_access(self);
+
+      filterIf(self, $falsy, block)
+    }
     self
   end
 
@@ -1064,6 +1085,8 @@ class ::Array < `Array`
 
   def fill(*args, &block)
     %x{
+      $deny_frozen_access(self);
+
       var i, length, value;
     }
 
@@ -1216,6 +1239,8 @@ class ::Array < `Array`
 
   def flatten!(level = undefined)
     %x{
+      $deny_frozen_access(self);
+
       var flattened = #{flatten level};
 
       if (self.length == flattened.length) {
@@ -1236,6 +1261,12 @@ class ::Array < `Array`
     self
   end
 
+  def freeze
+    return self if frozen?
+
+    `$freeze(self)`
+  end
+
   def hash
     %x{
       var top = ($hash_ids === undefined),
@@ -1322,6 +1353,8 @@ class ::Array < `Array`
 
   def insert(index, *objects)
     %x{
+      $deny_frozen_access(self);
+
       index = $coerce_to(index, #{::Integer}, 'to_int');
 
       if (objects.length > 0) {
@@ -1446,7 +1479,11 @@ class ::Array < `Array`
 
   def keep_if(&block)
     return enum_for(:keep_if) { size } unless block_given?
-    %x{filterIf(self, $truthy, block)}
+    %x{
+      $deny_frozen_access(self);
+
+      filterIf(self, $truthy, block)
+    }
     self
   end
 
@@ -1590,6 +1627,8 @@ class ::Array < `Array`
   end
 
   def pop(count = undefined)
+    `$deny_frozen_access(self)`
+
     if `count === undefined`
       return if `self.length === 0`
       return `self.pop()`
@@ -1664,6 +1703,8 @@ class ::Array < `Array`
 
   def push(*objects)
     %x{
+      $deny_frozen_access(self);
+
       for (var i = 0, length = objects.length; i < length; i++) {
         self.push(objects[i]);
       }
@@ -1708,6 +1749,8 @@ class ::Array < `Array`
   def reject!(&block)
     return enum_for(:reject!) { size } unless block_given?
 
+    `$deny_frozen_access(self)`
+
     original = length
     delete_if(&block)
 
@@ -1717,6 +1760,8 @@ class ::Array < `Array`
   end
 
   def replace(other)
+    `$deny_frozen_access(self)`
+
     other = if ::Array === other
               other.to_a
             else
@@ -1736,6 +1781,8 @@ class ::Array < `Array`
   end
 
   def reverse!
+    `$deny_frozen_access(self)`
+
     `self.reverse()`
   end
 
@@ -1809,6 +1856,8 @@ class ::Array < `Array`
 
   def rotate!(cnt = 1)
     %x{
+      $deny_frozen_access(self);
+
       if (self.length === 0 || self.length === 1) {
         return self;
       }
@@ -1967,6 +2016,8 @@ class ::Array < `Array`
     return enum_for(:select!) { size } unless block_given?
 
     %x{
+      $deny_frozen_access(self)
+
       var original = self.length;
       #{ keep_if(&block) };
       return self.length === original ? nil : self;
@@ -1974,6 +2025,8 @@ class ::Array < `Array`
   end
 
   def shift(count = undefined)
+    `$deny_frozen_access(self)`
+
     if `count === undefined`
       return if `self.length === 0`
       return `shiftNoArg(self)`
@@ -1996,6 +2049,8 @@ class ::Array < `Array`
 
   def shuffle!(rng = undefined)
     %x{
+      $deny_frozen_access(self);
+
       var randgen, i = self.length, j, tmp;
 
       if (rng !== undefined) {
@@ -2036,6 +2091,8 @@ class ::Array < `Array`
   end
 
   def slice!(index, length = undefined)
+    `$deny_frozen_access(self)`
+
     result = nil
 
     if `length === undefined`
@@ -2144,6 +2201,8 @@ class ::Array < `Array`
 
   def sort!(&block)
     %x{
+      $deny_frozen_access(self)
+
       var result;
 
       if (#{block_given?}) {
@@ -2165,6 +2224,8 @@ class ::Array < `Array`
   def sort_by!(&block)
     return enum_for(:sort_by!) { size } unless block_given?
 
+    `$deny_frozen_access(self)`
+
     replace sort_by(&block)
   end
 
@@ -2297,6 +2358,8 @@ class ::Array < `Array`
 
   def uniq!(&block)
     %x{
+      $deny_frozen_access(self);
+
       var original_length = self.length, hash = #{{}}, i, length, item, key;
 
       for (i = 0, length = original_length; i < length; i++) {
@@ -2319,6 +2382,8 @@ class ::Array < `Array`
 
   def unshift(*objects)
     %x{
+      $deny_frozen_access(self);
+
       var selfLength = self.length
       var objectsLength = objects.length
       if (objectsLength == 0) return self;

data/opal/corelib/basic_object.rb

@@ -51,6 +51,7 @@ class ::BasicObject
   def !
     false
   end
+  ::Opal.pristine :!
 
   def !=(other)
     !(self == other)

data/opal/corelib/comparable.rb

@@ -40,7 +40,7 @@ module ::Comparable
 
       // check for infinite recursion
       if (self.$$comparable) {
-        delete self.$$comparable;
+        self.$$comparable = false;
         return false;
       }
     }

data/opal/corelib/complex.rb

@@ -23,6 +23,7 @@ class ::Complex < ::Numeric
   def initialize(real, imag = 0)
     @real = real
     @imag = imag
+    freeze
   end
 
   def coerce(other)

data/opal/corelib/constants.rb

@@ -1,8 +1,8 @@
 ::RUBY_PLATFORM       = 'opal'
 ::RUBY_ENGINE         = 'opal'
 ::RUBY_VERSION        = '3.1.0'
-::RUBY_ENGINE_VERSION = '1.5.0'
-::RUBY_RELEASE_DATE   = '2022-04-13'
+::RUBY_ENGINE_VERSION = '1.6.0.alpha1'
+::RUBY_RELEASE_DATE   = '2022-11-11'
 ::RUBY_PATCHLEVEL     = 0
 ::RUBY_REVISION       = '0'
 ::RUBY_COPYRIGHT      = 'opal - Copyright (C) 2013-2022 Adam Beynon and the Opal contributors'

data/opal/corelib/enumerable.rb

@@ -1,4 +1,4 @@
-# helpers: truthy, coerce_to, yield1, yieldX
+# helpers: truthy, coerce_to, yield1, yieldX, deny_frozen_access
 
 module ::Enumerable
   %x{
@@ -128,7 +128,7 @@ module ::Enumerable
 
   def collect_concat(&block)
     return enum_for(:collect_concat) { enumerator_size } unless block_given?
-    map { |item| yield item }.flatten(1)
+    map(&block).flatten(1)
   end
 
   def compact
@@ -1230,6 +1230,8 @@ module ::Enumerable
   end
 
   def tally(hash = undefined)
+    `if (hash && hash !== nil) { $deny_frozen_access(hash); }`
+
     out = group_by(&:itself).transform_values(&:count)
     if hash
       out.each { |k, v| hash[k] = hash.fetch(k, 0) + v }

data/opal/corelib/enumerator/chain.rb

@@ -1,6 +1,10 @@
+# helpers: deny_frozen_access
+
 class ::Enumerator
   class self::Chain < self
     def initialize(*enums)
+      `$deny_frozen_access(self)`
+
       @enums = enums
       @iterated = []
       @object = self

data/opal/corelib/enumerator/generator.rb

@@ -1,10 +1,12 @@
-# helpers: breaker
+# helpers: deny_frozen_access
 
 class Enumerator
   class Generator
     include ::Enumerable
 
     def initialize(&block)
+      `$deny_frozen_access(self)`
+
       ::Kernel.raise ::LocalJumpError, 'no block given' unless block
 
       @block = block
@@ -20,8 +22,8 @@ class Enumerator
           Opal.yieldX(#{@block}, args);
         }
         catch (e) {
-          if (e === $breaker) {
-            return $breaker.$v;
+          if (e && e.$thrower_type == "breaker") {
+            return e.$v;
           }
           else {
             throw e;

data/opal/corelib/enumerator/lazy.rb

@@ -1,4 +1,4 @@
-# helpers: truthy, coerce_to, yield1, yieldX
+# helpers: truthy, coerce_to, yield1, yieldX, deny_frozen_access
 
 class ::Enumerator
   class self::Lazy < self
@@ -11,6 +11,8 @@ class ::Enumerator
     end
 
     def initialize(object, size = nil, &block)
+      `$deny_frozen_access(self)`
+
       unless block_given?
         ::Kernel.raise ::ArgumentError, 'tried to call lazy new without a block'
       end

data/opal/corelib/enumerator/yielder.rb

@@ -1,5 +1,3 @@
-# helpers: breaker
-
 class Enumerator
   class Yielder
     def initialize(&block)
@@ -13,8 +11,8 @@ class Enumerator
       %x{
         var value = Opal.yieldX(#{@block}, values);
 
-        if (value === $breaker) {
-          throw $breaker;
+        if (value && value.$thrower_type == "break") {
+          throw value;
         }
 
         return value;

data/opal/corelib/enumerator.rb

@@ -1,4 +1,4 @@
-# helpers: slice, coerce_to
+# helpers: slice, coerce_to, deny_frozen_access
 
 require 'corelib/enumerable'
 
@@ -22,6 +22,8 @@ class ::Enumerator
   end
 
   def initialize(*, &block)
+    `$deny_frozen_access(self)`
+
     @cursor = 0
     if block
       @object = Generator.new(&block)

data/opal/corelib/error/errno.rb

@@ -6,7 +6,8 @@ module ::Errno
     [:EMFILE, 'Too many open files', 24],
     [:EACCES, 'Permission denied', 13],
     [:EPERM, 'Operation not permitted', 1],
-    [:ENOENT, 'No such file or directory', 2]
+    [:ENOENT, 'No such file or directory', 2],
+    [:ENAMETOOLONG, 'File name too long', 36]
   ]
 
   klass = nil

data/opal/corelib/error.rb

@@ -2,6 +2,8 @@ class ::Exception < `Error`
   `Opal.prop(self.$$prototype, '$$is_exception', true)`
   `var stack_trace_limit`
 
+  `Error.stackTraceLimit = 100`
+
   def self.new(*args)
     %x{
       var message   = (args.length > 0) ? args[0] : nil;
@@ -75,10 +77,10 @@ class ::Exception < `Error`
       var backtrace = self.stack;
 
       if (typeof(backtrace) !== 'undefined' && backtrace.$$is_string) {
-        return self.backtrace = correct_backtrace(backtrace.split("\n").slice(0, 15));
+        return self.backtrace = correct_backtrace(backtrace.split("\n"));
       }
       else if (backtrace) {
-        return self.backtrace = correct_backtrace(backtrace.slice(0, 15));
+        return self.backtrace = correct_backtrace(backtrace);
       }
 
       return [];
@@ -244,6 +246,15 @@ class ::FiberError          < ::StandardError; end
 
 ::Object.autoload :Errno, 'corelib/error/errno'
 
+class ::FrozenError < ::RuntimeError
+  attr_reader :receiver
+
+  def initialize(message, receiver: nil)
+    super message
+    @receiver = receiver
+  end
+end
+
 class ::UncaughtThrowError < ::ArgumentError
   attr_reader :tag, :value
 

data/opal/corelib/hash.rb

@@ -1,4 +1,4 @@
-# helpers: yield1, hash, hash_init, hash_get, hash_put, hash_delete
+# helpers: yield1, hash, hash_init, hash_get, hash_put, hash_delete, deny_frozen_access, freeze
 
 require 'corelib/enumerable'
 
@@ -84,6 +84,8 @@ class ::Hash
 
   def initialize(defaults = undefined, &block)
     %x{
+      $deny_frozen_access(self);
+
       if (defaults !== undefined && block !== nil) {
         #{::Kernel.raise ::ArgumentError, 'wrong number of arguments (1 for 0)'}
       }
@@ -189,6 +191,8 @@ class ::Hash
 
   def []=(key, value)
     %x{
+      $deny_frozen_access(self);
+
       $hash_put(self, key, value);
       return value;
     }
@@ -216,6 +220,8 @@ class ::Hash
 
   def clear
     %x{
+      $deny_frozen_access(self);
+
       $hash_init(self);
       return self;
     }
@@ -257,6 +263,8 @@ class ::Hash
 
   def compact!
     %x{
+      $deny_frozen_access(self);
+
       var changes_were_made = false;
 
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
@@ -284,6 +292,8 @@ class ::Hash
 
   def compare_by_identity
     %x{
+      $deny_frozen_access(self);
+
       var i, ii, key, keys = self.$$keys, identity_hash;
 
       if (self.$$by_identity) return self;
@@ -324,6 +334,8 @@ class ::Hash
 
   def default=(object)
     %x{
+      $deny_frozen_access(self);
+
       self.$$proc = nil;
       self.$$none = object;
 
@@ -342,6 +354,8 @@ class ::Hash
 
   def default_proc=(default_proc)
     %x{
+      $deny_frozen_access(self);
+
       var proc = default_proc;
 
       if (proc !== nil) {
@@ -361,6 +375,7 @@ class ::Hash
 
   def delete(key, &block)
     %x{
+      $deny_frozen_access(self);
       var value = $hash_delete(self, key);
 
       if (value !== undefined) {
@@ -379,6 +394,8 @@ class ::Hash
     return enum_for(:delete_if) { size } unless block
 
     %x{
+      $deny_frozen_access(self);
+
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
@@ -458,7 +475,7 @@ class ::Hash
     return enum_for(:each_value) { size } unless block
 
     %x{
-      for (var i = 0, keys = self.$$keys, length = keys.length, key; i < length; i++) {
+      for (var i = 0, keys = self.$$keys.slice(), length = keys.length, key; i < length; i++) {
         key = keys[i];
 
         block(key.$$is_string ? self.$$smap[key] : key.value);
@@ -540,6 +557,12 @@ class ::Hash
     }
   end
 
+  def freeze
+    return self if frozen?
+
+    `$freeze(self)`
+  end
+
   def has_key?(key)
     `$hash_get(self, key) !== undefined`
   end
@@ -714,6 +737,8 @@ class ::Hash
     return enum_for(:keep_if) { size } unless block
 
     %x{
+      $deny_frozen_access(self);
+
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
         key = keys[i];
 
@@ -766,6 +791,7 @@ class ::Hash
 
   def merge!(*others, &block)
     %x{
+      $deny_frozen_access(self);
       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)};
@@ -834,6 +860,7 @@ class ::Hash
 
   def rehash
     %x{
+      $deny_frozen_access(self);
       Opal.hash_rehash(self);
       return self;
     }
@@ -870,6 +897,8 @@ class ::Hash
     return enum_for(:reject!) { size } unless block
 
     %x{
+      $deny_frozen_access(self);
+
       var changes_were_made = false;
 
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
@@ -898,6 +927,8 @@ class ::Hash
   end
 
   def replace(other)
+    `$deny_frozen_access(self);`
+
     other = ::Opal.coerce_to!(other, ::Hash, :to_hash)
 
     %x{
@@ -957,6 +988,8 @@ class ::Hash
     return enum_for(:select!) { size } unless block
 
     %x{
+      $deny_frozen_access(self);
+
       var result = nil;
 
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value, obj; i < length; i++) {
@@ -986,6 +1019,7 @@ class ::Hash
 
   def shift
     %x{
+      $deny_frozen_access(self);
       var keys = self.$$keys,
           key;
 
@@ -1100,6 +1134,8 @@ class ::Hash
     return enum_for(:transform_keys!) { size } unless block
 
     %x{
+      $deny_frozen_access(self);
+
       var keys = Opal.slice.call(self.$$keys),
           i, length = keys.length, key, value, new_key;
 
@@ -1152,6 +1188,8 @@ class ::Hash
     return enum_for(:transform_values!) { size } unless block
 
     %x{
+      $deny_frozen_access(self);
+
       for (var i = 0, keys = self.$$keys, length = keys.length, key, value; i < length; i++) {
         key = keys[i];