jruby · Feb 16, 2016 · Feb 16, 2016 · Feb 16, 2016 · Feb 16, 2016 · Feb 16, 2016
diff --git a/.travis.yml b/.travis.yml
@@ -35,8 +35,16 @@ matrix:
   include:
     - env: COMMAND=test/check_versions.sh
       jdk: oraclejdk8
+  allow_failures:
+    - env: PHASE='-Prake -Dtask=test:mri:fullint'
     - env: JT=check_ambiguous_arguments
       jdk: oraclejdk8
+    # NOTE: build seems to never start (waited for any to finish for more than a day) - probably a travis-ci bug
+    #- env: PHASE='-Pmain'
+    #  sudo: required
+    #  dist: trusty
+    #  group: edge
+    #  jdk: oraclejdk9
 
 branches:
   only:

diff --git a/ISSUE_TEMPLATE.md b/ISSUE_TEMPLATE.md
@@ -0,0 +1,34 @@
+<!--
+This is a simple template for filing JRuby isuses.
+
+Please help us help you by providing the information below.
+
+Text inside XML comment tags will not be shown in your report.
+-->
+
+### Environment
+
+<!--
+Provide at least:
+* JRuby version (`jruby -v`) and command line (flags, JRUBY_OPTS, etc)
+* Operating system and platform (e.g. `uname -a`)
+
+Other relevant info you may wish to add:
+* Installed or activated gems
+* Application/framework version (e.g. Rails, Sinatra)
+* Environment variables
+-->
+
+### Expected Behavior
+
+<!--
+Describe your expectation of how JRuby should behave.
+Provide an executable Ruby script or a link to an example repository.
+-->
+
+### Actual Behavior
+
+<!--
+Describe or show the actual behavior.
+Provide text or screen capture showing the behavior.
+-->
diff --git a/core/src/main/java/org/jruby/RubyHash.java b/core/src/main/java/org/jruby/RubyHash.java
@@ -485,6 +485,11 @@ protected static int hashValue(final int h) {
         return MRI_HASH ? MRIHashValue(h) : JavaSoftHashValue(h);
     }
 
+    protected final int hashValue(final IRubyObject key) {
+        final int h = isComparedByIdentity() ? System.identityHashCode(key) : key.hashCode();
+        return MRI_HASH ? MRIHashValue(h) : JavaSoftHashValue(h);
+    }
+
     private static int bucketIndex(final int h, final int length) {
         return MRI_HASH ? MRIBucketIndex(h, length) : JavaSoftBucketIndex(h, length);
     }
