jruby · Apr 4, 2016 · Apr 4, 2016
diff --git a/core/src/main/java/org/jruby/ir/IRBuilder.java b/core/src/main/java/org/jruby/ir/IRBuilder.java
@@ -4,7 +4,6 @@
 import org.jcodings.specific.USASCIIEncoding;
 import org.jruby.Ruby;
 import org.jruby.RubyInstanceConfig;
-import org.jruby.RubyString;
 import org.jruby.ast.*;
 import org.jruby.ast.types.INameNode;
 import org.jruby.compiler.NotCompilableException;
@@ -1337,52 +1336,26 @@ private Operand putConstantAssignment(OpAsgnConstDeclNode node, Operand value) {
         return putConstant((Colon3Node) constNode, value);
     }
 
-    private void genInheritanceSearchInstrs(Operand startingModule, Variable constVal, Label foundLabel, boolean noPrivateConstants, String name) {
-        addInstr(new InheritanceSearchConstInstr(constVal, startingModule, name, noPrivateConstants));
-        addInstr(BNEInstr.create(foundLabel, constVal, UndefinedValue.UNDEFINED));
-        addInstr(new ConstMissingInstr(constVal, startingModule, name, scope.maybeUsingRefinements()));
-        addInstr(new LabelInstr(foundLabel));
+    private Operand searchModuleForConst(Operand startingModule, String name) {
+        return addResultInstr(new SearchModuleForConstInstr(createTemporaryVariable(), startingModule, name, true));
     }
 
-    private Operand searchConstInInheritanceHierarchy(Operand startingModule, String name) {
-        Variable constVal = createTemporaryVariable();
-        genInheritanceSearchInstrs(startingModule, constVal, getNewLabel(), true, name);
-        return constVal;
+    private Operand searchConst(String name) {
+        return addResultInstr(new SearchConstInstr(createTemporaryVariable(), name, startingSearchScope(), false));
     }
 
-    private Operand searchConst(String name) {
-        final boolean noPrivateConstants = false;
-        Variable v = createTemporaryVariable();
-/**
- * SSS FIXME: Went back to a single instruction for now.
- *
- * Do not split search into lexical-search, inheritance-search, and const-missing instrs.
- *
-        Label foundLabel = getNewLabel();
-        addInstr(new LexicalSearchConstInstr(v, startingSearchScope(s), name));
-        addInstr(BNEInstr.create(v, UndefinedValue.UNDEFINED, foundLabel));
-        genInheritanceSearchInstrs(s, findContainerModule(startingScope), v, foundLabel, noPrivateConstants, name);
-**/
-        addInstr(new SearchConstInstr(v, name, startingSearchScope(), noPrivateConstants));
-        return v;
-    }
-
-    public Operand buildColon2(final Colon2Node iVisited) {
-        Node leftNode = iVisited.getLeftNode();
-        final String name = iVisited.getName();
-
-        // Colon2ImplicitNode
-        if (leftNode == null) return searchConst(name);
-
-        // Colon2ConstNode
-        // 1. Load the module first (lhs of node)
-        // 2. Then load the constant from the module
-        Operand module = build(leftNode);
-        return searchConstInInheritanceHierarchy(module, name);
+    public Operand buildColon2(final Colon2Node colon2) {
+        Node lhs = colon2.getLeftNode();
+
+        // Colon2ImplicitNode - (module|class) Foo.  Weird, but it is a wrinkle of AST inheritance.
+        if (lhs == null) return searchConst(colon2.getName());
+
+        // Colon2ConstNode (Left::name)
+        return searchModuleForConst(build(lhs), colon2.getName());
     }
 
     public Operand buildColon3(Colon3Node node) {
-        return searchConstInInheritanceHierarchy(new ObjectClass(), node.getName());
+        return searchModuleForConst(new ObjectClass(), node.getName());
     }
 
     public Operand buildComplex(ComplexNode node) {

diff --git a/core/src/main/java/org/jruby/ir/IRVisitor.java b/core/src/main/java/org/jruby/ir/IRVisitor.java
@@ -124,6 +124,7 @@ private void error(Object object) {
     public void RuntimeHelperCall(RuntimeHelperCall runtimehelpercall) { error(runtimehelpercall); }
     public void SaveBindingVisibilityInstr(SaveBindingVisibilityInstr instr) { error(instr); }
     public void SearchConstInstr(SearchConstInstr searchconstinstr) { error(searchconstinstr); }
+    public void SearchModuleForConstInstr(SearchModuleForConstInstr searchconstinstr) { error(searchconstinstr); }
     public void SetCapturedVarInstr(SetCapturedVarInstr instr) { error(instr); }
     public void StoreLocalVarInstr(StoreLocalVarInstr storelocalvarinstr) { error(storelocalvarinstr); }
     public void ThreadPollInstr(ThreadPollInstr threadpollinstr) { error(threadpollinstr); }

diff --git a/core/src/main/java/org/jruby/ir/Operation.java b/core/src/main/java/org/jruby/ir/Operation.java
@@ -120,6 +120,7 @@ public enum Operation {
     INHERITANCE_SEARCH_CONST(OpFlags.f_can_raise_exception),
     CONST_MISSING(OpFlags.f_can_raise_exception),
     SEARCH_CONST(OpFlags.f_can_raise_exception),
+    SEARCH_MODULE_FOR_CONST(OpFlags.f_can_raise_exception),
 
     GET_GLOBAL_VAR(OpFlags.f_is_load),
     GET_FIELD(OpFlags.f_is_load),

diff --git a/core/src/main/java/org/jruby/ir/instructions/SearchModuleForConstInstr.java b/core/src/main/java/org/jruby/ir/instructions/SearchModuleForConstInstr.java
@@ -0,0 +1,106 @@
+package org.jruby.ir.instructions;
+
+import org.jruby.Ruby;
+import org.jruby.RubyModule;
+import org.jruby.ir.IRVisitor;
+import org.jruby.ir.Operation;
+import org.jruby.ir.operands.Operand;
+import org.jruby.ir.operands.UndefinedValue;
+import org.jruby.ir.operands.Variable;
+import org.jruby.ir.persistence.IRReaderDecoder;
+import org.jruby.ir.persistence.IRWriterEncoder;
+import org.jruby.ir.transformations.inlining.CloneInfo;
+import org.jruby.parser.StaticScope;
+import org.jruby.runtime.DynamicScope;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.opto.ConstantCache;
+import org.jruby.runtime.opto.Invalidator;
+
+/**
+ * Search for a constant within the current module.  If it cannot find then
+ * call const_missing.
+ */
+public class SearchModuleForConstInstr extends OneOperandResultBaseInstr implements FixedArityInstr {
+    String   constName;
+    private final boolean  noPrivateConsts;
+
+    // Constant caching
+    private volatile transient ConstantCache cache;
+
+    public SearchModuleForConstInstr(Variable result, Operand currentModule, String constName, boolean noPrivateConsts) {
+        super(Operation.SEARCH_MODULE_FOR_CONST, result, currentModule);
+
+        this.constName = constName;
+        this.noPrivateConsts = noPrivateConsts;
+    }
+
+    public Operand getCurrentModule() {
+        return getOperand1();
+    }
+
+    public String getConstName() {
+        return constName;
+    }
+
+    public boolean isNoPrivateConsts() {
+        return noPrivateConsts;
+    }
+
+    @Override
+    public Instr clone(CloneInfo ii) {
+        return new InheritanceSearchConstInstr(ii.getRenamedVariable(result),
+                getCurrentModule().cloneForInlining(ii), constName, noPrivateConsts);
+    }
+
+    @Override
+    public String[] toStringNonOperandArgs() {
+        return new String[] { "name: " + constName, "no_priv: " + noPrivateConsts};
+    }
+
+    private Object cache(Ruby runtime, RubyModule module) {
+        Object constant = noPrivateConsts ? module.getConstantFromNoConstMissing(constName, false) : module.getConstantNoConstMissing(constName);
+        if (constant == null) {
+            constant = UndefinedValue.UNDEFINED;
+        } else {
+            // recache
+            Invalidator invalidator = runtime.getConstantInvalidator(constName);
+            cache = new ConstantCache((IRubyObject)constant, invalidator.getData(), invalidator, module.hashCode());
+        }
+        return constant;
+    }
+
+    @Override
+    public void encode(IRWriterEncoder e) {
+        super.encode(e);
+        e.encode(getCurrentModule());
+        e.encode(getConstName());
+        e.encode(isNoPrivateConsts());
+    }
+
+    public static SearchModuleForConstInstr decode(IRReaderDecoder d) {
+        return new SearchModuleForConstInstr(d.decodeVariable(), d.decodeOperand(), d.decodeString(), d.decodeBoolean());
+    }
+
+    @Override
+    public Object interpret(ThreadContext context, StaticScope currScope, DynamicScope currDynScope, IRubyObject self, Object[] temp) {
+        Object cmVal = getCurrentModule().retrieve(context, self, currScope, currDynScope, temp);
+
+        if (!(cmVal instanceof RubyModule)) throw context.runtime.newTypeError(cmVal + " is not a type/class");
+
+        RubyModule module = (RubyModule) cmVal;
+        ConstantCache cache = this.cache;
+        Object result = !ConstantCache.isCachedFrom(module, cache) ? cache(context.runtime, module) : cache.value;
+
+        if (result == UndefinedValue.UNDEFINED) {
+            result = module.callMethod(context, "const_missing", context.runtime.fastNewSymbol(constName));
+        }
+
+        return result;
+    }
+
+    @Override
+    public void visit(IRVisitor visitor) {
+        visitor.SearchModuleForConstInstr(this);
+    }
+}
diff --git a/core/src/main/java/org/jruby/ir/persistence/IRReaderStream.java b/core/src/main/java/org/jruby/ir/persistence/IRReaderStream.java
@@ -279,6 +279,7 @@ public Instr decodeInstr() {
             case RETURN_OR_RETHROW_SAVED_EXC: return ReturnOrRethrowSavedExcInstr.decode(this);
             case RUNTIME_HELPER: return RuntimeHelperCall.decode(this);
             case SEARCH_CONST: return SearchConstInstr.decode(this);
+            case SEARCH_MODULE_FOR_CONST: return SearchModuleForConstInstr.decode(this);
             case SET_CAPTURED_VAR: return SetCapturedVarInstr.decode(this);
             case TRACE: return TraceInstr.decode(this);
             case THREAD_POLL: return ThreadPollInstr.decode(this);

diff --git a/core/src/main/java/org/jruby/ir/targets/ConstantLookupSite.java b/core/src/main/java/org/jruby/ir/targets/ConstantLookupSite.java
@@ -98,6 +98,38 @@ public IRubyObject searchConst(ThreadContext context, StaticScope staticScope) {
         return constant;
     }
 
+    public IRubyObject searchModuleForConst(ThreadContext context, RubyModule module) {
+        // Lexical lookup
+        Ruby runtime = context.getRuntime();
+        IRubyObject constant = publicOnly ? module.getConstantFromNoConstMissing(name, false) : module.getConstantNoConstMissing(name);
+
+        // Call const_missing or cache
+        if (constant == null) {
+            return module.callMethod(context, "const_missing", context.runtime.fastNewSymbol(name));
+        }
+
+        SwitchPoint switchPoint = (SwitchPoint) runtime.getConstantInvalidator(name).getData();
+
+        // bind constant until invalidated
+        MethodHandle target = Binder.from(type())
+                .drop(0, 2)
+                .constant(constant);
+        MethodHandle fallback = getTarget();
+        if (fallback == null) {
+            fallback = Binder.from(type())
+                    .insert(0, this)
+                    .invokeVirtualQuiet(Bootstrap.LOOKUP, "searchConst");
+        }
+
+        setTarget(switchPoint.guardWithTest(target, fallback));
+
+        if (Options.INVOKEDYNAMIC_LOG_CONSTANTS.load()) {
+            LOG.info(name + "\tretrieved and cached from module " + module);// + " added to PIC" + extractSourceInfo(site));
+        }
+
+        return constant;
+    }
+
     public IRubyObject inheritanceSearchConst(ThreadContext context, IRubyObject cmVal) {
         Ruby runtime = context.runtime;
         RubyModule module;

diff --git a/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter.java b/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter.java
@@ -466,6 +466,17 @@ public org.objectweb.asm.Label newLabel() {
      */
     public abstract void searchConst(String name, boolean noPrivateConsts);
 
+
+    /**
+     * Lookup a constant from current module.
+     *
+     * Stack required: context, static scope
+     *
+     * @param name name of the constant
+     * @param noPrivateConsts whether to ignore private constants
+     */
+    public abstract void searchModuleForConst(String name, boolean noPrivateConsts);
+
     /**
      * Lookup a constant from a given class or module.
      *

diff --git a/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter6.java b/core/src/main/java/org/jruby/ir/targets/IRBytecodeAdapter6.java
@@ -715,6 +715,10 @@ public void searchConst(String name, boolean noPrivateConsts) {
         adapter.invokedynamic("searchConst", sig(JVM.OBJECT, params(ThreadContext.class, StaticScope.class)), ConstantLookupSite.BOOTSTRAP, name, noPrivateConsts ? 1 : 0);
     }
 
+    public void searchModuleForConst(String name, boolean noPrivateConsts) {
+        adapter.invokedynamic("searchModuleForConst", sig(JVM.OBJECT, params(ThreadContext.class, RubyModule.class)), ConstantLookupSite.BOOTSTRAP, name, noPrivateConsts ? 1 : 0);
+    }
+
     public void inheritanceSearchConst(String name, boolean noPrivateConsts) {
         adapter.invokedynamic("inheritanceSearchConst", sig(JVM.OBJECT, params(ThreadContext.class, IRubyObject.class)), ConstantLookupSite.BOOTSTRAP, name, noPrivateConsts ? 1 : 0);
     }

diff --git a/core/src/main/java/org/jruby/ir/targets/JVMVisitor.java b/core/src/main/java/org/jruby/ir/targets/JVMVisitor.java
@@ -1918,6 +1918,14 @@ public void SearchConstInstr(SearchConstInstr searchconstinstr) {
         jvmStoreLocal(searchconstinstr.getResult());
     }
 
+    @Override
+    public void SearchModuleForConstInstr(SearchModuleForConstInstr instr) {
+        jvmMethod().loadContext();
+        visit(instr.getCurrentModule());
+
+        jvmMethod().searchModuleForConst(instr.getConstName(), instr.isNoPrivateConsts());
+    }
+
     @Override
     public void SetCapturedVarInstr(SetCapturedVarInstr instr) {
         jvmMethod().loadContext();