[GR-28849] Implement two-arg version of {public,private,protected}_method_defined?

PullRequest: truffleruby/2344

Author: Nicolas Laurent

CHANGELOG.md

@@ -40,6 +40,7 @@ Compatibility:
 * Coerce the message to a `String` for `BasicSocket#send` (#2209, @HoneyryderChuck).
 * Support buffer argument for `UDPSocket#recvfrom_nonblock` (#2209, @HoneyryderChuck).
 * Fixed `Integer#digits` implementation to handle more bases (#2224, #2225).
+* Support the `inherit` parameter for `Module#{private, protected, public}_method_defined?`.
 
 Performance:
 

spec/tags/core/module/private_method_defined_tags.txt

@@ -1697,6 +1697,7 @@ public PrivateInstanceMethodsNode() {
 
     @NodeChild(value = "module", type = RubyNode.class)
     @NodeChild(value = "name", type = RubyNode.class)
+    @NodeChild(value = "inherit", type = RubyNode.class)
     protected abstract static class AbstractMethodDefinedNode extends CoreMethodNode {
 
         final Visibility visibility;
@@ -1710,39 +1711,47 @@ protected RubyNode coerceToString(RubyNode name) {
             return NameToJavaStringNode.create(name);
         }
 
-        @Specialization
-        protected boolean isMethodDefined(RubyModule module, String name) {
-            // TODO (pitr-ch 30-Mar-2016): cache lookup
-            return ModuleOperations.lookupMethod(module, name, visibility) != null;
+        @CreateCast("inherit")
+        protected RubyNode coerceToBoolean(RubyNode inherit) {
+            return BooleanCastWithDefaultNodeGen.create(true, inherit);
+        }
+
+        // TODO (pitr-ch 30-Mar-2016): cache lookup
+
+        @Specialization(guards = "inherit")
+        protected boolean isMethodDefinedInherit(RubyModule module, String name, boolean inherit) {
+            final InternalMethod method = ModuleOperations.lookupMethodUncached(module, name, null);
+            return method != null && !method.isUndefined() && !method.isUnimplemented() &&
+                    method.getVisibility() == visibility;
         }
 
+        @Specialization(guards = "!inherit")
+        protected boolean isMethodDefinedDontInherit(RubyModule module, String name, boolean inherit) {
+            final InternalMethod method = module.fields.getMethod(name);
+            return method != null && !method.isUndefined() && !method.isUnimplemented() &&
+                    method.getVisibility() == visibility;
+        }
     }
 
-    @CoreMethod(names = "public_method_defined?", required = 1)
+    @CoreMethod(names = "public_method_defined?", required = 1, optional = 1)
     public abstract static class PublicMethodDefinedNode extends AbstractMethodDefinedNode {
-
         public PublicMethodDefinedNode() {
             super(Visibility.PUBLIC);
         }
-
     }
 
-    @CoreMethod(names = "protected_method_defined?", required = 1)
+    @CoreMethod(names = "protected_method_defined?", required = 1, optional = 1)
     public abstract static class ProtectedMethodDefinedNode extends AbstractMethodDefinedNode {
-
         public ProtectedMethodDefinedNode() {
             super(Visibility.PROTECTED);
         }
-
     }
 
-    @CoreMethod(names = "private_method_defined?", required = 1)
+    @CoreMethod(names = "private_method_defined?", required = 1, optional = 1)
     public abstract static class PrivateMethodDefinedNode extends AbstractMethodDefinedNode {
-
         public PrivateMethodDefinedNode() {
             super(Visibility.PRIVATE);
         }
-
     }
 
     @CoreMethod(names = "instance_methods", optional = 1)

spec/tags/core/module/protected_method_defined_tags.txt

@@ -24,7 +24,6 @@
 import org.truffleruby.core.string.StringUtils;
 import org.truffleruby.language.LexicalScope;
 import org.truffleruby.language.RubyConstant;
-import org.truffleruby.language.Visibility;
 import org.truffleruby.language.control.RaiseException;
 import org.truffleruby.language.methods.DeclarationContext;
 import org.truffleruby.language.methods.InternalMethod;
@@ -492,14 +491,6 @@ private static InternalMethod lookupMethodUncached(RubyModule module, RubyModule
         return null;
     }
 
-    public static InternalMethod lookupMethod(RubyModule module, String name, Visibility visibility) {
-        final InternalMethod method = lookupMethodUncached(module, name, null);
-        if (method == null || method.isUndefined()) {
-            return null;
-        }
-        return method.getVisibility() == visibility ? method : null;
-    }
-
     public static MethodLookupResult lookupSuperMethod(InternalMethod currentMethod, RubyModule objectMetaClass) {
         final String name = currentMethod.getSharedMethodInfo().getMethodNameForNotBlock(); // use the original name