Revert to using weakref.rb, since it's based on a proper weak map.

This library used to use _id2ref (an internal API) for its implementation. This was not only very VM-specific (most VMs can't reconstitute an object reference given only its ID) but also buggy (an evacuated reference might get overlaid by a new object due to MRI's conservative GC and use of address for IDs. The new implementation of the library uses ObjectSpace::WeakMap, which is considered an internal API but which exposes an opaque weak identity map that can be implemented on other VMs more more easily. Given this and our need to continue descending from Delegate, moving back to the Ruby version may make sense.
jruby · Jan 8, 2018 · 783d025 · 783d025
1 parent 87a0e73
commit 783d025
Showing 6 changed files with 113 additions and 159 deletions.
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -1704,7 +1704,6 @@ private void initBuiltins() {
         addLazyBuiltin("bigdecimal.jar", "bigdecimal", "org.jruby.ext.bigdecimal.BigDecimalLibrary");
         addLazyBuiltin("io/wait.jar", "io/wait", "org.jruby.ext.io.wait.IOWaitLibrary");
         addLazyBuiltin("etc.jar", "etc", "org.jruby.ext.etc.EtcLibrary");
-        addLazyBuiltin("weakref.rb", "weakref", "org.jruby.ext.weakref.WeakRefLibrary");
         addLazyBuiltin("timeout.rb", "timeout", "org.jruby.ext.timeout.Timeout");
         addLazyBuiltin("socket.jar", "socket", "org.jruby.ext.socket.SocketLibrary");
         addLazyBuiltin("rbconfig.rb", "rbconfig", "org.jruby.ext.rbconfig.RbConfigLibrary");

diff --git a/core/src/main/java/org/jruby/RubyObjectSpace.java b/core/src/main/java/org/jruby/RubyObjectSpace.java
@@ -214,6 +214,11 @@ public IRubyObject op_aref(ThreadContext context, IRubyObject key, IRubyObject v
             return context.runtime.newFixnum(System.identityHashCode(value));
         }
 
+        @JRubyMethod(name = "key?")
+        public IRubyObject key_p(ThreadContext context, IRubyObject key) {
+            return context.runtime.newBoolean(map.get(key) != null);
+        }
+
         private final WeakValuedIdentityMap<IRubyObject, IRubyObject> map = new WeakValuedIdentityMap<IRubyObject, IRubyObject>();
     }
 }
diff --git a/core/src/main/java/org/jruby/ext/weakref/WeakRef.java b/core/src/main/java/org/jruby/ext/weakref/WeakRef.java
diff --git a/core/src/main/java/org/jruby/ext/weakref/WeakRefLibrary.java b/core/src/main/java/org/jruby/ext/weakref/WeakRefLibrary.java
diff --git a/lib/ruby/stdlib/weakref.rb b/lib/ruby/stdlib/weakref.rb
@@ -0,0 +1,107 @@
+# frozen_string_literal: false
+require "delegate"
+
+# Weak Reference class that allows a referenced object to be
+# garbage-collected.
+#
+# A WeakRef may be used exactly like the object it references.
+#
+# Usage:
+#
+#   foo = Object.new            # create a new object instance
+#   p foo.to_s                  # original's class
+#   foo = WeakRef.new(foo)      # reassign foo with WeakRef instance
+#   p foo.to_s                  # should be same class
+#   GC.start                    # start the garbage collector
+#   p foo.to_s                  # should raise exception (recycled)
+#
+# == Example
+#
+# With help from WeakRef, we can implement our own rudimentary WeakHash class.
+#
+# We will call it WeakHash, since it's really just a Hash except all of it's
+# keys and values can be garbage collected.
+#
+#     require 'weakref'
+#
+#     class WeakHash < Hash
+#       def []= key, obj
+#         super WeakRef.new(key), WeakRef.new(obj)
+#       end
+#     end
+#
+# This is just a simple implementation, we've opened the Hash class and changed
+# Hash#store to create a new WeakRef object with +key+ and +obj+ parameters
+# before passing them as our key-value pair to the hash.
+#
+# With this you will have to limit your self to String keys, otherwise you
+# will get an ArgumentError because WeakRef cannot create a finalizer for a
+# Symbol. Symbols are immutable and cannot be garbage collected.
+#
+# Let's see it in action:
+#
+#   omg = "lol"
+#   c = WeakHash.new
+#   c['foo'] = "bar"
+#   c['baz'] = Object.new
+#   c['qux'] = omg
+#   puts c.inspect
+#   #=> {"foo"=>"bar", "baz"=>#<Object:0x007f4ddfc6cb48>, "qux"=>"lol"}
+#
+#   # Now run the garbage collector
+#   GC.start
+#   c['foo'] #=> nil
+#   c['baz'] #=> nil
+#   c['qux'] #=> nil
+#   omg      #=> "lol"
+#
+#   puts c.inspect
+#   #=> WeakRef::RefError: Invalid Reference - probably recycled
+#
+# You can see the local variable +omg+ stayed, although its reference in our
+# hash object was garbage collected, along with the rest of the keys and
+# values. Also, when we tried to inspect our hash, we got a WeakRef::RefError.
+# This is because these objects were also garbage collected.
+
+class WeakRef < Delegator
+
+  ##
+  # RefError is raised when a referenced object has been recycled by the
+  # garbage collector
+
+  class RefError < StandardError
+  end
+
+  @@__map = ::ObjectSpace::WeakMap.new
+
+  ##
+  # Creates a weak reference to +orig+
+  #
+  # Raises an ArgumentError if the given +orig+ is immutable, such as Symbol,
+  # Fixnum, or Float.
+
+  def initialize(orig)
+    case orig
+    when true, false, nil
+      @delegate_sd_obj = orig
+    else
+      @@__map[self] = orig
+    end
+    super
+  end
+
+  def __getobj__ # :nodoc:
+    @@__map[self] or defined?(@delegate_sd_obj) ? @delegate_sd_obj :
+      Kernel::raise(RefError, "Invalid Reference - probably recycled", Kernel::caller(2))
+  end
+
+  def __setobj__(obj) # :nodoc:
+  end
+
+  ##
+  # Returns true if the referenced object is still alive.
+
+  def weakref_alive?
+    @@__map.key?(self) or defined?(@delegate_sd_obj)
+  end
+end
diff --git a/tool/globals_2_3_3.rb b/tool/globals_2_3_3.rb
@@ -66,6 +66,7 @@
   unicode_normalize.rb
   uri
   uri.rb
+  weakref.rb
   webrick
   webrick.rb
   xmlrpc