[GR-18163] Fix import_methods supports module methods with super

PullRequest: truffleruby/3746

Author: horakivo

spec/ruby/core/refinement/import_methods_spec.rb

@@ -125,7 +125,6 @@ def indent(level)
           suppress_warning { import_methods RefinementSpec::ModuleWithAncestors }
         end
 
-
         using self
         -> {
           "foo".indent(3)
@@ -134,26 +133,26 @@ def indent(level)
     end
 
     it "doesn't import any methods if one of the arguments is not a module" do
-        str_utils = Module.new do
-          def indent(level)
-            " " * level + self
-          end
-        end
-
-        string_refined = Module.new do
-          refine String do
-            -> {
-              import_methods str_utils, Integer
-            }.should raise_error(TypeError)
-          end
+      str_utils = Module.new do
+        def indent(level)
+          " " * level + self
         end
+      end
 
-        Module.new do
-          using string_refined
+      string_refined = Module.new do
+        refine String do
           -> {
-            "foo".indent(3)
-          }.should raise_error(NoMethodError)
+            import_methods str_utils, Integer
+          }.should raise_error(TypeError)
         end
+      end
+
+      Module.new do
+        using string_refined
+        -> {
+          "foo".indent(3)
+        }.should raise_error(NoMethodError)
+      end
     end
 
     it "imports methods from multiple modules so that methods see other's module's methods" do
@@ -219,6 +218,31 @@ def self.indent(level)
       end
     end
 
+    it "imports module methods with super" do
+      class_to_refine = Class.new do
+        def foo(number)
+          2 * number
+        end
+      end
+
+      extension = Module.new do
+        def foo(number)
+          super * 2
+        end
+      end
+
+      refinement = Module.new do
+        refine class_to_refine do
+          import_methods extension
+        end
+      end
+
+      Module.new do
+        using refinement
+        class_to_refine.new.foo(2).should == 8
+      end
+    end
+
     context "when methods are not defined in Ruby code" do
       it "raises ArgumentError" do
         Module.new do

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

@@ -2489,7 +2489,7 @@ private String createErrorMessage(InternalMethod method, RubyModule module) {
         private void importMethodsFromModuleToRefinement(RubyModule module, RubyModule refinement) {
             var declarationContext = createDeclarationContextWithRefinement(refinement);
             for (InternalMethod methodToCopy : module.fields.getMethods()) {
-                var clonedMethod = cloneMethod(methodToCopy, declarationContext);
+                var clonedMethod = cloneMethod(methodToCopy, declarationContext, refinement);
                 refinement.fields.addMethod(getContext(), this, clonedMethod);
             }
         }
@@ -2514,9 +2514,11 @@ private DeclarationContext createDeclarationContextWithRefinement(RubyModule ref
                     refinements);
         }
 
-        private InternalMethod cloneMethod(InternalMethod method, DeclarationContext declarationContext) {
+        private InternalMethod cloneMethod(InternalMethod method, DeclarationContext declarationContext,
+                RubyModule refinement) {
             var clonedCallTarget = cloneCallTarget(method);
-            return method.withCallTargetAndDeclarationContext(clonedCallTarget, declarationContext);
+            return method.withCallTargetAndDeclarationContextAndDeclarationModule(clonedCallTarget, declarationContext,
+                    refinement);
         }
 
         private RootCallTarget cloneCallTarget(InternalMethod method) {

src/main/java/org/truffleruby/language/methods/InternalMethod.java

@@ -384,17 +384,18 @@ public InternalMethod withDeclarationContext(DeclarationContext newDeclarationCo
         }
     }
 
-    public InternalMethod withCallTargetAndDeclarationContext(RootCallTarget rootCallTarget,
-            DeclarationContext newDeclarationContext) {
-        if (rootCallTarget == this.callTarget && newDeclarationContext == declarationContext) {
+    public InternalMethod withCallTargetAndDeclarationContextAndDeclarationModule(RootCallTarget rootCallTarget,
+            DeclarationContext newDeclarationContext, RubyModule newDeclaringModule) {
+        if (rootCallTarget == this.callTarget && newDeclarationContext == declarationContext &&
+                newDeclaringModule == this.declaringModule) {
             return this;
         } else {
             return new InternalMethod(
                     sharedMethodInfo,
                     lexicalScope,
                     newDeclarationContext,
                     name,
-                    declaringModule,
+                    newDeclaringModule,
                     owner,
                     visibility,
                     undefined,