jruby · Jan 7, 2016 · Jan 7, 2016 · Jan 7, 2016 · Jan 7, 2016 · Jan 7, 2016
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -5094,8 +5094,8 @@ public FilenoUtil getFilenoUtil() {
     private final Random random;
 
     /** The runtime-local seed for hash randomization */
-    private long hashSeedK0;
-    private long hashSeedK1;
+    private final long hashSeedK0;
+    private final long hashSeedK1;
 
     private StaticScopeFactory staticScopeFactory;
 

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
@@ -159,27 +159,27 @@ public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      * Set a reflective allocator that calls the "standard" Ruby object
      * constructor (Ruby, RubyClass) on the given class.
      *
-     * @param cls The class from which to grab a standard Ruby constructor
+     * @param clazz The class from which to grab a standard Ruby constructor
      */
-    public void setRubyClassAllocator(final Class cls) {
+    public void setRubyClassAllocator(final Class<? extends IRubyObject> clazz) {
         try {
-            final Constructor constructor = cls.getConstructor(Ruby.class, RubyClass.class);
+            final Constructor<? extends IRubyObject> constructor = clazz.getConstructor(Ruby.class, RubyClass.class);
 
             this.allocator = new ObjectAllocator() {
                 public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
                     try {
-                        return (IRubyObject)constructor.newInstance(runtime, klazz);
+                        return constructor.newInstance(runtime, klazz);
                     } catch (InvocationTargetException ite) {
-                        throw runtime.newTypeError("could not allocate " + cls + " with (Ruby, RubyClass) constructor:\n" + ite);
+                        throw runtime.newTypeError("could not allocate " + clazz + " with (Ruby, RubyClass) constructor:\n" + ite);
                     } catch (InstantiationException ie) {
-                        throw runtime.newTypeError("could not allocate " + cls + " with (Ruby, RubyClass) constructor:\n" + ie);
+                        throw runtime.newTypeError("could not allocate " + clazz + " with (Ruby, RubyClass) constructor:\n" + ie);
                     } catch (IllegalAccessException iae) {
-                        throw runtime.newSecurityError("could not allocate " + cls + " due to inaccessible (Ruby, RubyClass) constructor:\n" + iae);
+                        throw runtime.newSecurityError("could not allocate " + clazz + " due to inaccessible (Ruby, RubyClass) constructor:\n" + iae);
                     }
                 }
             };
 
-            this.reifiedClass = cls;
+            this.reifiedClass = clazz;
         } catch (NoSuchMethodException nsme) {
             throw new RuntimeException(nsme);
         }
@@ -190,26 +190,26 @@ public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
      * constructor (Ruby, RubyClass) on the given class via a static
      * __allocate__ method intermediate.
      *
-     * @param cls The class from which to grab a standard Ruby __allocate__
+     * @param clazz The class from which to grab a standard Ruby __allocate__
      *            method.
      */
-    public void setRubyStaticAllocator(final Class cls) {
+    public void setRubyStaticAllocator(final Class<?> clazz) {
         try {
-            final Method method = cls.getDeclaredMethod("__allocate__", Ruby.class, RubyClass.class);
+            final Method method = clazz.getDeclaredMethod("__allocate__", Ruby.class, RubyClass.class);
 
             this.allocator = new ObjectAllocator() {
                 public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
                     try {
-                        return (IRubyObject)method.invoke(null, runtime, klazz);
+                        return (IRubyObject) method.invoke(null, runtime, klazz);
                     } catch (InvocationTargetException ite) {
-                        throw runtime.newTypeError("could not allocate " + cls + " with (Ruby, RubyClass) constructor:\n" + ite);
+                        throw runtime.newTypeError("could not allocate " + clazz + " with (Ruby, RubyClass) constructor:\n" + ite);
                     } catch (IllegalAccessException iae) {
-                        throw runtime.newSecurityError("could not allocate " + cls + " due to inaccessible (Ruby, RubyClass) constructor:\n" + iae);
+                        throw runtime.newSecurityError("could not allocate " + clazz + " due to inaccessible (Ruby, RubyClass) constructor:\n" + iae);
                     }
                 }
             };
 
-            this.reifiedClass = cls;
+            this.reifiedClass = clazz;
         } catch (NoSuchMethodException nsme) {
             throw new RuntimeException(nsme);
         }
@@ -1578,11 +1578,11 @@ public synchronized void reify(String classDumpDir, boolean useChildLoader) {
         }
     }
 
-    public void setReifiedClass(Class newReifiedClass) {
+    public void setReifiedClass(Class<? extends IRubyObject> newReifiedClass) {
         this.reifiedClass = newReifiedClass;
     }
 
-    public Class getReifiedClass() {
+    public Class<? extends IRubyObject> getReifiedClass() {
         return reifiedClass;
     }
 

diff --git a/core/src/main/java/org/jruby/RubyInstanceConfig.java b/core/src/main/java/org/jruby/RubyInstanceConfig.java
@@ -59,7 +59,6 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.PrintStream;
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
@@ -114,12 +113,7 @@ public RubyInstanceConfig() {
 
         threadDumpSignal = Options.THREAD_DUMP_SIGNAL.load();
 
-        environment = new HashMap<String,String>();
-        try {
-            environment.putAll(System.getenv());
-        } catch (SecurityException se) {
-        }
-        setupEnvironment(getJRubyHome());
+        initEnvironment();
     }
 
     public RubyInstanceConfig(RubyInstanceConfig parentConfig) {
@@ -141,11 +135,15 @@ public RubyInstanceConfig(RubyInstanceConfig parentConfig) {
         profilingService = parentConfig.profilingService;
         profilingMode = parentConfig.profilingMode;
 
-        environment = new HashMap<String, String>();
+        initEnvironment();
+    }
+
+    private void initEnvironment() {
+        environment = new HashMap<String,String>();
         try {
             environment.putAll(System.getenv());
-        } catch (SecurityException se) {
         }
+        catch (SecurityException se) { /* ignore missing getenv permission */ }
         setupEnvironment(getJRubyHome());
     }
 
@@ -1611,15 +1609,6 @@ public boolean shouldPrecompileAll() {
     // Static configuration fields, used as defaults for new JRuby instances.
     ////////////////////////////////////////////////////////////////////////////
 
-    // NOTE: These BigDecimal fields must be initialized before calls to initGlobalJavaVersion
-
-    /** A BigDecimal representing 1.5, for Java spec version matching */
-    private static final BigDecimal BIGDECIMAL_1_5 = new BigDecimal("1.5");
-    /** A BigDecimal representing 1.6, for Java spec version matching */
-    private static final BigDecimal BIGDECIMAL_1_6 = new BigDecimal("1.6");
-    /** A BigDecimal representing 1.7, for Java spec version matching */
-    private static final BigDecimal BIGDECIMAL_1_7 = new BigDecimal("1.7");
-
     /**
      * The version to use for generated classes. Set to current JVM version by default
      */
@@ -1853,19 +1842,16 @@ public boolean shouldPrecompileAll() {
     ////////////////////////////////////////////////////////////////////////////
 
     private static int initGlobalJavaVersion() {
-        String specVersion = Options.BYTECODE_VERSION.load();
-
-        // stack map calculation is failing for some compilation scenarios, so
-        // forcing both 1.5 and 1.6 to use 1.5 bytecode for the moment.
-        if (specVersion.equals("1.5")) {// || specVersion.equals("1.6")) {
-           return Opcodes.V1_5;
-        } else if (specVersion.equals("1.6")) {
-            return Opcodes.V1_6;
-        } else if (specVersion.equals("1.7") || specVersion.equals("1.8") || specVersion.equals("1.9") || specVersion.equals("9")) {
-            return Opcodes.V1_7;
-        } else {
-            System.err.println("unsupported Java version \"" + specVersion + "\", defaulting to 1.5");
-            return Opcodes.V1_5;
+        final String specVersion = Options.BYTECODE_VERSION.load();
+        switch ( specVersion ) {
+            case "1.6" : return Opcodes.V1_6;
+            case "1.7" : return Opcodes.V1_7;
+            case "1.8" : return Opcodes.V1_8;
+            // NOTE: JDK 9 now returns "9" instead of "1.9"
+            case "1.9" : case "9" : return Opcodes.V1_8; // +1
+            default :
+                System.err.println("unsupported Java version \"" + specVersion + "\", defaulting to 1.7");
+                return Opcodes.V1_7;
         }
     }
 

diff --git a/core/src/main/java/org/jruby/ast/executable/RuntimeCache.java b/core/src/main/java/org/jruby/ast/executable/RuntimeCache.java
@@ -425,6 +425,44 @@ private DynamicMethod cacheAndGet(ThreadContext context, RubyClass selfType, int
         return method;
     }
 
+    private DynamicMethod searchWithCacheNoMethodMissing(RubyClass clazz, int index, String name1) {
+        CacheEntry entry = clazz.searchWithCache(name1);
+        DynamicMethod method = entry.method;
+        if (entry.method == UndefinedMethod.INSTANCE) {
+            return null;
+        }
+        methodCache[index] = entry;
+        return method;
+    }
+
+    private DynamicMethod searchWithCacheNoMethodMissing(RubyClass clazz, int index, String name1, String name2) {
+        CacheEntry entry = clazz.searchWithCache(name1);
+        DynamicMethod method = entry.method;
+        if (entry.method == UndefinedMethod.INSTANCE) {
+            return searchWithCacheNoMethodMissing(clazz, index, name2);
+        }
+        methodCache[index] = entry;
+        return method;
+    }
+
+    // used from byte-code generated by RealClassGenerator
+    public final DynamicMethod searchWithCacheNoMethodMissing(IRubyObject obj, int index, String name1) {
+        CacheEntry myCache = getCacheEntry(index);
+        if (CacheEntry.typeOk(myCache, obj.getMetaClass())) {
+            return myCache.method;
+        }
+        return searchWithCacheNoMethodMissing(obj.getMetaClass(), index, name1);
+    }
+
+    // used from byte-code generated by RealClassGenerator
+    public final DynamicMethod searchWithCacheNoMethodMissing(IRubyObject obj, int index, String name1, String name2) {
+        CacheEntry myCache = getCacheEntry(index);
+        if (CacheEntry.typeOk(myCache, obj.getMetaClass())) {
+            return myCache.method;
+        }
+        return searchWithCacheNoMethodMissing(obj.getMetaClass(), index, name1, name2);
+    }
+
     public DynamicMethod searchWithCache(RubyClass clazz, int index, String name1) {
         CacheEntry entry = clazz.searchWithCache(name1);
         DynamicMethod method = entry.method;

diff --git a/core/src/main/java/org/jruby/compiler/JITCompiler.java b/core/src/main/java/org/jruby/compiler/JITCompiler.java
@@ -418,8 +418,8 @@ public MethodJITClassGenerator(String className, String methodName, String key,
             } else {
                 digestString = key;
             }
-            this.className = packageName + "/" + className.replace('.', '/') + CLASS_METHOD_DELIMITER + JavaNameMangler.mangleMethodName(methodName) + "_" + digestString;
-            this.name = this.className.replaceAll("/", ".");
+            this.className = packageName + '/' + className.replace('.', '/') + CLASS_METHOD_DELIMITER + JavaNameMangler.mangleMethodName(methodName) + '_' + digestString;
+            this.name = this.className.replace('/', '.');
             this.methodName = methodName;
             this.method = method;
             this.visitor = visitor;