jruby · enebo · May 25, 2021 · Oct 2, 2020 · Oct 22, 2020 · Oct 24, 2020
diff --git a/core/src/main/java/org/jruby/Ruby.java b/core/src/main/java/org/jruby/Ruby.java
@@ -122,7 +122,6 @@
 import org.jruby.ir.persistence.IRReader;
 import org.jruby.ir.persistence.IRReaderStream;
 import org.jruby.ir.persistence.util.IRFileExpert;
-import org.jruby.javasupport.proxy.JavaProxyClassFactory;
 import org.jruby.management.BeanManager;
 import org.jruby.management.BeanManagerFactory;
 import org.jruby.management.Config;
@@ -2986,14 +2985,6 @@ public Map<String, Map<String, String>> getBoundMethods() {
         return boundMethods;
     }
 
-    public void setJavaProxyClassFactory(JavaProxyClassFactory factory) {
-        this.javaProxyClassFactory = factory;
-    }
-
-    public JavaProxyClassFactory getJavaProxyClassFactory() {
-        return javaProxyClassFactory;
-    }
-
     private static final EnumSet<RubyEvent> interest =
             EnumSet.of(
                     RubyEvent.C_CALL,
@@ -5622,8 +5613,6 @@ public void warn(String message) {
 
     private FFI ffi;
 
-    private JavaProxyClassFactory javaProxyClassFactory;
-
     /** Used to find the ProfilingService implementation to use. If profiling is disabled it's null */
     private final ProfilingServiceLookup profilingServiceLookup;
 

diff --git a/core/src/main/java/org/jruby/RubyClass.java b/core/src/main/java/org/jruby/RubyClass.java
diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -1812,6 +1812,25 @@ public CacheEntry searchMethodEntryInner(String id) {
         return null;
     }
 
+    /**
+     * Searches for a method up until the superclass, but include modules. This is
+     * for Concrete java ctor initialization
+     * TODO: add a cache?
+     */
+    public DynamicMethod searchMethodLateral(String id) {
+       // int token = generation;
+        // This flattens some of the recursion that would be otherwise be necessary.
+        // Used to recurse up the class hierarchy which got messy with prepend.
+        for (RubyModule module = this; module != null && (module == this || (module instanceof IncludedModuleWrapper)); module = module.getSuperClass()) {
+            // Only recurs if module is an IncludedModuleWrapper.
+            // This way only the recursion needs to be handled differently on
+            // IncludedModuleWrapper.
+            DynamicMethod method = module.searchMethodCommon(id);
+            if (method != null) return method.isNull() ? null : method;
+        }
+        return null;
+    }
+
     // MRI: resolve_refined_method
     public CacheEntry resolveRefinedMethod(Map<RubyModule, RubyModule> refinements, CacheEntry entry, String id, boolean cacheUndef) {
         if (entry != null && entry.method.isRefined()) {
@@ -2482,6 +2501,8 @@ public IRubyObject initialize_copy(IRubyObject original) {
         syncConstants(originalModule);
 
         originalModule.cloneMethods(this);
+
+        this.javaProxy = originalModule.javaProxy; 
 
         return this;
     }

diff --git a/core/src/main/java/org/jruby/compiler/impl/SkinnyMethodAdapter.java b/core/src/main/java/org/jruby/compiler/impl/SkinnyMethodAdapter.java
@@ -73,17 +73,19 @@ public final class SkinnyMethodAdapter extends MethodVisitor {
     private final ClassVisitor cv;
     private final Label start;
     private final Label end;
+    private final String signature;
 
     private MethodVisitor method;
     private Printer printer;
 
-    public SkinnyMethodAdapter(ClassVisitor cv, int flags, String name, String signature, String something, String[] exceptions) {
+    public SkinnyMethodAdapter(ClassVisitor cv, int flags, String name, String signature, String genericTypeInformation, String[] exceptions) {
         super(ASM4);
-        setMethodVisitor(cv.visitMethod(flags, name, signature, something, exceptions));
+        setMethodVisitor(cv.visitMethod(flags, name, signature, genericTypeInformation, exceptions));
         this.cv = cv;
         this.name = name;
         this.start = new Label();
         this.end = new Label();
+        this.signature = signature;
     }
 
     public ClassVisitor getClassVisitor() {
@@ -102,6 +104,10 @@ public void setMethodVisitor(MethodVisitor mv) {
             this.method = mv;
         }
     }
+
+    public String getSignature() {
+    	return signature;
+    }
 
     /**
      * Short-hand for specifying a set of aloads

diff --git a/core/src/main/java/org/jruby/ext/ffi/ReifyingAllocator.java b/core/src/main/java/org/jruby/ext/ffi/ReifyingAllocator.java
@@ -10,10 +10,10 @@
 import java.lang.reflect.InvocationTargetException;
 
 class ReifyingAllocator implements ObjectAllocator {
-    private final Class klass;
-    private final Constructor cons;
+    private final Class<? extends IRubyObject> klass;
+    private final Constructor<? extends IRubyObject> cons;
 
-    public ReifyingAllocator(Class klass) {
+    public ReifyingAllocator(Class<? extends IRubyObject> klass) {
         this.klass = klass;
         try {
             this.cons = klass.getDeclaredConstructor(Ruby.class, RubyClass.class);
@@ -24,8 +24,8 @@ public ReifyingAllocator(Class klass) {
 
     public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
         try {
-            if (klazz.getReifiedClass() == this.klass) {
-                return (IRubyObject) cons.newInstance(runtime, klazz);
+            if (klazz.getReifiedRubyClass() == this.klass) {
+                return cons.newInstance(runtime, klazz);
             }
 
             reifyWithAncestors(klazz);
@@ -44,10 +44,10 @@ private static void reifyWithAncestors(RubyClass klazz) {
 
         RubyClass realSuper = klazz.getSuperClass().getRealClass();
 
-        if (realSuper.getReifiedClass() == null) reifyWithAncestors(realSuper);
+        if (realSuper.getReifiedRubyClass() == null) reifyWithAncestors(realSuper);
         synchronized (klazz) {
             klazz.reify();
-            klazz.setAllocator(new ReifyingAllocator(klazz.getReifiedClass()));
+            klazz.setAllocator(new ReifyingAllocator(klazz.getReifiedRubyClass()));
         }
     }
 }
diff --git a/core/src/main/java/org/jruby/internal/runtime/AbstractIRMethod.java b/core/src/main/java/org/jruby/internal/runtime/AbstractIRMethod.java
@@ -1,5 +1,33 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/epl-v20.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the EPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the EPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
 package org.jruby.internal.runtime;
 
+import java.util.Collection;
+
 import org.jruby.Ruby;
 import org.jruby.RubyModule;
 import org.jruby.compiler.Compilable;
@@ -13,15 +41,15 @@
 import org.jruby.parser.StaticScope;
 import org.jruby.runtime.ArgumentDescriptor;
 import org.jruby.runtime.Arity;
+import org.jruby.runtime.Block;
 import org.jruby.runtime.PositionAware;
 import org.jruby.runtime.Signature;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.runtime.ivars.MethodData;
 import org.jruby.util.cli.Options;
 
-import java.util.Collection;
-
 public abstract class AbstractIRMethod extends DynamicMethod implements IRMethodArgs, PositionAware, Cloneable {
 
     protected final Signature signature;
@@ -175,4 +203,12 @@ public boolean needsToFindImplementer() {
         // FIXME: This may stop working if we eliminate startup interp
         return !(irScope instanceof IRMethod && !irScope.getInterpreterContext().getFlags().contains(IRFlags.REQUIRES_CLASS));
     }
+    /**
+     * Calls a split method (java constructor-invoked initialize) and returns the paused state. If
+     * this method doesn't have a super call, returns null without execution.
+     */
+    public abstract SplitSuperState startSplitSuperCall(ThreadContext context, IRubyObject self, RubyModule klazz,
+            String name, IRubyObject[] args, Block block);
+
+    public abstract void finishSplitCall(SplitSuperState state);
 }
diff --git a/core/src/main/java/org/jruby/internal/runtime/InternalSplitState.java b/core/src/main/java/org/jruby/internal/runtime/InternalSplitState.java
@@ -0,0 +1,31 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/epl-v20.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the EPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the EPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.internal.runtime;
+
+public interface InternalSplitState {
+
+}
diff --git a/core/src/main/java/org/jruby/internal/runtime/SplitSuperState.java b/core/src/main/java/org/jruby/internal/runtime/SplitSuperState.java
@@ -0,0 +1,43 @@
+/***** BEGIN LICENSE BLOCK *****
+ * Version: EPL 2.0/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Eclipse Public
+ * License Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.eclipse.org/legal/epl-v20.html
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the EPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the EPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package org.jruby.internal.runtime;
+
+import org.jruby.RubyArray;
+import org.jruby.internal.runtime.methods.ExitableReturn;
+import org.jruby.runtime.Block;
+
+public class SplitSuperState<T extends InternalSplitState> {
+    public final RubyArray<?> callArrayArgs;
+    public final Block callBlockArgs;
+    public final T state;
+
+    public SplitSuperState(ExitableReturn result, T state) {
+        callArrayArgs = result.getArguments();
+        callBlockArgs = result.getBlock();
+        this.state = state;
+    }
+}