[GR-28711] Add method assumptions map to modules

PullRequest: truffleruby/2442

Author: eregon

spec/ruby/core/module/include_spec.rb

@@ -234,6 +234,124 @@ class C
       remove_const :C
     end
   end
+
+  it "updates the method when an included module is updated" do
+    a_class = Class.new do
+      def foo
+        'a'
+      end
+    end
+
+    m_module = Module.new
+
+    b_class = Class.new(a_class) do
+      include m_module
+    end
+
+    b = b_class.new
+
+    foo = -> { b.foo }
+
+    foo.call.should == 'a'
+
+    m_module.module_eval do
+      def foo
+        'm'
+      end
+    end
+
+    foo.call.should == 'm'
+  end
+
+  it "updates the method when a nested included module is updated" do
+    a_class = Class.new do
+      def foo
+        'a'
+      end
+    end
+
+    n_module = Module.new
+
+    m_module = Module.new  do
+      include n_module
+    end
+
+    b_class = Class.new(a_class) do
+      include m_module
+    end
+
+    b = b_class.new
+
+    foo = -> { b.foo }
+
+    foo.call.should == 'a'
+
+    n_module.module_eval do
+      def foo
+        'n'
+      end
+    end
+
+    foo.call.should == 'n'
+  end
+
+  it "updates the method when a new module is included" do
+    a_class = Class.new do
+      def foo
+        'a'
+      end
+    end
+
+    m_module = Module.new do
+      def foo
+        'm'
+      end
+    end
+
+    b_class = Class.new(a_class)
+    b = b_class.new
+
+    foo = -> { b.foo }
+
+    foo.call.should == 'a'
+
+    b_class.class_eval do
+      include m_module
+    end
+
+    foo.call.should == 'm'
+  end
+
+  it "updates the method when a new module with nested module is included" do
+    a_class = Class.new do
+      def foo
+        'a'
+      end
+    end
+
+    n_module = Module.new do
+      def foo
+        'n'
+      end
+    end
+
+    m_module = Module.new  do
+      include n_module
+    end
+
+    b_class = Class.new(a_class)
+    b = b_class.new
+
+    foo = -> { b.foo }
+
+    foo.call.should == 'a'
+
+    b_class.class_eval do
+      include m_module
+    end
+
+    foo.call.should == 'n'
+  end
 end
 
 describe "Module#include?" do

spec/ruby/core/module/prepend_spec.rb

@@ -36,6 +36,77 @@ def self.prepend_features(mod)
     ScratchPad.recorded.should == [ [ m3, c], [ m2, c ], [ m, c ] ]
   end
 
+  it "updates the method when a module is prepended" do
+    m_module = Module.new do
+      def foo
+        "m"
+      end
+    end
+    a_class = Class.new do
+      def foo
+        'a'
+      end
+    end
+    b_class = Class.new(a_class)
+    b = b_class.new
+    foo = -> { b.foo }
+    foo.call.should == 'a'
+    a_class.class_eval do
+      prepend m_module
+    end
+    foo.call.should == 'm'
+  end
+
+  it "updates the method when a prepended module is updated" do
+    m_module = Module.new
+    a_class = Class.new do
+      prepend m_module
+      def foo
+        'a'
+      end
+    end
+    b_class = Class.new(a_class)
+    b = b_class.new
+    foo = -> { b.foo }
+    foo.call.should == 'a'
+    m_module.module_eval do
+      def foo
+        "m"
+      end
+    end
+    foo.call.should == 'm'
+  end
+
+  it "updates the method when a new module with an included module is prepended" do
+    a_class = Class.new do
+      def foo
+        'a'
+      end
+    end
+
+    n_module = Module.new do
+      def foo
+        'n'
+      end
+    end
+
+    m_module = Module.new  do
+      include n_module
+    end
+
+    b_class = Class.new(a_class)
+    b = b_class.new
+    foo = -> { b.foo }
+
+    foo.call.should == 'a'
+
+    a_class.class_eval do
+      prepend m_module
+    end
+
+    foo.call.should == 'n'
+  end
+
   it "raises a TypeError when the argument is not a Module" do
     -> { ModuleSpecs::Basic.prepend(Class.new) }.should raise_error(TypeError)
   end

spec/ruby/core/module/remove_method_spec.rb

@@ -43,6 +43,28 @@ def method_to_remove; 2; end
     x.method_to_remove.should == 1
   end
 
+  it "updates the method implementation" do
+    m_module = Module.new do
+      def foo
+        'm'
+      end
+    end
+
+    a_class = Class.new do
+      include m_module
+
+      def foo
+        'a'
+      end
+    end
+
+    a = a_class.new
+    foo = -> { a.foo }
+    foo.call.should == 'a'
+    a_class.remove_method(:foo)
+    foo.call.should == 'm'
+  end
+
   it "removes multiple methods with 1 call" do
     klass = Class.new do
       def method_to_remove_1; 1; end

src/main/java/org/truffleruby/core/method/MethodEntry.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2021, 2021 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.method;
+
+import org.truffleruby.language.methods.InternalMethod;
+
+import com.oracle.truffle.api.Assumption;
+import com.oracle.truffle.api.Truffle;
+
+public final class MethodEntry {
+
+    private final Assumption assumption;
+    private final InternalMethod method;
+
+    public MethodEntry(InternalMethod method) {
+        assert method != null;
+        this.assumption = Truffle.getRuntime().createAssumption();
+        this.method = method;
+    }
+
+    public MethodEntry() {
+        this.assumption = Truffle.getRuntime().createAssumption();
+        this.method = null;
+    }
+
+    public MethodEntry withNewAssumption() {
+        if (method != null) {
+            return new MethodEntry(method);
+        } else {
+            return new MethodEntry();
+        }
+    }
+
+    public Assumption getAssumption() {
+        return assumption;
+    }
+
+    public InternalMethod getMethod() {
+        return method;
+    }
+
+    public void invalidate(String message) {
+        assumption.invalidate(message);
+    }
+
+}

src/main/java/org/truffleruby/core/module/ModuleChain.java

@@ -9,12 +9,10 @@
  */
 package org.truffleruby.core.module;
 
-import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
-
 /** Either an IncludedModule, a RubyClass or a RubyModule. Private interface, do not use outside RubyModule. */
 public abstract class ModuleChain {
 
-    @CompilationFinal protected ModuleChain parentModule;
+    protected ModuleChain parentModule;
 
     public ModuleChain(ModuleChain parentModule) {
         this.parentModule = parentModule;