jruby · Mar 26, 2018 · Mar 26, 2018 · Mar 27, 2018 · Mar 27, 2018 · Mar 27, 2018
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -5132,7 +5132,7 @@ private void setNetworkStack() {
         deprecatedNetworkStackProperty();
     }
 
-    @SuppressWarnings("deprecated")
+    @SuppressWarnings("deprecation")
     private void deprecatedNetworkStackProperty() {
         if (Options.PREFER_IPV4.load()) {
             LOG.warn("Warning: not setting network stack system property because socket subsystem may already be booted."

diff --git a/core/src/main/java/org/jruby/RubyComplex.java b/core/src/main/java/org/jruby/RubyComplex.java
@@ -1032,7 +1032,7 @@ static RubyArray str_to_c_internal(ThreadContext context, IRubyObject recv) {
             } else {
                 si = match.op_aref19(RubyFixnum.three(runtime));
                 IRubyObject t = match.op_aref19(RubyFixnum.four(runtime));
-                if (t.isNil()) t = runtime.newString(RubyFixnum.SINGLE_CHAR_BYTELISTS19['1']);
+                if (t.isNil()) t = runtime.newString(RubyInteger.SINGLE_CHAR_BYTELISTS['1']);
                 si.convertToString().cat(t.convertToString().getByteList());
             }
             re = match.post_match(context);

diff --git a/core/src/main/java/org/jruby/RubyIO.java b/core/src/main/java/org/jruby/RubyIO.java
@@ -1646,7 +1646,7 @@ public IRubyObject putc(ThreadContext context, IRubyObject ch) {
         if (ch instanceof RubyString) {
             str = ((RubyString)ch).substr(context.runtime, 0, 1);
         } else {
-            str = RubyString.newStringShared(context.runtime, RubyFixnum.SINGLE_CHAR_BYTELISTS19[RubyNumeric.num2chr(ch) & 0xFF]);
+            str = RubyString.newStringShared(context.runtime, RubyInteger.SINGLE_CHAR_BYTELISTS[RubyNumeric.num2chr(ch) & 0xFF]);
         }
 
         sites(context).write.call(context, this, this, str);
@@ -1659,7 +1659,7 @@ public static IRubyObject putc(ThreadContext context, IRubyObject maybeIO, IRuby
             ((RubyIO)maybeIO).putc(context, object);
         } else {
             byte c = RubyNumeric.num2chr(object);
-            IRubyObject str = RubyString.newStringShared(context.runtime, RubyFixnum.SINGLE_CHAR_BYTELISTS19[c & 0xFF]);
+            IRubyObject str = RubyString.newStringShared(context.runtime, RubyInteger.SINGLE_CHAR_BYTELISTS[c & 0xFF]);
             sites(context).write.call(context, maybeIO, maybeIO, str);
         }
 

diff --git a/core/src/main/java/org/jruby/RubyInteger.java b/core/src/main/java/org/jruby/RubyInteger.java
@@ -299,17 +299,16 @@ public IRubyObject succ(ThreadContext context) {
     }
 
     static final ByteList[] SINGLE_CHAR_BYTELISTS;
-    @Deprecated
-    public static final ByteList[] SINGLE_CHAR_BYTELISTS19;
     static {
         SINGLE_CHAR_BYTELISTS = new ByteList[256];
         for (int i = 0; i < 256; i++) {
             ByteList bytes = new ByteList(new byte[] { (byte) i }, false);
             SINGLE_CHAR_BYTELISTS[i] = bytes;
             bytes.setEncoding(i < 0x80 ? USASCIIEncoding.INSTANCE : ASCIIEncoding.INSTANCE);
         }
-        SINGLE_CHAR_BYTELISTS19 = SINGLE_CHAR_BYTELISTS;
     }
+    @Deprecated
+    public static final ByteList[] SINGLE_CHAR_BYTELISTS19 = SINGLE_CHAR_BYTELISTS;
 
     static ByteList singleCharByteList(final byte index) {
         return SINGLE_CHAR_BYTELISTS[index & 0xFF];

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -78,11 +78,11 @@
 import org.jruby.internal.runtime.methods.DynamicMethod;
 import org.jruby.internal.runtime.methods.Framing;
 import org.jruby.internal.runtime.methods.JavaMethod;
+import org.jruby.internal.runtime.methods.PartialDelegatingMethod;
 import org.jruby.internal.runtime.methods.ProcMethod;
 import org.jruby.internal.runtime.methods.Scoping;
 import org.jruby.internal.runtime.methods.SynchronizedDynamicMethod;
 import org.jruby.internal.runtime.methods.UndefinedMethod;
-import org.jruby.internal.runtime.methods.WrapperMethod;
 import org.jruby.ir.IRClosure;
 import org.jruby.ir.IRMethod;
 import org.jruby.ir.runtime.IRRuntimeHelpers;
@@ -107,7 +107,6 @@
 import org.jruby.runtime.ivars.MethodData;
 import org.jruby.runtime.marshal.MarshalStream;
 import org.jruby.runtime.marshal.UnmarshalStream;
-import org.jruby.runtime.opto.ConstantInvalidator;
 import org.jruby.runtime.opto.Invalidator;
 import org.jruby.runtime.opto.OptoFactory;
 import org.jruby.runtime.profile.MethodEnhancer;
@@ -1814,7 +1813,7 @@ public void exportMethod(String name, Visibility visibility) {
             if (this == method.getImplementationClass()) {
                 method.setVisibility(visibility);
             } else {
-                DynamicMethod newMethod = new WrapperMethod(this, method, visibility);
+                DynamicMethod newMethod = new PartialDelegatingMethod(this, method, visibility);
 
                 methodLocation.addMethod(name, newMethod);
             }

diff --git a/core/src/main/java/org/jruby/TopSelfFactory.java b/core/src/main/java/org/jruby/TopSelfFactory.java
@@ -59,7 +59,7 @@ public static IRubyObject createTopSelf(final Ruby runtime, final boolean wrappe
 
         final RubyClass singletonClass = topSelf.getSingletonClass();
 
-        singletonClass.addMethod("to_s", new JavaMethod.JavaMethodZero(singletonClass, Visibility.PUBLIC) {
+        singletonClass.addMethod("to_s", new JavaMethod.JavaMethodZero(singletonClass, Visibility.PUBLIC, "to_s") {
             @Override
             public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name) {
                 return runtime.newString("main");
@@ -69,29 +69,29 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
 
         // The following three methods must be defined fast, since they expect to modify the current frame
         // (i.e. they expect no frame will be allocated for them). JRUBY-1185.
-        singletonClass.addMethod("include", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE) {
+        singletonClass.addMethod("include", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE, "include") {
             @Override
             public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {
                 return context.runtime.getObject().include(args);
             }
         });
 
-        singletonClass.addMethod("public", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE) {
+        singletonClass.addMethod("public", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE, "public") {
             @Override
             public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {
                 return context.runtime.getObject().rbPublic(context, args);
             }
         });
 
-        singletonClass.addMethod("private", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE) {
+        singletonClass.addMethod("private", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE, "private") {
             @Override
             public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {
                 return context.runtime.getObject().rbPrivate(context, args);
             }
         });
 
         final RubyClass klass = wrapper ? singletonClass : runtime.getObject();
-        singletonClass.addMethod("define_method", new JavaMethod.JavaMethodOneOrTwoBlock(singletonClass, Visibility.PRIVATE) {
+        singletonClass.addMethod("define_method", new JavaMethod.JavaMethodOneOrTwoBlock(singletonClass, Visibility.PRIVATE, "define_method") {
             @Override
             public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject arg0, Block block) {
                 if (klass == singletonClass) warnWrapper(context);
@@ -105,7 +105,7 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule claz
             }
         });
 
-        singletonClass.addMethod("using", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE) {
+        singletonClass.addMethod("using", new JavaMethod.JavaMethodN(singletonClass, Visibility.PRIVATE, "using") {
             @Override
             public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule clazz, String name, IRubyObject[] args) {
                 Arity.checkArgumentCount(context.runtime, args, 1, 1);

diff --git a/core/src/main/java/org/jruby/anno/IndyBinder.java b/core/src/main/java/org/jruby/anno/IndyBinder.java
@@ -365,7 +365,12 @@ public void processMethodDeclarationMulti(List<ExecutableElement> methods) {
                 }
                 buffer.append(')');
 
-                Handle handle = new Handle(isStatic ? H_INVOKESTATIC : H_INVOKEVIRTUAL, qualifiedName.toString().replace('.', '/'), method.getSimpleName().toString(), Method.getMethod(buffer.toString()).getDescriptor());
+                Handle handle = new Handle(
+                        isStatic ? H_INVOKESTATIC : H_INVOKEVIRTUAL,
+                        qualifiedName.toString().replace('.', '/'),
+                        method.getSimpleName().toString(),
+                        Method.getMethod(buffer.toString()).getDescriptor(),
+                        false);
 
                 int handleOffset = calculateHandleOffset(method.getParameters().size(), anno.required(), anno.optional(), anno.rest(), isStatic, hasContext, hasBlock);
 

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/DynamicMethod.java b/core/src/main/java/org/jruby/internal/runtime/methods/DynamicMethod.java
@@ -395,7 +395,7 @@ public Arity getArity() {
     /**
      * Get the "real" method contained within this method. This simply returns
      * self except in cases where a method is wrapped to give it a new
-     * name or new implementation class (AliasMethod, WrapperMethod, ...).
+     * name or new implementation class (AliasMethod, PartialDelegatingMethod, ...).
      *
      * @return The "real" method associated with this one
      */

diff --git a/core/src/main/java/org/jruby/internal/runtime/methods/InvocationMethodFactory.java b/core/src/main/java/org/jruby/internal/runtime/methods/InvocationMethodFactory.java
@@ -343,6 +343,7 @@ public DynamicMethod getAnnotatedMethod(RubyModule implementationClass, JavaMeth
         }
     }
 
+    @SuppressWarnings("deprecation")
     public JavaMethod constructJavaMethod(RubyModule implementationClass, JavaMethodDescriptor desc, String name, Class c) throws InstantiationException, IllegalAccessException, java.lang.reflect.InvocationTargetException, NoSuchMethodException {
         // In order to support older versions of generated JavaMethod invokers, we check for the Version
         // annotation to be present and > 0. If absent, we use a thread local to allow the deprecated constructor

diff --git a/...ternal/runtime/methods/WrapperMethod.java → ...time/methods/PartialDelegatingMethod.java b/...ternal/runtime/methods/WrapperMethod.java → ...time/methods/PartialDelegatingMethod.java
@@ -36,18 +36,25 @@
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
- * 
+ * This is similar to {@link DelegatingDynamicMethod} except that it does not delegate most properties of DynamicMethod.
+ * Visibility, etc, set on an instance of {@link PartialDelegatingMethod} will not be delegated to the contained method.
+ *
+ * This type of method is used primarily for altering the visibility of a parent class's method in a child class.
+ *
+ * Note that {@link AliasMethod} is not a suitable substitute since it always passes the method's original name to the
+ * delegate, and {@link DelegatingDynamicMethod} is not a suitable substitute since it delegates all properties to the
+ * delegate.
+ *
  * @author jpetersen
  */
-@Deprecated
-public class WrapperMethod extends DynamicMethod {
+public class PartialDelegatingMethod extends DynamicMethod {
     private DynamicMethod method;
 
     /**
-     * Constructor for WrapperCallable.
+     * Constructor for PartialDelegatingMethod.
      * @param visibility
      */
-    public WrapperMethod(RubyModule implementationClass, DynamicMethod method, Visibility visibility) {
+    public PartialDelegatingMethod(RubyModule implementationClass, DynamicMethod method, Visibility visibility) {
         super(implementationClass, visibility, method.getName()   );
         this.method = method;
     }
@@ -93,7 +100,7 @@ public IRubyObject call(ThreadContext context, IRubyObject self, RubyModule klaz
     }
 
     public DynamicMethod dup() {
-        return new WrapperMethod(getImplementationClass(), method, getVisibility());
+        return new PartialDelegatingMethod(getImplementationClass(), method, getVisibility());
     }
 
     public long getSerialNumber() {

diff --git a/core/src/main/java/org/jruby/ir/targets/ArrayDerefInvokeSite.java b/core/src/main/java/org/jruby/ir/targets/ArrayDerefInvokeSite.java
@@ -34,7 +34,12 @@ public ArrayDerefInvokeSite(MethodType type, String file, int line) {
         super(type, "[]", false, file, line);
     }
 
-    public static final Handle BOOTSTRAP = new Handle(Opcodes.H_INVOKESTATIC, p(ArrayDerefInvokeSite.class), "bootstrap", sig(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, String.class, int.class));
+    public static final Handle BOOTSTRAP = new Handle(
+            Opcodes.H_INVOKESTATIC,
+            p(ArrayDerefInvokeSite.class),
+            "bootstrap",
+            sig(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, String.class, int.class),
+            false);
 
     public static CallSite bootstrap(MethodHandles.Lookup lookup, String name, MethodType type, String file, int line) {
         InvokeSite site = new ArrayDerefInvokeSite(type, file, line);

diff --git a/core/src/main/java/org/jruby/ir/targets/BignumObjectSite.java b/core/src/main/java/org/jruby/ir/targets/BignumObjectSite.java
@@ -25,7 +25,12 @@ public BignumObjectSite(MethodType type, String value) {
         this.value = value;
     }
 
-    public static final Handle BOOTSTRAP = new Handle(Opcodes.H_INVOKESTATIC, p(BignumObjectSite.class), "bootstrap", sig(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, String.class));
+    public static final Handle BOOTSTRAP = new Handle(
+            Opcodes.H_INVOKESTATIC,
+            p(BignumObjectSite.class),
+            "bootstrap",
+            sig(CallSite.class, MethodHandles.Lookup.class, String.class, MethodType.class, String.class),
+            false);
 
     public static CallSite bootstrap(MethodHandles.Lookup lookup, String name, MethodType type, String value) {
         return new BignumObjectSite(type, value).bootstrap(lookup);

diff --git a/core/src/main/java/org/jruby/ir/targets/Bootstrap.java b/core/src/main/java/org/jruby/ir/targets/Bootstrap.java
@@ -142,39 +142,79 @@ public static CallSite ivar(Lookup lookup, String name, MethodType type) throws
     }
 
     public static Handle string() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "string", sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, String.class, int.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "string",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, String.class, int.class),
+                false);
     }
 
     public static Handle fstring() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "fstring", sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, String.class, int.class, String.class, int.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "fstring",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, String.class, int.class, String.class, int.class),
+                false);
     }
 
     public static Handle bytelist() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "bytelist", sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, String.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "bytelist",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, String.class),
+                false);
     }
 
     public static Handle array() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "array", sig(CallSite.class, Lookup.class, String.class, MethodType.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "array",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class),
+                false);
     }
 
     public static Handle hash() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "hash", sig(CallSite.class, Lookup.class, String.class, MethodType.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "hash",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class),
+                false);
     }
 
     public static Handle kwargsHash() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "kwargsHash", sig(CallSite.class, Lookup.class, String.class, MethodType.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "kwargsHash",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class),
+                false);
     }
 
     public static Handle invokeSuper() {
         return SuperInvokeSite.BOOTSTRAP;
     }
 
     public static Handle ivar() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "ivar", sig(CallSite.class, Lookup.class, String.class, MethodType.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "ivar",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class),
+                false);
     }
 
     public static Handle global() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "globalBootstrap", sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, int.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "globalBootstrap",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class, int.class),
+                false);
     }
 
     public static RubyString string(MutableCallSite site, ByteList value, int cr, ThreadContext context) throws Throwable {
@@ -215,11 +255,21 @@ public static IRubyObject array(ThreadContext context, IRubyObject[] elts) {
     }
 
     public static Handle contextValue() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "contextValue", sig(CallSite.class, Lookup.class, String.class, MethodType.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "contextValue",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class),
+                false);
     }
 
     public static Handle contextValueString() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "contextValueString", sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "contextValueString",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class, String.class),
