review (cleanup) boot -> standard JRuby extension loading

core/src/main/java/org/jruby/Ruby.java

@@ -1717,7 +1717,6 @@ private void initBuiltins() {
         addLazyBuiltin("java.rb", "java", "org.jruby.javasupport.Java");
         addLazyBuiltin("jruby.rb", "jruby", "org.jruby.ext.jruby.JRubyLibrary");
         addLazyBuiltin("jruby/util.rb", "jruby/util", "org.jruby.ext.jruby.JRubyUtilLibrary");
-        addLazyBuiltin("jruby/type.rb", "jruby/type", "org.jruby.ext.jruby.JRubyTypeLibrary");
         addLazyBuiltin("nkf.jar", "nkf", "org.jruby.ext.nkf.NKFLibrary");
         addLazyBuiltin("stringio.jar", "stringio", "org.jruby.ext.stringio.StringIOLibrary");
         addLazyBuiltin("strscan.jar", "strscan", "org.jruby.ext.strscan.StringScannerLibrary");
@@ -1741,7 +1740,7 @@ private void initBuiltins() {
         addLazyBuiltin("pathname.jar", "pathname", "org.jruby.ext.pathname.PathnameLibrary");
         addLazyBuiltin("set.rb", "set", "org.jruby.ext.set.SetLibrary");
         addLazyBuiltin("date.jar", "date", "org.jruby.ext.date.DateLibrary");
-
+        addLazyBuiltin("securerandom.jar", "securerandom", "org.jruby.ext.securerandom.SecureRandomLibrary");
         addLazyBuiltin("mathn/complex.jar", "mathn/complex", "org.jruby.ext.mathn.Complex");
         addLazyBuiltin("mathn/rational.jar", "mathn/rational", "org.jruby.ext.mathn.Rational");
         addLazyBuiltin("ripper.jar", "ripper", "org.jruby.ext.ripper.RipperLibrary");

core/src/main/java/org/jruby/RubyArray.java

@@ -1149,30 +1149,31 @@ public RubyArray aryDup() {
      */
     @JRubyMethod(name = "transpose")
     public RubyArray transpose() {
-        RubyArray tmp, result = null;
 
         int alen = realLength;
         if (alen == 0) return aryDup();
 
         Ruby runtime = getRuntime();
+
         int elen = -1;
+        RubyArray[] result = null;
         for (int i = 0; i < alen; i++) {
-            tmp = elt(i).convertToArray();
+            RubyArray tmp = elt(i).convertToArray();
             if (elen < 0) {
                 elen = tmp.realLength;
-                result = newBlankArray(runtime, elen);
+                result = new RubyArray[elen];
                 for (int j = 0; j < elen; j++) {
-                    result.store(j, newBlankArray(runtime, alen));
+                    result[j] = newBlankArray(runtime, alen);
                 }
             } else if (elen != tmp.realLength) {
                 throw runtime.newIndexError("element size differs (" + tmp.realLength
                         + " should be " + elen + ")");
             }
             for (int j = 0; j < elen; j++) {
-                ((RubyArray) result.elt(j)).store(i, tmp.elt(j));
+                result[j].store(i, tmp.elt(j));
             }
         }
-        return result;
+        return new RubyArray(runtime, result);
     }
 
     /** rb_values_at (internal)
@@ -3861,10 +3862,10 @@ public IRubyObject product(ThreadContext context, IRubyObject[] args, Block bloc
             }
         }
 
-        RubyArray result = useBlock ? null : newBlankArray(runtime, resultLen);
+        RubyArray result = useBlock ? null : newBlankArrayInternal(runtime, resultLen);
 
         for (int i = 0; i < resultLen; i++) {
-            RubyArray sub = newBlankArray(runtime, n);
+            RubyArray sub = newBlankArrayInternal(runtime, n);
             for (int j = 0; j < n; j++) sub.store(j, arrays[j].entry(counters[j]));
 
             if (useBlock) {
@@ -4052,7 +4053,7 @@ private static void permute(ThreadContext context, int n, int r, int[] p, boolea
     }
 
     private static void yieldValues(ThreadContext context, int r, int[] p, int pStart, RubyArray values, Block block) {
-        RubyArray result = newBlankArray(context.runtime, r);
+        RubyArray result = newBlankArrayInternal(context.runtime, r);
 
         for (int j = 0; j < r; j++) {
             result.store(j, values.eltInternal(p[j + pStart]));
@@ -4763,6 +4764,22 @@ public static RubyArray newBlankArray(Ruby runtime, int size) {
         return newArray(runtime, size);
     }
 
+    // when caller is sure to set all elements (avoids nil elements initialization)
+    static RubyArray newBlankArrayInternal(Ruby runtime, int size) {
+        switch (size) {
+            case 0:
+                return newEmptyArray(runtime);
+            case 1:
+                if (USE_PACKED_ARRAYS) return new RubyArrayOneObject(runtime, null);
+                break;
+            case 2:
+                if (USE_PACKED_ARRAYS) return new RubyArrayTwoObject(runtime, null, null);
+                break;
+        }
+
+        return new RubyArray(runtime, size);
+    }
+
     @JRubyMethod(name = "try_convert", meta = true)
     public static IRubyObject try_convert(ThreadContext context, IRubyObject self, IRubyObject arg) {
         return arg.checkArrayType();

core/src/main/java/org/jruby/RubyHash.java

@@ -1957,7 +1957,7 @@ public void visit(ThreadContext context, RubyHash self, IRubyObject key, IRubyOb
      */
     @JRubyMethod(name = "values_at", rest = true)
     public RubyArray values_at(ThreadContext context, IRubyObject[] args) {
-        RubyArray result = RubyArray.newBlankArray(context.runtime, args.length);
+        RubyArray result = RubyArray.newBlankArrayInternal(context.runtime, args.length);
         for (int i = 0; i < args.length; i++) {
             result.store(i, op_aref(context, args[i]));
         }
@@ -1966,8 +1966,7 @@ public RubyArray values_at(ThreadContext context, IRubyObject[] args) {
 
     @JRubyMethod(name = "fetch_values", rest = true)
     public RubyArray fetch_values(ThreadContext context, IRubyObject[] args, Block block) {
-        RubyArray result = RubyArray.newBlankArray(context.runtime, args.length);
-
+        RubyArray result = RubyArray.newBlankArrayInternal(context.runtime, args.length);
         for (int i = 0; i < args.length; i++) {
             result.store(i, fetch(context, args[i], block));
         }

core/src/main/java/org/jruby/RubyKernel.java

@@ -1101,8 +1101,7 @@ public static IRubyObject caller(ThreadContext context, IRubyObject recv, IRubyO
     }
 
     private static IRubyObject callerInternal(ThreadContext context, IRubyObject recv, IRubyObject level, IRubyObject length) {
-        Ruby runtime = context.runtime;
-        Integer[] ll = levelAndLengthFromArgs(runtime, level, length, 1);
+        Integer[] ll = levelAndLengthFromArgs(context, level, length, 1);
         Integer levelInt = ll[0], lengthInt = ll[1];
 
         return context.createCallerBacktrace(levelInt, lengthInt, Thread.currentThread().getStackTrace());
@@ -1124,8 +1123,7 @@ public static IRubyObject caller_locations(ThreadContext context, IRubyObject re
     }
 
     private static IRubyObject callerLocationsInternal(ThreadContext context, IRubyObject level, IRubyObject length) {
-        Ruby runtime = context.runtime;
-        Integer[] ll = levelAndLengthFromArgs(runtime, level, length, 1);
+        Integer[] ll = levelAndLengthFromArgs(context, level, length, 1);
         Integer levelInt = ll[0], lengthInt = ll[1];
 
         return context.createCallerLocations(levelInt, lengthInt, Thread.currentThread().getStackTrace());
@@ -1134,20 +1132,17 @@ private static IRubyObject callerLocationsInternal(ThreadContext context, IRubyO
     /**
      * Retrieve the level and length from given args, if non-null.
      */
-    static Integer[] levelAndLengthFromArgs(Ruby runtime, IRubyObject _level, IRubyObject _length, int defaultLevel) {
+    static Integer[] levelAndLengthFromArgs(ThreadContext context, IRubyObject _level, IRubyObject _length, int defaultLevel) {
         int level;
         Integer length = null;
         if (_length != null) {
             level = RubyNumeric.fix2int(_level);
             length = RubyNumeric.fix2int(_length);
         } else if (_level != null && _level instanceof RubyRange) {
             RubyRange range = (RubyRange) _level;
-            ThreadContext context = runtime.getCurrentContext();
             level = RubyNumeric.fix2int(range.first(context));
             length = RubyNumeric.fix2int(range.last(context)) - level;
-            if (!range.exclude_end_p().isTrue()){
-                length++;
-            }
+            if (!range.isExcludeEnd()) length++;
             length = length < 0 ? 0 : length;
         } else if (_level != null) {
             level = RubyNumeric.fix2int(_level);
@@ -1156,10 +1151,10 @@ static Integer[] levelAndLengthFromArgs(Ruby runtime, IRubyObject _level, IRubyO
         }
 
         if (level < 0) {
-            throw runtime.newArgumentError("negative level (" + level + ')');
+            throw context.runtime.newArgumentError("negative level (" + level + ')');
         }
         if (length != null && length < 0) {
-            throw runtime.newArgumentError("negative size (" + length + ')');
+            throw context.runtime.newArgumentError("negative size (" + length + ')');
         }
 
         return new Integer[] {level, length};

core/src/main/java/org/jruby/RubyLoadError.java

@@ -43,7 +43,7 @@ protected RubyLoadError(Ruby runtime, RubyClass exceptionClass) {
 
     static RubyClass define(Ruby runtime, RubyClass exceptionClass) {
         RubyClass LoadErrorClass = runtime.defineClass("LoadError", exceptionClass, (r, klass) -> new RubyLoadError(runtime, klass));
-
+        LoadErrorClass.addReadAttribute(runtime.getCurrentContext(), "path");
         return LoadErrorClass;
     }
 

core/src/main/java/org/jruby/RubyRegexp.java

@@ -1492,11 +1492,10 @@ public IRubyObject named_captures(ThreadContext context) {
         for (Iterator<NameEntry> i = pattern.namedBackrefIterator(); i.hasNext();) {
             NameEntry e = i.next();
             int[] backrefs = e.getBackRefs();
-            RubyArray ary = RubyArray.newBlankArray(runtime, backrefs.length);
+            RubyArray ary = RubyArray.newBlankArrayInternal(runtime, backrefs.length);
 
-            int index = 0;
-            for (int backref : backrefs) {
-                ary.store(index++, RubyFixnum.newFixnum(runtime, backref));
+            for (int idx = 0; idx<backrefs.length; idx++) {
+                ary.store(idx, RubyFixnum.newFixnum(runtime, backrefs[idx]));
             }
             RubyString name = RubyString.newStringShared(runtime, e.name, e.nameP, e.nameEnd - e.nameP);
             hash.fastASet(name.freeze(context), ary);

core/src/main/java/org/jruby/RubySignal.java

@@ -42,13 +42,13 @@
 
 @JRubyModule(name="Signal")
 public class RubySignal {
-    private final static SignalFacade SIGNALS = getSignalFacade();
 
-    private final static SignalFacade getSignalFacade() {
+    private final static SignalFacade SIGNAL_FACADE = initSignalFacade();
+
+    private final static SignalFacade initSignalFacade() {
         try {
-            Class realFacadeClass = Class.forName("org.jruby.util.SunSignalFacade");
-            return (SignalFacade)realFacadeClass.newInstance();
-        } catch(Throwable e) {
+            return org.jruby.util.SunSignalFacade.class.newInstance();
+        } catch (Throwable e) {
             return new NoFunctionalitySignalFacade();
         }
     }
@@ -72,24 +72,24 @@ public static void createSignal(Ruby runtime) {
     }
 
     public static Map<String, Integer> list() {
-        Map<String, Integer> signals = new HashMap<String, Integer>();
+        Map<String, Integer> signals = new HashMap<>();
 
         for (Signal s : Signal.values()) {
-            if (!s.description().startsWith(SIGNAME_PREFIX))
-                continue;
-            if (!RUBY_18_SIGNALS.contains(signmWithoutPrefix(s.description())))
-                continue;
+            String desc = s.description();
+            if (!desc.startsWith(SIGNAME_PREFIX)) continue;
+
+            desc = signmWithoutPrefix(desc);
+            if (!SIGNAME(desc)) continue;
 
             // replace CLD with CHLD value
             int signo = s.intValue();
             if (s == Signal.SIGCLD)
                 signo = Signal.SIGCHLD.intValue();
 
             // omit unsupported signals
-            if (signo >= 20000)
-                continue;
+            if (signo >= 20000) continue;
 
-            signals.put(signmWithoutPrefix(s.description()), signo);
+            signals.put(desc, signo);
         }
 
         return signals;
@@ -119,22 +119,22 @@ public static IRubyObject list(ThreadContext context, IRubyObject recv) {
 
     @JRubyMethod(required = 2, meta = true)
     public static IRubyObject __jtrap_kernel(final IRubyObject recv, IRubyObject block, IRubyObject sig) {
-        return SIGNALS.trap(recv, block, sig);
+        return SIGNAL_FACADE.trap(recv, block, sig);
     }
 
     @JRubyMethod(required = 1, meta = true)
     public static IRubyObject __jtrap_platform_kernel(final IRubyObject recv, IRubyObject sig) {
-        return SIGNALS.restorePlatformDefault(recv, sig);
+        return SIGNAL_FACADE.restorePlatformDefault(recv, sig);
     }
 
     @JRubyMethod(required = 1, meta = true)
     public static IRubyObject __jtrap_osdefault_kernel(final IRubyObject recv, IRubyObject sig) {
-        return SIGNALS.restoreOSDefault(recv, sig);
+        return SIGNAL_FACADE.restoreOSDefault(recv, sig);
     }
 
     @JRubyMethod(required = 1, meta = true)
     public static IRubyObject __jtrap_restore_kernel(final IRubyObject recv, IRubyObject sig) {
-        return SIGNALS.ignore(recv, sig);
+        return SIGNAL_FACADE.ignore(recv, sig);
     }
 
     @JRubyMethod(required = 1, meta = true)
@@ -177,58 +177,58 @@ public static String signmWithoutPrefix(String nm) {
         return (nm.startsWith(SIGNAME_PREFIX)) ? nm.substring(SIGNAME_PREFIX.length()) : nm;
     }
 
-    private static final Set<String> RUBY_18_SIGNALS;
-    static {
-        RUBY_18_SIGNALS = new HashSet<String>();
-        for (String name : new String[] {
-                "EXIT",
-                "HUP",
-                "INT",
-                "QUIT",
-                "ILL",
-                "TRAP",
-                "IOT",
-                "ABRT",
-                "EMT",
-                "FPE",
-                "KILL",
-                "BUS",
-                "SEGV",
-                "SYS",
-                "PIPE",
-                "ALRM",
-                "TERM",
-                "URG",
-                "STOP",
-                "TSTP",
-                "CONT",
-                "CHLD",
-                "CLD",
-                "TTIN",
-                "TTOU",
-                "IO",
-                "XCPU",
-                "XFSZ",
-                "VTALRM",
-                "PROF",
-                "WINCH",
-                "USR1",
-                "USR2",
-                "LOST",
-                "MSG",
-                "PWR",
-                "POLL",
-                "DANGER",
-                "MIGRATE",
-                "PRE",
-                "GRANT",
-                "RETRACT",
-                "SOUND",
-                "INFO",
-        }) {
-            RUBY_18_SIGNALS.add(name);
+    private static boolean SIGNAME(final String name) {
+        switch (name) {
+            case "EXIT":
+            case "HUP" :
+            case "INT" :
+            case "QUIT":
+            case "ILL" :
+            case "TRAP":
+            case "IOT" :
+            case "ABRT":
+            case "EMT" :
+            case "FPE" :
+            case "KILL":
+            case "BUS" :
+            case "SEGV":
+            case "SYS" :
+            case "PIPE":
+            case "ALRM":
+            case "TERM":
+            case "URG" :
+            case "STOP":
+            case "TSTP":
+            case "CONT":
+            case "CHLD":
+            case "CLD" :
+            case "TTIN":
+            case "TTOU":
+            case "IO"  :
+            case "XCPU":
+            case "XFSZ":
+            case "PROF":
+            case "VTALRM":
+            case "WINCH":
+            case "USR1":
+            case "USR2":
+            case "LOST":
+            case "MSG" :
+            case "PWR" :
+            case "POLL":
+            case "DANGER":
+            case "MIGRATE":
+            case "PRE" :
+            case "GRANT":
+            case "RETRACT":
+            case "SOUND":
+            case "INFO":
+                return true;
+            default:
+                return false;
         }
     }
 
     private static final String SIGNAME_PREFIX = "SIG";
-}// RubySignal
+
+}