jruby · Jan 8, 2018 · Jan 8, 2018
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/core/src/main/java/org/jruby/ir/interpreter/Interpreter.java b/core/src/main/java/org/jruby/ir/interpreter/Interpreter.java
@@ -84,13 +84,9 @@ protected IRubyObject execute(Ruby runtime, IRScriptBody irScope, IRubyObject se
         }
 
         scope.setModule(currModule);
-        DynamicScope tlbScope = irScope.getScriptDynamicScope();
-        if (tlbScope == null) {
-            context.preMethodScopeOnly(scope);
-        } else {
-            context.preScopedBody(tlbScope);
-            tlbScope.growIfNeeded();
-        }
+
+        IRRuntimeHelpers.prepareScriptScope(context, scope);
+
         context.setCurrentVisibility(Visibility.PRIVATE);
 
         try {

diff --git a/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java b/core/src/main/java/org/jruby/ir/runtime/IRRuntimeHelpers.java
@@ -19,6 +19,7 @@
 import org.jruby.ir.IRMethod;
 import org.jruby.ir.IRScope;
 import org.jruby.ir.IRScopeType;
+import org.jruby.ir.IRScriptBody;
 import org.jruby.ir.Interp;
 import org.jruby.ir.JIT;
 import org.jruby.ir.Tuple;
@@ -568,6 +569,25 @@ public static void checkForExtraUnwantedKeywordArgs(ThreadContext context, final
         }
     }
 
+    @JIT
+    public static DynamicScope prepareScriptScope(ThreadContext context, StaticScope scope) {
+        IRScope irScope = scope.getIRScope();
+
+        if (irScope.isScriptScope()) {
+            DynamicScope tlbScope = ((IRScriptBody) irScope).getScriptDynamicScope();
+            if (tlbScope != null) {
+                context.preScopedBody(tlbScope);
+                tlbScope.growIfNeeded();
+                return tlbScope;
+            }
+        }
+
+        DynamicScope dynScope = DynamicScope.newDynamicScope(scope);
+        context.pushScope(dynScope);
+
+        return dynScope;
+    }
+
     private static class InvalidKeyException extends RuntimeException {}
     private static final InvalidKeyException INVALID_KEY_EXCEPTION = new InvalidKeyException();
     private static final RubyHash.VisitorWithState<StaticScope> CheckUnwantedKeywordsVisitor = new RubyHash.VisitorWithState<StaticScope>() {

diff --git a/core/src/main/java/org/jruby/ir/targets/JVMVisitor.java b/core/src/main/java/org/jruby/ir/targets/JVMVisitor.java
@@ -1692,46 +1692,24 @@ public void PushBlockFrameInstr(PushBlockFrameInstr instr) {
     @Override
     public void PushMethodBindingInstr(PushMethodBindingInstr pushbindinginstr) {
         IRScope scope = jvm.methodData().scope;
-        org.objectweb.asm.Label done = new org.objectweb.asm.Label();
 
         if (scope.isScriptScope() &&
                 scope.getRootLexicalScope() != null) {
-
-            org.objectweb.asm.Label noTopLevel = new org.objectweb.asm.Label();
-
             // script scope, so we don't push a new scope; instead we push the top-level scope it provides
             jvmMethod().loadContext();
-
             jvmMethod().loadStaticScope();
-            jvmAdapter().invokevirtual(p(StaticScope.class), "getIRScope", sig(IRScope.class));
-            jvmAdapter().checkcast(p(IRScriptBody.class));
-            jvmAdapter().invokevirtual(p(IRScriptBody.class), "getScriptDynamicScope", sig(DynamicScope.class));
-
-            jvmAdapter().dup();
-            jvmAdapter().ifnull(noTopLevel);
-
-            jvmAdapter().dup();
+            jvmMethod().invokeIRHelper("prepareScriptScope", sig(DynamicScope.class, ThreadContext.class, StaticScope.class));
             jvmStoreLocal(DYNAMIC_SCOPE);
 
+            return;
+        } else {
+            jvmMethod().loadContext();
+            jvmMethod().loadStaticScope();
+            jvmAdapter().invokestatic(p(DynamicScope.class), "newDynamicScope", sig(DynamicScope.class, StaticScope.class));
             jvmAdapter().dup();
-            jvmAdapter().invokevirtual(p(DynamicScope.class), "growIfNeeded", sig(void.class));
-
-            jvmAdapter().invokevirtual(p(ThreadContext.class), "preScopedBody", sig(void.class, DynamicScope.class));
-
-            jvmAdapter().go_to(done);
-
-            jvmAdapter().label(noTopLevel);
-            jvmAdapter().pop2(); // context, dynscope
+            jvmStoreLocal(DYNAMIC_SCOPE);
+            jvmMethod().invokeVirtual(Type.getType(ThreadContext.class), Method.getMethod("void pushScope(org.jruby.runtime.DynamicScope)"));
         }
-
-        jvmMethod().loadContext();
-        jvmMethod().loadStaticScope();
-        jvmAdapter().invokestatic(p(DynamicScope.class), "newDynamicScope", sig(DynamicScope.class, StaticScope.class));
-        jvmAdapter().dup();
-        jvmStoreLocal(DYNAMIC_SCOPE);
-        jvmMethod().invokeVirtual(Type.getType(ThreadContext.class), Method.getMethod("void pushScope(org.jruby.runtime.DynamicScope)"));
-
-        jvmAdapter().label(done);
     }
 
     @Override

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