+                false);
     }
 
     public static CallSite contextValue(Lookup lookup, String name, MethodType type) {
@@ -845,7 +895,12 @@ public static Handle getBootstrapHandle(String name, String sig) {
     }
 
     public static Handle getBootstrapHandle(String name, Class type, String sig) {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(type), name, sig);
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(type),
+                name,
+                sig,
+                false);
     }
 
     public static CallSite checkpointBootstrap(Lookup lookup, String name, MethodType type) throws Throwable {
@@ -949,7 +1004,12 @@ public static void setGlobalUncached(GlobalVariable variable, IRubyObject value)
     }
 
     public static Handle prepareBlock() {
-        return new Handle(Opcodes.H_INVOKESTATIC, p(Bootstrap.class), "prepareBlock", sig(CallSite.class, Lookup.class, String.class, MethodType.class, MethodHandle.class, MethodHandle.class, long.class));
+        return new Handle(
+                Opcodes.H_INVOKESTATIC,
+                p(Bootstrap.class),
+                "prepareBlock",
+                sig(CallSite.class, Lookup.class, String.class, MethodType.class, MethodHandle.class, MethodHandle.class, long.class),
+                false);
     }
 
     public static CallSite prepareBlock(Lookup lookup, String name, MethodType type, MethodHandle bodyHandle, MethodHandle scopeHandle, long encodedSignature) throws Throwable {