jruby · Apr 8, 2016 · Apr 8, 2016 · Apr 8, 2016 · Apr 8, 2016 · Apr 8, 2016
diff --git a/core/src/main/java/org/jruby/RubyBasicObject.java b/core/src/main/java/org/jruby/RubyBasicObject.java
@@ -1075,7 +1075,7 @@ public IRubyObject inspect() {
         return to_s();
     }
 
-    public IRubyObject hashyInspect() {
+    public final IRubyObject hashyInspect() {
         final Ruby runtime = getRuntime();
         String cname = getMetaClass().getRealClass().getName();
         StringBuilder part = new StringBuilder(2 + cname.length() + 3 + 8 + 1); // #<Object:0x5a1c0542>

diff --git a/core/src/main/java/org/jruby/RubyString.java b/core/src/main/java/org/jruby/RubyString.java
@@ -517,7 +517,7 @@ public static RubyString newUTF8String(Ruby runtime, CharSequence str) {
     }
 
     public static RubyString newUTF16String(Ruby runtime, CharSequence str) {
-        ByteList byteList = new ByteList(RubyEncoding.encodeUTF16(str.toString()), UTF16BEEncoding.INSTANCE, false);
+        ByteList byteList = new ByteList(RubyEncoding.encodeUTF16(str), UTF16BEEncoding.INSTANCE, false);
         return new RubyString(runtime, runtime.getString(), byteList);
     }
 

diff --git a/core/src/main/java/org/jruby/java/proxies/JavaProxy.java b/core/src/main/java/org/jruby/java/proxies/JavaProxy.java
@@ -89,7 +89,7 @@ public void dataWrapStruct(Object object) {
         this.object = javaObject.getValue();
     }
 
-    public Object getObject() {
+    public final Object getObject() {
         // FIXME: Added this because marshal_spec seemed to reconstitute objects without calling dataWrapStruct
         // this resulted in object being null after unmarshalling...
         if (object == null) {

diff --git a/core/src/main/java/org/jruby/javasupport/JavaObject.java b/core/src/main/java/org/jruby/javasupport/JavaObject.java
@@ -252,7 +252,7 @@ public IRubyObject is_java_proxy() {
     }
 
     @JRubyMethod(name = "synchronized")
-    public IRubyObject ruby_synchronized(ThreadContext context, Block block) {
+    public final IRubyObject ruby_synchronized(ThreadContext context, Block block) {
         Object lock = getValue();
         synchronized (lock != null ? lock : NULL_LOCK) {
             return block.yield(context, null);

diff --git a/core/src/main/java/org/jruby/javasupport/JavaProxyMethods.java b/core/src/main/java/org/jruby/javasupport/JavaProxyMethods.java
@@ -1,24 +1,47 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 1.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 1.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the EPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the EPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
 package org.jruby.javasupport;
 
-import org.jruby.Ruby;
 import org.jruby.RubyBasicObject;
 import org.jruby.RubyFixnum;
 import org.jruby.RubyModule;
-import org.jruby.RubyObject;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.java.proxies.JavaProxy;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 public class JavaProxyMethods {
+
+    private JavaProxyMethods() { /* no instances */ }
+
     public static RubyModule createJavaProxyMethods(ThreadContext context) {
-        Ruby runtime = context.runtime;
-        RubyModule javaProxyMethods = runtime.defineModule("JavaProxyMethods");
-
-        javaProxyMethods.defineAnnotatedMethods(JavaProxyMethods.class);
-
-        return javaProxyMethods;
+        RubyModule JavaProxyMethods = context.runtime.defineModule("JavaProxyMethods");
+        JavaProxyMethods.defineAnnotatedMethods(JavaProxyMethods.class);
+        return JavaProxyMethods;
     }
 
     @JRubyMethod
@@ -28,7 +51,7 @@ public static IRubyObject java_class(ThreadContext context, IRubyObject recv) {
 
     @JRubyMethod
     public static IRubyObject java_object(ThreadContext context, IRubyObject recv) {
-        return (IRubyObject)recv.dataGetStruct();
+        return (IRubyObject) recv.dataGetStruct();
     }
 
     @JRubyMethod(name = "java_object=")
@@ -38,57 +61,55 @@ public static IRubyObject java_object_set(ThreadContext context, IRubyObject rec
         return obj;
     }
 
-    @JRubyMethod(name = {"=="})
+    @JRubyMethod
+    public static IRubyObject to_java_object(IRubyObject recv) {
+        return (JavaObject) recv.dataGetStruct();
+    }
+
+    @JRubyMethod(name = "eql?")
+    public static IRubyObject op_eql(IRubyObject recv, IRubyObject obj) {
+        return op_equal(recv, obj);
+    }
+
+    @JRubyMethod(name = "==")
     public static IRubyObject op_equal(IRubyObject recv, IRubyObject rhs) {
         if (recv instanceof JavaProxy) {
-            return JavaObject.op_equal((JavaProxy)recv, rhs);
+            return JavaObject.op_equal((JavaProxy) recv, rhs);
         }
         return ((JavaObject)recv.dataGetStruct()).op_equal(rhs);
     }
 
     @JRubyMethod
     public static IRubyObject to_s(IRubyObject recv) {
         if (recv instanceof JavaProxy) {
-            return JavaObject.to_s(recv.getRuntime(), ((JavaProxy)recv).getObject());
-        } else if (recv.dataGetStruct() != null) {
-            return ((JavaObject)recv.dataGetStruct()).to_s();
-        } else {
-            return ((RubyObject)recv).to_s();
+            return JavaObject.to_s(recv.getRuntime(), ((JavaProxy) recv).getObject());
         }
+        final Object unwrap = recv.dataGetStruct();
+        if (unwrap != null) return ((JavaObject) unwrap).to_s();
+        return ((RubyBasicObject) recv).to_s();
     }
 
     @JRubyMethod
     public static IRubyObject inspect(IRubyObject recv) {
         if (recv instanceof RubyBasicObject) {
-            return ((RubyBasicObject)recv).hashyInspect();
-        } else {
-            return recv.inspect();
+            return ((RubyBasicObject) recv).hashyInspect();
         }
-    }
-
-    @JRubyMethod(name = "eql?")
-    public static IRubyObject op_eql(IRubyObject recv, IRubyObject rhs) {
-        return op_equal(recv, rhs);
+        return recv.inspect();
     }
 
     @JRubyMethod
     public static IRubyObject hash(IRubyObject recv) {
         if (recv instanceof JavaProxy) {
-            return RubyFixnum.newFixnum(recv.getRuntime(), ((JavaProxy)recv).getObject().hashCode());
+            return RubyFixnum.newFixnum(recv.getRuntime(), ((JavaProxy) recv).getObject().hashCode());
         }
-        return ((JavaObject)recv.dataGetStruct()).hash();
-    }
-
-    @JRubyMethod
-    public static IRubyObject to_java_object(IRubyObject recv) {
-        return (JavaObject)recv.dataGetStruct();
+        return ((JavaObject) recv.dataGetStruct()).hash();
     }
 
     @JRubyMethod(name = "synchronized")
     public static IRubyObject rbSynchronized(ThreadContext context, IRubyObject recv, Block block) {
         if (recv instanceof JavaProxy) {
-            return JavaObject.ruby_synchronized(context, ((JavaProxy)recv).getObject(), block);
+            return JavaObject.ruby_synchronized(context, ((JavaProxy) recv).getObject(), block);
         }
-        return ((JavaObject)recv.dataGetStruct()).ruby_synchronized(context, block);
+        return ((JavaObject) recv.dataGetStruct()).ruby_synchronized(context, block);
     }
 }
diff --git a/core/src/main/java/org/jruby/javasupport/JavaSupport.java b/core/src/main/java/org/jruby/javasupport/JavaSupport.java
@@ -63,10 +63,12 @@ public abstract class JavaSupport {
 
     public abstract Map<String, JavaClass> getNameClassMap();
 
-    public abstract void setJavaObjectVariable(Object o, int i, Object v);
-
+    @Deprecated
     public abstract Object getJavaObjectVariable(Object o, int i);
 
+    @Deprecated
+    public abstract void setJavaObjectVariable(Object o, int i, Object v);
+
     public abstract RubyModule getJavaModule();
 
     public abstract RubyModule getJavaUtilitiesModule();
@@ -108,15 +110,94 @@ public abstract class JavaSupport {
 
     public abstract RubyClass getJavaProxyConstructorClass();
 
-    public abstract Map<Set<?>, JavaProxyClass> getJavaProxyClassCache();
-
     public abstract ClassValue<Map<String, AssignedName>> getStaticAssignedNames();
 
     public abstract ClassValue<Map<String, AssignedName>> getInstanceAssignedNames();
 
+    @Deprecated // internal API - no longer used
+    public abstract Map<Set<?>, JavaProxyClass> getJavaProxyClassCache();
+
+    /**
+     * a replacement for {@link #getJavaProxyClassCache()} API
+     */
+    abstract JavaProxyClass fetchJavaProxyClass(ProxyClassKey classKey);
+
+    /**
+     * a replacement for {@link #getJavaProxyClassCache()} API
+     */
+    abstract JavaProxyClass saveJavaProxyClass(ProxyClassKey classKey, JavaProxyClass klass);
+
+    /**
+     * @note Internal API - subject to change!
+     */
+    public static final class ProxyClassKey {
+        final Class superClass;
+        final Class[] interfaces;
+        final Set<String> names; // "usable" method names - assumed immutable
+
+        private ProxyClassKey(Class superClass, Class[] interfaces, Set<String> names) {
+            this.superClass = superClass;
+            this.interfaces = interfaces;
+            this.names = names;
+        }
+
+        public static ProxyClassKey getInstance(Class superClass, Class[] interfaces, Set<String> names) {
+            return new ProxyClassKey(superClass, interfaces, names);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+            if ( obj instanceof ProxyClassKey ) {
+                final ProxyClassKey that = (ProxyClassKey) obj;
+                if (this.superClass != that.superClass) return false;
+
+                if (this.names.size() != that.names.size()) return false;
+                if ( ! this.names.equals(that.names) ) return false;
+
+                final int len = this.interfaces.length;
+                if (len != that.interfaces.length) return false;
+                // order is not important :
+                for ( int i = 0; i < len; i++ ) {
+                    final Class iface = this.interfaces[i];
+                    boolean ifaceFound = false;
+                    for ( int j = 0; j < len; j++ ) {
+                        if ( iface == that.interfaces[j] ) {
+                            ifaceFound = true; break;
+                        }
+                    }
+                    if ( ! ifaceFound ) return false;
+                }
+                return true;
+            }
+            return false;
+        }
+
+        private int hash;
+
+        @Override
+        public int hashCode() {
+            int hash = this.hash;
+            if (hash != 0) return hash;
+
+            for ( int i = 0; i < interfaces.length; i++ ) {
+                hash += interfaces[i].hashCode();
+            }
+            return this.hash = (hash * superClass.hashCode()) ^ this.names.hashCode();
+        }
+    }
+
+    /**
+     * @deprecated Internal API that should not be accessible.
+     */
     public abstract void beginProxy(Class cls, RubyModule proxy);
 
+    /**
+     * @deprecated Internal API that should not be accessible.
+     */
     public abstract void endProxy(Class cls);
 
+    /**
+     * @deprecated Internal API that should not be accessible.
+     */
     public abstract RubyModule getUnfinishedProxy(Class cls);
 }