@@ -518,7 +523,7 @@ protected void internalPut(final IRubyObject key, final IRubyObject value, final
     }
 
     protected void internalPutSmall(final IRubyObject key, final IRubyObject value, final boolean checkForExisting) {
-        final int hash = hashValue(key.hashCode());
+        final int hash = hashValue(key);
         final int i = bucketIndex(hash, table.length);
 
         // if (table[i] != null) collisions++;
@@ -547,7 +552,7 @@ protected IRubyObject internalGet(IRubyObject key) { // specialized for value
     protected RubyHashEntry internalGetEntry(IRubyObject key) {
         if (size == 0) return NO_ENTRY;
 
-        final int hash = hashValue(key.hashCode());
+        final int hash = hashValue(key);
         for (RubyHashEntry entry = table[bucketIndex(hash, table.length)]; entry != null; entry = entry.next) {
             if (internalKeyExist(entry, hash, key)) {
                 return entry;
@@ -567,12 +572,12 @@ private boolean internalKeyExist(RubyHashEntry entry, int hash, IRubyObject key)
     protected RubyHashEntry internalDelete(final IRubyObject key) {
         if (size == 0) return NO_ENTRY;
 
-        return internalDelete(hashValue(key.hashCode()), MATCH_KEY, key);
+        return internalDelete(hashValue(key), MATCH_KEY, key);
     }
 
     protected RubyHashEntry internalDeleteEntry(final RubyHashEntry entry) {
         // n.b. we need to recompute the hash in case the key object was modified
-        return internalDelete(hashValue(entry.key.hashCode()), MATCH_ENTRY, entry);
+        return internalDelete(hashValue(entry.key), MATCH_ENTRY, entry);
     }
 
     private final RubyHashEntry internalDelete(final int hash, final EntryMatchType matchType, final Object obj) {
@@ -923,7 +928,7 @@ public RubyHash rehash() {
             oldTable[j] = null;
             while (entry != null) {
                 RubyHashEntry next = entry.next;
-                entry.hash = hashValue(entry.key.hashCode()); // update the hash value
+                entry.hash = hashValue(entry.key); // update the hash value
                 int i = bucketIndex(entry.hash, newTable.length);
                 entry.next = newTable[i];
                 newTable[i] = entry;

diff --git a/core/src/main/java/org/jruby/RubyIO.java b/core/src/main/java/org/jruby/RubyIO.java
@@ -2408,8 +2408,6 @@ public IRubyObject ctl(Ruby runtime, IRubyObject cmd, IRubyObject arg) {
         return runtime.newFixnum(0);
     }
 
-    private static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
-
     @JRubyMethod(name = "puts")
     public IRubyObject puts(ThreadContext context) {
         return puts0(context, this);
@@ -3743,13 +3741,13 @@ private void setupPopen(ModeFlags modes, POpenProcess process) throws RaiseExcep
     }
 
     private static class Ruby19POpen {
-        public final RubyString cmd;
-        public final IRubyObject[] cmdPlusArgs;
-        public final RubyHash env;
+        final RubyString cmd;
+        final IRubyObject[] cmdPlusArgs;
+        final RubyHash env;
 
-        public Ruby19POpen(Ruby runtime, IRubyObject[] args) {
-            IRubyObject[] _cmdPlusArgs = null;
-            IRubyObject _env = null;
+        Ruby19POpen(Ruby runtime, IRubyObject[] args) {
+            IRubyObject[] _cmdPlusArgs;
+            IRubyObject _env;
             IRubyObject _cmd;
 
             int firstArg = 0;
@@ -3865,18 +3863,6 @@ public static IRubyObject popen(ThreadContext context, IRubyObject recv, IRubyOb
                 process = ShellLauncher.popen(runtime, r19Popen.cmdPlusArgs, r19Popen.env, modes);
             }
 
-            // Yes, this is gross. java.lang.Process does not appear to be guaranteed
-            // "ready" when we get it back from Runtime#exec, so we try to give it a
-            // chance by waiting for 10ms before we proceed. Only doing this on 1.5
-            // since Hotspot 1.6+ does not seem to exhibit the problem.
-            if (System.getProperty("java.specification.version", "").equals("1.5")) {
-                synchronized (process) {
-                    try {
-                        process.wait(100);
-                    } catch (InterruptedException ie) {}
-                }
-            }
-
             checkPopenOptions(options);
 
             io.setupPopen(modes, process);
@@ -4304,14 +4290,15 @@ protected void interruptBlockingThreads() {
      * @author realjenius
      */
     private static class ByteListCache {
-        private byte[] buffer = EMPTY_BYTE_ARRAY;
-        public void release(ByteList l) {
-            buffer = l.getUnsafeBytes();
+
+        private byte[] buffer = ByteList.NULL_ARRAY;
+
+        final void release(ByteList bytes) {
+            buffer = bytes.getUnsafeBytes();
         }
 
-        public ByteList allocate(int size) {
-            ByteList l = new ByteList(buffer, 0, size, false);
-            return l;
+        final ByteList allocate(int size) {
+            return new ByteList(buffer, 0, size, false);
         }
     }
 

diff --git a/core/src/main/java/org/jruby/RubyKernel.java b/core/src/main/java/org/jruby/RubyKernel.java
@@ -1553,7 +1553,7 @@ public static IRubyObject system19(ThreadContext context, IRubyObject recv, IRub
             if (pid < 0) {
                 return runtime.getNil();
             }
-            status[0] = (int)((RubyProcess.RubyStatus)context.getLastExitStatus()).getStatus();
+            status[0] = (int)((RubyProcess.RubyStatus) context.getLastExitStatus()).getStatus();
             if (status[0] == 0) return runtime.getTrue();
             return runtime.getFalse();
         }
@@ -1582,11 +1582,7 @@ private static int systemCommon(ThreadContext context, IRubyObject recv, IRubyOb
         long[] tuple;
 
         try {
-            IRubyObject lastArg = args[args.length - 1];
-            if (lastArg instanceof RubyHash) {
-                runtime.getWarnings().warn(ID.UNSUPPORTED_SUBPROCESS_OPTION, "system does not support options in JRuby yet: " + lastArg.inspect());
-                args = Arrays.copyOf(args, args.length - 1);
-            }
+            args = dropLastArgIfOptions(runtime, args);
             if (! Platform.IS_WINDOWS && args[args.length -1].asJavaString().matches(".*[^&]&\\s*")) {
                 // looks like we need to send process to the background
                 ShellLauncher.runWithoutWait(runtime, args);
@@ -1599,7 +1595,18 @@ private static int systemCommon(ThreadContext context, IRubyObject recv, IRubyOb
 
         // RubyStatus uses real native status now, so we unshift Java's shifted exit status
         context.setLastExitStatus(RubyProcess.RubyStatus.newProcessStatus(runtime, tuple[0] << 8, tuple[1]));
-        return (int)tuple[0];
+        return (int) tuple[0];
+    }
+
+    private static IRubyObject[] dropLastArgIfOptions(final Ruby runtime, final IRubyObject[] args) {
+        IRubyObject lastArg = args[args.length - 1];
+        if (lastArg instanceof RubyHash) {
+            if (!((RubyHash) lastArg).isEmpty()) {
+                runtime.getWarnings().warn(ID.UNSUPPORTED_SUBPROCESS_OPTION, "system does not support options in JRuby yet: " + lastArg);
+            }
+            return Arrays.copyOf(args, args.length - 1);
+        }
+        return args;
     }
 
     public static IRubyObject exec(ThreadContext context, IRubyObject recv, IRubyObject[] args) {

diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -3649,21 +3649,21 @@ public IRubyObject setConstant(String name, IRubyObject value, boolean hidden) {
      */
     private IRubyObject setConstantCommon(String name, IRubyObject value, boolean hidden, boolean warn) {
         IRubyObject oldValue = fetchConstant(name);
+
+        setParentForModule(name, value);
+
         if (oldValue != null) {
-            if (oldValue == UNDEF) {
-                setAutoloadConstant(name, value);
-            } else {
-                if (warn) {
+            boolean notAutoload = oldValue != UNDEF;
+            if (notAutoload || !setAutoloadConstant(name, value)) {
+                if (warn && notAutoload) {
                     getRuntime().getWarnings().warn(ID.CONSTANT_ALREADY_INITIALIZED, "already initialized constant " + name);
                 }
-                setParentForModule(name, value);
                 // might just call storeConstant(name, value, hidden) but to maintain
                 // backwards compatibility with calling #storeConstant overrides
                 if (hidden) storeConstant(name, value, true);
                 else storeConstant(name, value);
             }
         } else {
-            setParentForModule(name, value);
             if (hidden) storeConstant(name, value, true);
             else storeConstant(name, value);
         }
@@ -4148,6 +4148,7 @@ protected final IRubyObject finishAutoload(String name) {
             storeConstant(name, value);
         }
         removeAutoload(name);
+        invalidateConstantCache(name);
         return value;
     }
 
@@ -4170,17 +4171,14 @@ protected IRubyObject getAutoloadConstant(String name, boolean loadConstant) {
     /**
      * Set an Object as a defined constant in autoloading.
      */
-    private void setAutoloadConstant(String name, IRubyObject value) {
+    private boolean setAutoloadConstant(String name, IRubyObject value) {
         final Autoload autoload = getAutoloadMap().get(name);
         if ( autoload != null ) {
-            if ( ! autoload.setConstant(getRuntime().getCurrentContext(), value) ) {
-                storeConstant(name, value);
-                removeAutoload(name);
-            }
-        }
-        else {
-            storeConstant(name, value);
+            boolean set = autoload.setConstant(getRuntime().getCurrentContext(), value);
+            if ( ! set ) removeAutoload(name);
+            return set;
         }
+        return false;
     }
 
     /**

diff --git a/core/src/main/java/org/jruby/RubyString.java b/core/src/main/java/org/jruby/RubyString.java
@@ -115,7 +115,6 @@ public class RubyString extends RubyObject implements EncodingCapable, MarshalEn
 
     private static final ASCIIEncoding ASCII = ASCIIEncoding.INSTANCE;
     private static final UTF8Encoding UTF8 = UTF8Encoding.INSTANCE;
-    private static final byte[] EMPTY_BYTE_ARRAY = ByteList.NULL_ARRAY;
 
     // string doesn't share any resources
     private static final int SHARE_LEVEL_NONE = 0;
@@ -340,7 +339,7 @@ private boolean eql19(IRubyObject other) {
     }
 
     public RubyString(Ruby runtime, RubyClass rubyClass) {
-        this(runtime, rubyClass, EMPTY_BYTE_ARRAY);
+        this(runtime, rubyClass, ByteList.NULL_ARRAY);
     }
 
     public RubyString(Ruby runtime, RubyClass rubyClass, CharSequence value) {
@@ -593,8 +592,8 @@ public static RubyString newEmptyString(Ruby runtime) {
         return newEmptyString(runtime, runtime.getString());
     }
 
-    private static final ByteList EMPTY_ASCII8BIT_BYTELIST = new ByteList(new byte[0], ASCIIEncoding.INSTANCE);
-    private static final ByteList EMPTY_USASCII_BYTELIST = new ByteList(new byte[0], USASCIIEncoding.INSTANCE);
+    private static final ByteList EMPTY_ASCII8BIT_BYTELIST = new ByteList(ByteList.NULL_ARRAY, ASCIIEncoding.INSTANCE);
+    private static final ByteList EMPTY_USASCII_BYTELIST = new ByteList(ByteList.NULL_ARRAY, USASCIIEncoding.INSTANCE);
 
     public static RubyString newAllocatedString(Ruby runtime, RubyClass metaClass) {
         RubyString empty = new RubyString(runtime, metaClass, EMPTY_ASCII8BIT_BYTELIST);
@@ -4536,14 +4535,14 @@ public IRubyObject squeeze19(ThreadContext context) {
         return str;
     }
 
-    @JRubyMethod(name = "squeeze")
+    @JRubyMethod(name = "squeeze", required = 1)
     public IRubyObject squeeze19(ThreadContext context, IRubyObject arg) {
         RubyString str = strDup(context.runtime);
         str.squeeze_bang19(context, arg);
         return str;
     }
 
-    @JRubyMethod(name = "squeeze", rest = true)
+    @JRubyMethod(name = "squeeze", required = 2, rest = true)
     public IRubyObject squeeze19(ThreadContext context, IRubyObject[] args) {
         RubyString str = strDup(context.runtime);
         str.squeeze_bang19(context, args);
@@ -4552,11 +4551,12 @@ public IRubyObject squeeze19(ThreadContext context, IRubyObject[] args) {
 
     @JRubyMethod(name = "squeeze!")
     public IRubyObject squeeze_bang19(ThreadContext context) {
-        Ruby runtime = context.runtime;
         if (value.getRealSize() == 0) {
             modifyCheck();
-            return runtime.getNil();
+            return context.nil;
         }
+        final Ruby runtime = context.runtime;
+
         final boolean squeeze[] = new boolean[StringSupport.TRANS_SIZE];
         for (int i=0; i< StringSupport.TRANS_SIZE; i++) squeeze[i] = true;
 
@@ -4574,9 +4574,9 @@ public IRubyObject squeeze_bang19(ThreadContext context) {
         return this;
     }
 
-    @JRubyMethod(name = "squeeze!")
+    @JRubyMethod(name = "squeeze!", required = 1)
     public IRubyObject squeeze_bang19(ThreadContext context, IRubyObject arg) {
-        Ruby runtime = context.runtime;
+        final Ruby runtime = context.runtime;
 
         RubyString otherStr = arg.convertToString();
         final boolean squeeze[] = new boolean[StringSupport.TRANS_SIZE + 1];
@@ -4596,29 +4596,29 @@ public IRubyObject squeeze_bang19(ThreadContext context, IRubyObject arg) {
         return this;
     }
 
-    @JRubyMethod(name = "squeeze!", rest = true)
+    @JRubyMethod(name = "squeeze!", rest = true, required = 2)
     public IRubyObject squeeze_bang19(ThreadContext context, IRubyObject[] args) {
-        Ruby runtime = context.runtime;
         if (value.getRealSize() == 0) {
             modifyCheck();
-            return runtime.getNil();
+            return context.nil;
         }
+        final Ruby runtime = context.runtime;
 
         RubyString otherStr = args[0].convertToString();
         Encoding enc = checkEncoding(otherStr);
         final boolean squeeze[] = new boolean[StringSupport.TRANS_SIZE + 1];
         StringSupport.TrTables tables = StringSupport.trSetupTable(otherStr.value, runtime, squeeze, null, true, enc);
 
-        boolean singlebyte = singleByteOptimizable() && otherStr.singleByteOptimizable();
+        boolean singleByte = singleByteOptimizable() && otherStr.singleByteOptimizable();
         for (int i=1; i<args.length; i++) {
             otherStr = args[i].convertToString();
             enc = checkEncoding(otherStr);
-            singlebyte = singlebyte && otherStr.singleByteOptimizable();
+            singleByte = singleByte && otherStr.singleByteOptimizable();
             tables = StringSupport.trSetupTable(otherStr.value, runtime, squeeze, tables, false, enc);
         }
 
         modifyAndKeepCodeRange();
-        if (singlebyte) {
+        if (singleByte) {
             if (! StringSupport.singleByteSqueeze(value, squeeze)) {
                 return runtime.getNil();
             }

diff --git a/core/src/main/java/org/jruby/ext/ripper/StringTerm.java b/core/src/main/java/org/jruby/ext/ripper/StringTerm.java
@@ -55,7 +55,7 @@ public StringTerm(int flags, int begin, int end) {
     }
 
     protected ByteList createByteList(RipperLexer lexer) {
-        return new ByteList(new byte[]{}, lexer.getEncoding());
+        return new ByteList(ByteList.NULL_ARRAY, lexer.getEncoding());
     }
 
     private int endFound(RipperLexer lexer, LexerSource src, ByteList buffer) throws IOException {