Rework method invocation to properly super

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

@@ -41,6 +41,7 @@
 import org.jruby.runtime.PositionAware;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.callsite.CacheEntry;
 import org.jruby.runtime.marshal.DataType;
 
 /**
@@ -52,7 +53,9 @@ public abstract class AbstractRubyMethod extends RubyObject implements DataType
     protected String methodName;
     protected RubyModule originModule;
     protected String originName;
+    protected CacheEntry entry;
     protected DynamicMethod method;
+    protected RubyModule sourceModule;
 
     protected AbstractRubyMethod(Ruby runtime, RubyClass rubyClass) {
         super(runtime, rubyClass);
@@ -147,13 +150,13 @@ public IRubyObject parameters(ThreadContext context) {
     protected IRubyObject super_method(ThreadContext context, IRubyObject receiver, RubyModule superClass) {
         if (superClass == null) return context.nil;
 
-        DynamicMethod newMethod = superClass.searchMethod(methodName);
-        if (newMethod == UndefinedMethod.INSTANCE) return context.nil;
+        CacheEntry entry = superClass.searchWithCache(methodName);
+        if (entry.method == UndefinedMethod.INSTANCE) return context.nil;
 
         if (receiver == null) {
-            return RubyUnboundMethod.newUnboundMethod(superClass, methodName, superClass, originName, newMethod);
+            return RubyUnboundMethod.newUnboundMethod(superClass, methodName, superClass, originName, entry);
         } else {
-            return RubyMethod.newMethod(superClass, methodName, superClass, originName, newMethod, receiver);
+            return RubyMethod.newMethod(superClass, methodName, superClass, originName, entry, receiver);
         }
     }
 

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

@@ -53,6 +53,16 @@ public IRubyObject id() {
         return origin.id();
     }
 
+    @Override
+    protected synchronized Map<String, IRubyObject> getClassVariables() {
+        return origin.getClassVariables();
+    }
+
+    @Override
+    protected Map<String, IRubyObject> getClassVariablesForRead() {
+        return origin.getClassVariablesForRead();
+    }
+
     /** The module to which this include origins. */
     protected final RubyModule origin;
 }

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

@@ -115,16 +115,6 @@ public Map<String, DynamicMethod> getMethodsForWrite() {
         return origin.getMethodsForWrite();
     }
 
-    @Override
-    protected synchronized Map<String, IRubyObject> getClassVariables() {
-        return origin.getClassVariables();
-    }
-
-    @Override
-    protected Map<String, IRubyObject> getClassVariablesForRead() {
-        return origin.getClassVariablesForRead();
-    }
-
     @Override
     protected boolean variableTableContains(String name) {
         return origin.variableTableContains(name);

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

@@ -44,16 +44,14 @@
  */
 public class PrependedModule extends IncludedModule {
 
-    public PrependedModule(Ruby runtime, RubyClass superClass, RubyModule origin) {
-        super(runtime, superClass, origin);
-        this.methods = origin.methods;
-        origin.methods = Collections.EMPTY_MAP;
-        origin.methodLocation = this;
+    public PrependedModule(Ruby runtime, RubyClass superClass, RubyModule klass) {
+        super(runtime, superClass, klass);
+        this.methods = klass.methods;
+        klass.methods = Collections.EMPTY_MAP;
+        klass.methodLocation = this;
         for (Map.Entry<String, DynamicMethod> entry : methods.entrySet()) {
             DynamicMethod method = entry.getValue();
-            method.setImplementationClass(this);
-            method.setDefinedClass(origin);
-            if (moveRefinedMethod(entry.getKey(), method, origin)) {
+            if (moveRefinedMethod(entry.getKey(), method, klass)) {
                 methods.remove(entry.getKey());
             }
         }

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

@@ -34,6 +34,7 @@
 import org.jruby.runtime.CallSite;
 import org.jruby.runtime.JavaSites;
 import org.jruby.runtime.JavaSites.BasicObjectSites;
+import org.jruby.runtime.callsite.CacheEntry;
 import org.jruby.runtime.ivars.VariableAccessor;
 import java.io.IOException;
 import java.io.ObjectInputStream;
@@ -586,7 +587,8 @@ public final RubyClass getType() {
     @Override
     public final boolean respondsTo(String name) {
         final Ruby runtime = getRuntime();
-        final DynamicMethod respondTo = getMetaClass().searchMethod("respond_to?");
+        final CacheEntry entry = getMetaClass().searchWithCache("respond_to?");
+        final DynamicMethod respondTo = entry.method;
 
         // fastest path; builtin respond_to? and respond_to_missing? so we just check isMethodBound
         if ( respondTo.equals(runtime.getRespondToMethod()) &&
@@ -609,14 +611,14 @@ public final boolean respondsTo(String name) {
         final Arity arity = respondTo.getArity();
         if ( arity.isFixed() ) {
             if ( arity.required() == 1 ) {
-                return respondTo.call(context, this, metaClass, respondName, mname).isTrue();
+                return respondTo.call(context, this, entry.sourceModule, respondName, mname).isTrue();
             }
             if ( arity.required() != 2 ) {
                 throw runtime.newArgumentError(str(runtime, ids(runtime, respondName), " must accept 1 or 2 arguments (requires " + arity.getValue() + ")"));
             }
         }
 
-        return respondTo.call(context, this, metaClass, respondName, mname, runtime.getTrue()).isTrue();
+        return respondTo.call(context, this, entry.sourceModule, respondName, mname, runtime.getTrue()).isTrue();
     }
 
     /**
@@ -632,11 +634,12 @@ public final boolean respondsToMissing(String name) {
      */
     @Override
     public final boolean respondsToMissing(String name, boolean incPrivate) {
-        DynamicMethod method = getMetaClass().searchMethod("respond_to_missing?");
+        CacheEntry entry = getMetaClass().searchWithCache("respond_to_missing?");
+        DynamicMethod method = entry.method;
         // perhaps should try a smart version as for respondsTo above?
         if ( method.isUndefined() ) return false;
         final Ruby runtime = getRuntime();
-        return method.call(runtime.getCurrentContext(), this, getMetaClass(),
+        return method.call(runtime.getCurrentContext(), this, entry.sourceModule,
             "respond_to_missing?", runtime.newSymbol(name), runtime.newBoolean(incPrivate)
         ).isTrue();
     }
@@ -2492,9 +2495,9 @@ public IRubyObject singleton_method(IRubyObject name) {
         final String methodName = symbol.idString();
         final RubyClass klass = metaClass;
         if (klass.isSingleton()) {
-            DynamicMethod method = klass.searchMethod(methodName);
-            if (klass == method.getDefinedClass()) { // ! method.isUndefined()
-                AbstractRubyMethod newMethod = RubyMethod.newMethod(klass, methodName, klass, methodName, method, this);
+            CacheEntry entry = klass.searchWithCache(methodName);
+            if (klass == entry.method.getDefinedClass()) { // ! method.isUndefined()
+                AbstractRubyMethod newMethod = RubyMethod.newMethod(klass, methodName, klass, methodName, entry, this);
                 newMethod.infectBy(this);
                 return newMethod;
             }