jruby · Jul 7, 2015 · Jul 7, 2015 · Jul 7, 2015 · Jul 7, 2015
Showing with 20 additions and 10 deletions.

+17 −1 spec/ruby/core/module/prepend_spec.rb

+1 −0 spec/truffle/tags/core/module/prepend_tags.txt

+2 −9 truffle/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java
diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb
@@ -117,8 +117,12 @@ def self.prepend_features(mod)
     m1 = Module.new { def calc(x) x end }
     m2 = Module.new { prepend(m1) }
     c1 = Class.new { prepend(m2) }
-    c2 = Class.new { prepend(m2.dup) }
+    m2dup = m2.dup
+    m2dup.ancestors.should == [m2dup,m1,m2]
+    c2 = Class.new { prepend(m2dup) }
+    c1.ancestors[0,3].should == [m1,m2,c1]
     c1.new.should be_kind_of(m1)
+    c2.ancestors[0,4].should == [m2dup,m1,m2,c2]
     c2.new.should be_kind_of(m1)
   end
 
@@ -127,6 +131,18 @@ def self.prepend_features(mod)
     Class.new { prepend(m) }.ancestors.should_not include(m)
   end
 
+  it "adds the module in the subclass chains" do
+    parent = Class.new { def chain; [:parent]; end }
+    child = Class.new(parent) { def chain; super << :child; end }
+    mod = Module.new { def chain; super << :mod; end }
+    parent.prepend mod
+    parent.ancestors[0,2].should == [mod, parent]
+    child.ancestors[0,3].should == [child, mod, parent]
+
+    parent.new.chain.should == [:parent, :mod]
+    child.new.chain.should == [:parent, :mod, :child]
+  end
+
   it "inserts a later prepended module into the chain" do
     m1 = Module.new { def chain; super << :m1; end }
     m2 = Module.new { def chain; super << :m2; end }

diff --git a/spec/truffle/tags/core/module/prepend_tags.txt b/spec/truffle/tags/core/module/prepend_tags.txt
@@ -0,0 +1 @@
+fails:Module#prepend keeps the module in the chain when dupping an intermediate module
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java b/truffle/src/main/java/org/jruby/truffle/runtime/core/RubyModule.java
@@ -98,8 +98,7 @@ public void insertAfter(RubyModule module) {
     // The context is stored here - objects can obtain it via their class (which is a module)
     private final RubyContext context;
 
-    /** Either {@code this} or a {@link PrependMarker} */
-    @CompilationFinal protected ModuleChain start = this;
+    protected final ModuleChain start = new PrependMarker(this);
     @CompilationFinal protected ModuleChain parentModule;
 
     private final RubyModule lexicalParent;
@@ -178,7 +177,7 @@ public void initCopy(RubyModule from) {
         this.constants.putAll(from.constants);
         this.classVariables.putAll(from.classVariables);
 
-        if (from.start instanceof PrependMarker) {
+        if (from.start.getParentModule() != from) {
             this.parentModule = from.start;
         } else {
             this.parentModule = from.parentModule;
@@ -272,12 +271,6 @@ public void prepend(Node currentNode, RubyModule module) {
             throw new RaiseException(getContext().getCoreLibrary().argumentError("cyclic prepend detected", currentNode));
         }
 
-        if (start == this) {
-            // Create an PrependMarker pointing to an empty module or class
-            // serving as an indirection to the first prepended module
-            start = new PrependMarker(this);
-        }
-
         Stack<RubyModule> modulesToPrepend = new Stack<>();
         modulesToPrepend.push(module);
         for (RubyModule includedModule : module.prependedAndIncludedModules()) {
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1 @@
		fails:Module#prepend keeps the module in the chain when dupping an intermediate module