[GR-18163] Call #method_missing if #singleton_method_added is undefined (#2258)

PullRequest: truffleruby/2415

Author: eregon

spec/ruby/core/basicobject/singleton_method_added_spec.rb

@@ -83,4 +83,63 @@ class << self
     end
     ScratchPad.recorded.should == [:singleton_method_added, :new_method_with_define_method]
   end
+
+  describe "when singleton_method_added is undefined" do
+    it "raises NoMethodError for a metaclass" do
+      class BasicObjectSpecs::NoSingletonMethodAdded
+        class << self
+          undef_method :singleton_method_added
+        end
+
+        -> {
+          def self.foo
+          end
+        }.should raise_error(NoMethodError, /undefined method `singleton_method_added' for/)
+      end
+    end
+
+    it "raises NoMethodError for a singleton instance" do
+      object = Object.new
+      class << object
+        undef_method :singleton_method_added
+
+        -> {
+          def foo
+          end
+        }.should raise_error(NoMethodError, /undefined method `singleton_method_added' for #<Object:/)
+
+        -> {
+          define_method(:bar) {}
+        }.should raise_error(NoMethodError, /undefined method `singleton_method_added' for #<Object:/)
+      end
+
+      -> {
+        object.define_singleton_method(:baz) {}
+      }.should raise_error(NoMethodError, /undefined method `singleton_method_added' for #<Object:/)
+    end
+
+    it "calls #method_missing" do
+      ScratchPad.record []
+      object = Object.new
+      class << object
+        def method_missing(*args)
+          ScratchPad << args
+        end
+
+        undef_method :singleton_method_added
+
+        def foo
+        end
+
+        define_method(:bar) {}
+      end
+      object.define_singleton_method(:baz) {}
+
+      ScratchPad.recorded.should == [
+        [:singleton_method_added, :foo],
+        [:singleton_method_added, :bar],
+        [:singleton_method_added, :baz],
+      ]
+    end
+  end
 end

src/main/java/org/truffleruby/RubyContext.java

@@ -45,9 +45,7 @@
 import org.truffleruby.core.hash.ReHashable;
 import org.truffleruby.core.inlined.CoreMethods;
 import org.truffleruby.core.kernel.AtExitManager;
-import org.truffleruby.core.kernel.KernelNodes;
 import org.truffleruby.core.kernel.TraceManager;
-import org.truffleruby.core.module.ModuleOperations;
 import org.truffleruby.core.module.RubyModule;
 import org.truffleruby.core.objectspace.ObjectSpaceManager;
 import org.truffleruby.core.proc.ProcOperations;
@@ -63,16 +61,13 @@
 import org.truffleruby.language.CallStackManager;
 import org.truffleruby.core.string.ImmutableRubyString;
 import org.truffleruby.language.LexicalScope;
-import org.truffleruby.language.Nil;
 import org.truffleruby.language.RubyBaseNode;
 import org.truffleruby.language.SafepointManager;
-import org.truffleruby.language.arguments.RubyArguments;
 import org.truffleruby.language.backtrace.BacktraceFormatter;
 import org.truffleruby.language.control.RaiseException;
+import org.truffleruby.language.dispatch.DispatchNode;
 import org.truffleruby.language.loader.CodeLoader;
 import org.truffleruby.language.loader.FeatureLoader;
-import org.truffleruby.language.methods.InternalMethod;
-import org.truffleruby.language.objects.MetaClassNode;
 import org.truffleruby.language.objects.shared.SharedObjects;
 import org.truffleruby.options.LanguageOptions;
 import org.truffleruby.options.Options;
@@ -435,27 +430,7 @@ private TruffleNFIPlatform createNativePlatform() {
 
     @TruffleBoundary
     public static Object send(Object receiver, String methodName, Object... arguments) {
-        final InternalMethod method = ModuleOperations
-                .lookupMethodUncached(MetaClassNode.getUncached().execute(receiver), methodName, null);
-        if (method == null || method.isUndefined()) {
-            final RubyContext context = RubyLanguage.getCurrentContext();
-            final String message = String.format(
-                    "undefined method `%s' for %s when using RubyContext#send() which ignores #method_missing",
-                    methodName,
-                    KernelNodes.ToSNode.uncachedBasicToS(receiver));
-            throw new RaiseException(
-                    context,
-                    context.getCoreExceptions().noMethodError(
-                            message,
-                            receiver,
-                            methodName,
-                            arguments,
-                            EncapsulatingNodeReference.getCurrent().get()));
-        }
-
-        return IndirectCallNode.getUncached().call(
-                method.getCallTarget(),
-                RubyArguments.pack(null, null, method, null, receiver, Nil.INSTANCE, arguments));
+        return DispatchNode.getUncached().call(receiver, methodName, arguments);
     }
 
     @TruffleBoundary