jruby · Mar 21, 2018 · Mar 26, 2018 · Mar 26, 2018 · Mar 26, 2018 · Mar 26, 2018
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -5259,7 +5259,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/RubyInteger.java b/core/src/main/java/org/jruby/RubyInteger.java
@@ -321,17 +321,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/RubyMethod.java b/core/src/main/java/org/jruby/RubyMethod.java
@@ -35,10 +35,10 @@
 import org.jruby.anno.JRubyMethod;
 import org.jruby.anno.JRubyClass;
 import org.jruby.internal.runtime.methods.AliasMethod;
+import org.jruby.internal.runtime.methods.DelegatingDynamicMethod;
 import org.jruby.internal.runtime.methods.DynamicMethod;
 import org.jruby.internal.runtime.methods.IRMethodArgs;
 import org.jruby.internal.runtime.methods.ProcMethod;
-import org.jruby.internal.runtime.methods.WrapperMethod;
 import org.jruby.runtime.ArgumentDescriptor;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.ClassIndex;
@@ -253,7 +253,7 @@ public IRubyObject inspect() {
         RubyModule definedClass;
         RubyModule mklass = originModule;
 
-        if (method instanceof AliasMethod || method instanceof WrapperMethod) {
+        if (method instanceof AliasMethod || method instanceof DelegatingDynamicMethod) {
             definedClass = method.getRealMethod().getDefinedClass();
         }
         else {

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -77,10 +77,10 @@
 import org.jruby.internal.runtime.methods.DynamicMethod;
 import org.jruby.internal.runtime.methods.JavaMethod;
 import org.jruby.internal.runtime.methods.NativeCallMethod;
+import org.jruby.internal.runtime.methods.PartialDelegatingMethod;
 import org.jruby.internal.runtime.methods.ProcMethod;
 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;
@@ -105,7 +105,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;
@@ -1851,7 +1850,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/RubyTime.java b/core/src/main/java/org/jruby/RubyTime.java
@@ -1555,20 +1555,15 @@ private static RubyTime createTime(ThreadContext context, RubyClass klass, IRuby
         RubyTime time = new RubyTime(runtime, klass, dt);
         // Ignores usec if 8 args (for compatibility with parse-date) or if not supplied.
         if (args.length != 8 && args[6] != context.nil) {
-            boolean fractionalUSecGiven = args[6] instanceof RubyFloat || args[6] instanceof RubyRational;
-
-            if (fractionalUSecGiven) {
-                if (args[6] instanceof RubyRational) {
-                    RubyRational usecRat = (RubyRational) args[6];
-                    RubyRational nsecRat = (RubyRational) usecRat.op_mul(context, runtime.newFixnum(1000));
-                    double tmpNanos = nsecRat.getDoubleValue(context);
-                    time.dt = dt.withMillis((long) (dt.getMillis() + (tmpNanos / 1000000)));
-                    nanos = (long) tmpNanos % 1000000;
-                } else {
-                    double micros = RubyNumeric.num2dbl(args[6]);
-                    time.dt = dt.withMillis(dt.getMillis() + (long) (micros / 1000));
-                    nanos = (long) Math.rint((micros * 1000) % 1000000);
-                }
+            if (args[6] instanceof RubyRational) {
+                RubyRational nsec = (RubyRational) ((RubyRational) args[6]).op_mul(context, runtime.newFixnum(1000));
+                long tmpNanos = (long) nsec.getDoubleValue(context);
+                time.dt = dt.withMillis(dt.getMillis() + (tmpNanos / 1_000_000));
+                nanos = tmpNanos % 1_000_000;
+            } else if (args[6] instanceof RubyFloat) {
+                double micros = ((RubyFloat) args[6]).getDoubleValue();
+                time.dt = dt.withMillis(dt.getMillis() + (long) (micros / 1000));
+                nanos = (long) Math.rint((micros * 1000) % 1_000_000);
             } else {
                 int usec = i_args4 % 1000;
                 int msec = i_args4 / 1000;
@@ -1582,8 +1577,7 @@ private static RubyTime createTime(ThreadContext context, RubyClass klass, IRuby
             }
         }
 
-        if (nanos != 0)
-            time.setNSec(nanos);
+        if (nanos != 0) time.setNSec(nanos);
 
         time.callInit(IRubyObject.NULL_ARRAY, Block.NULL_BLOCK);
         time.setIsTzRelative(setTzRelative);

diff --git a/core/src/main/java/org/jruby/TopSelfFactory.java b/core/src/main/java/org/jruby/TopSelfFactory.java
@@ -60,7 +60,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");
@@ -70,29 +70,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);
@@ -106,7 +106,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
@@ -357,7 +357,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/ext/coverage/CoverageData.java b/core/src/main/java/org/jruby/ext/coverage/CoverageData.java
@@ -93,6 +93,12 @@ private boolean hasCodeBeenPartiallyCovered(int[] lines) {
     public synchronized Map<String, int[]> prepareCoverage(String filename, int[] lines) {
         assert lines != null;
 
+        if (filename == null) {
+            // null filename from certain evals, Ruby.executeScript, etc (jruby/jruby#5111)
+            // we opt to ignore scripts with no filename, since coverage means nothing
+            return coverage;
+        }
+
         Map<String, int[]> coverage = this.coverage;
 
         if (coverage != null) {

diff --git a/core/src/main/java/org/jruby/ext/socket/RubyUDPSocket.java b/core/src/main/java/org/jruby/ext/socket/RubyUDPSocket.java
@@ -41,6 +41,7 @@
 import java.net.SocketAddress;
 import java.net.SocketException;
 import java.net.MulticastSocket;
+import java.net.SocketOption;
 import java.net.StandardProtocolFamily;
 import java.net.UnknownHostException;
 import java.net.DatagramPacket;
@@ -49,6 +50,7 @@
 import java.nio.channels.Channel;
 import java.nio.channels.DatagramChannel;
 import java.nio.channels.NotYetConnectedException;
+import java.nio.channels.UnsupportedAddressTypeException;
 
 import jnr.constants.platform.AddressFamily;
 import jnr.netdb.Service;
@@ -124,6 +126,7 @@ public IRubyObject initialize(ThreadContext context, ProtocolFamily family) {
         Ruby runtime = context.runtime;
 
         try {
+            this.family = family;
             DatagramChannel channel = DatagramChannel.open(family);
             initSocket(newChannelFD(runtime, channel));
         } catch (ConnectException e) {
@@ -189,6 +192,11 @@ else if (host instanceof RubyFixnum) {
 
             return RubyFixnum.zero(runtime);
         }
+        catch (UnsupportedAddressTypeException e) {
+            // This may not be the appropriate message for all such exceptions
+            ProtocolFamily family = this.family == null ? StandardProtocolFamily.INET : this.family;
+            throw SocketUtils.sockerr(runtime, "bind: unsupported address " + host.inspect() + " for protocol family " + family);
+        }
         catch (UnknownHostException e) {
             throw SocketUtils.sockerr(runtime, "bind: name or service not known");
         }
@@ -634,6 +642,7 @@ private static IRubyObject doReceiveMulticast(RubyBasicSocket socket, final Ruby
     }
 
     private volatile Class<? extends InetAddress> explicitFamily;
+    private volatile ProtocolFamily family;
 
     @Deprecated
     public IRubyObject bind(IRubyObject host, IRubyObject port) {

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
@@ -37,18 +37,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;
     }
@@ -94,7 +101,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);