[GR-40333] module#private, #public, #protected, #module_function now returns their arguments

PullRequest: truffleruby/3642

Author: horakivo

CHANGELOG.md

@@ -74,6 +74,7 @@ Compatibility:
 * Fix `Array` methods `reject`, `reject!`, `inject`, `map`, `select`, `each_index` and handle a case when array is modified by a passed block like CRuby does (#2822, @andrykonchin, @eregon).
 * Fix `Array` methods `select!` and `keep_if` and handle a case when exception is raised in a passed block properly (@andrykonchin).
 * Fix `Enumerable` methods `each_cons` and `each_slice` to return receiver (#2733, @horakivo)
+* `Module` methods `#private`, `#public`, `#protected`, `#module_function` now returns their arguments like in CRuby 3.1 (#2733, @horakivo)
 
 Performance:
 

spec/tags/core/module/module_function_tags.txt

@@ -1,2 +1 @@
 fails:Module#private continues to allow a prepended module method to call super
-fails:Module#private returns argument or arguments if given

spec/tags/core/module/private_tags.txt

@@ -1,2 +1 @@
 fails:Module#public on a superclass method calls the redefined method
-fails:Module#public returns argument or arguments if given

spec/tags/core/module/protected_tags.txt

@@ -9,13 +9,15 @@
  */
 package org.truffleruby.core.cast;
 
+import com.oracle.truffle.api.dsl.GenerateUncached;
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.RubyGuards;
 
 import com.oracle.truffle.api.dsl.ImportStatic;
 import com.oracle.truffle.api.dsl.Specialization;
 
+@GenerateUncached
 @ImportStatic(value = { RubyGuards.class })
 public abstract class SingleValueCastNode extends RubyBaseNode {
 

spec/tags/core/module/public_tags.txt

@@ -47,6 +47,7 @@
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.cast.BooleanCastWithDefaultNode;
 import org.truffleruby.core.cast.NameToJavaStringNode;
+import org.truffleruby.core.cast.SingleValueCastNode;
 import org.truffleruby.core.cast.ToIntNode;
 import org.truffleruby.core.cast.ToPathNodeGen;
 import org.truffleruby.core.cast.ToStrNode;
@@ -1682,21 +1683,22 @@ protected boolean isMethodDefined(RubyModule module, String name, boolean inheri
     @CoreMethod(names = "module_function", rest = true, visibility = Visibility.PRIVATE, alwaysInlined = true)
     public abstract static class ModuleFunctionNode extends AlwaysInlinedMethodNode {
         @Specialization(guards = "names.length == 0")
-        protected RubyModule frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names,
                 @Cached BranchProfile errorProfile) {
             checkNotClass(module, errorProfile);
             needCallerFrame(callerFrame, "Module#module_function with no arguments");
             DeclarationContext.setCurrentVisibility(callerFrame, Visibility.MODULE_FUNCTION);
-            return module;
+            return nil;
         }
 
         @Specialization(guards = "names.length > 0")
-        protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names,
                 @Cached SetMethodVisibilityNode setMethodVisibilityNode,
                 @Cached BranchProfile errorProfile,
-                @Cached LoopConditionProfile loopProfile) {
+                @Cached LoopConditionProfile loopProfile,
+                @Cached SingleValueCastNode singleValueCastNode) {
             checkNotClass(module, errorProfile);
             int i = 0;
             try {
@@ -1707,7 +1709,7 @@ protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] ruby
             } finally {
                 profileAndReportLoopCount(loopProfile, i);
             }
-            return module;
+            return singleValueCastNode.executeSingleValue(names);
         }
 
         private void checkNotClass(RubyModule module, BranchProfile errorProfile) {
@@ -1769,21 +1771,22 @@ protected RubyArray nesting() {
     @CoreMethod(names = "public", rest = true, visibility = Visibility.PRIVATE, alwaysInlined = true)
     public abstract static class PublicNode extends AlwaysInlinedMethodNode {
         @Specialization(guards = "names.length == 0")
-        protected RubyModule frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names) {
             needCallerFrame(callerFrame, "Module#public with no arguments");
             DeclarationContext.setCurrentVisibility(callerFrame, Visibility.PUBLIC);
-            return module;
+            return nil;
         }
 
         @Specialization(guards = "names.length > 0")
-        protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names,
-                @Cached SetMethodVisibilityNode setMethodVisibilityNode) {
+                @Cached SetMethodVisibilityNode setMethodVisibilityNode,
+                @Cached SingleValueCastNode singleValueCastNode) {
             for (Object name : names) {
                 setMethodVisibilityNode.execute(module, name, Visibility.PUBLIC);
             }
-            return module;
+            return singleValueCastNode.executeSingleValue(names);
         }
     }
 
@@ -1810,21 +1813,22 @@ protected RubyModule publicClassMethod(RubyModule module, Object[] names) {
     @CoreMethod(names = "private", rest = true, visibility = Visibility.PRIVATE, alwaysInlined = true)
     public abstract static class PrivateNode extends AlwaysInlinedMethodNode {
         @Specialization(guards = "names.length == 0")
-        protected RubyModule frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names) {
             needCallerFrame(callerFrame, "Module#private with no arguments");
             DeclarationContext.setCurrentVisibility(callerFrame, Visibility.PRIVATE);
-            return module;
+            return nil;
         }
 
         @Specialization(guards = "names.length > 0")
-        protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names,
-                @Cached SetMethodVisibilityNode setMethodVisibilityNode) {
+                @Cached SetMethodVisibilityNode setMethodVisibilityNode,
+                @Cached SingleValueCastNode singleValueCastNode) {
             for (Object name : names) {
                 setMethodVisibilityNode.execute(module, name, Visibility.PRIVATE);
             }
-            return module;
+            return singleValueCastNode.executeSingleValue(names);
         }
     }
 
@@ -2114,21 +2118,22 @@ protected RubyModule publicConstant(RubyModule module, Object[] args) {
     @CoreMethod(names = "protected", rest = true, visibility = Visibility.PRIVATE, alwaysInlined = true)
     public abstract static class ProtectedNode extends AlwaysInlinedMethodNode {
         @Specialization(guards = "names.length == 0")
-        protected RubyModule frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object frame(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names) {
             needCallerFrame(callerFrame, "Module#protected with no arguments");
             DeclarationContext.setCurrentVisibility(callerFrame, Visibility.PROTECTED);
-            return module;
+            return nil;
         }
 
         @Specialization(guards = "names.length > 0")
-        protected RubyModule methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
+        protected Object methods(Frame callerFrame, RubyModule module, Object[] rubyArgs, RootCallTarget target,
                 @Bind("getPositionalArguments(rubyArgs, false)") Object[] names,
-                @Cached SetMethodVisibilityNode setMethodVisibilityNode) {
+                @Cached SetMethodVisibilityNode setMethodVisibilityNode,
+                @Cached SingleValueCastNode singleValueCastNode) {
             for (Object name : names) {
                 setMethodVisibilityNode.execute(module, name, Visibility.PROTECTED);
             }
-            return module;
+            return singleValueCastNode.executeSingleValue(names);
         }
     }