proc.c: Support any callable when composing Procs

* proc.c (proc_compose): support any object with a call method rather
  than supporting only procs. [Feature ruby#6284]

* proc.c (compose): use the function call on the given object rather
  than rb_proc_call_with_block in order to support any object.

* test/ruby/test_proc.rb: Add test cases for composing Procs with
  callable objects.

* test/ruby/test_method.rb: Add test cases for composing Methods with
  callable objects.

proc.c

@@ -3052,7 +3052,7 @@ compose(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc)
     VALUE f, g, fargs;
     f = RARRAY_AREF(args, 0);
     g = RARRAY_AREF(args, 1);
-    fargs = rb_ary_new3(1, rb_proc_call_with_block(g, argc, argv, passed_proc));
+    fargs = rb_ary_new3(1, rb_funcall_with_block(g, idCall, argc, argv, passed_proc));
 
     return rb_proc_call(f, fargs);
 }
@@ -3061,7 +3061,7 @@ compose(VALUE dummy, VALUE args, int argc, VALUE *argv, VALUE passed_proc)
  *  call-seq:
  *     prc * g -> a_proc
  *
- *  Returns a proc that is the composition of this proc and the given proc <i>g</i>.
+ *  Returns a proc that is the composition of this proc and the given <i>g</i>.
  *  The returned proc takes a variable number of arguments, calls <i>g</i> with them
  *  then calls this proc with the result.
  *
@@ -3077,16 +3077,6 @@ proc_compose(VALUE self, VALUE g)
     rb_proc_t *procp;
     int is_lambda;
 
-    if (!rb_obj_is_method(g) && !rb_obj_is_proc(g)) {
-        rb_raise(rb_eTypeError,
-                "wrong argument type %s (expected Proc/Method)",
-                rb_obj_classname(g));
-    }
-
-    if (rb_obj_is_method(g)) {
-        g = method_to_proc(g);
-    }
-
     args = rb_ary_new3(2, self, g);
 
     GetProcPtr(self, procp);
@@ -3103,7 +3093,7 @@ proc_compose(VALUE self, VALUE g)
  *  call-seq:
  *     meth * g -> a_proc
  *
- *  Returns a proc that is the composition of this method and the given proc <i>g</i>.
+ *  Returns a proc that is the composition of this method and the given <i>g</i>.
  *  The returned proc takes a variable number of arguments, calls <i>g</i> with them
  *  then calls this method with the result.
  *

test/ruby/test_method.rb

@@ -1064,14 +1064,28 @@ def f(x) x * 2 end
     assert_equal(6, h.call(2))
   end
 
-  def test_compose_with_nonproc_or_method
+  def test_compose_with_callable
+    c = Class.new {
+      def f(x) x * 2 end
+    }
+    c2 = Class.new {
+      def call(x) x + 1 end
+    }
+    f = c.new.method(:f)
+    g = f * c2.new
+
+    assert_equal(6, g.call(2))
+  end
+
+  def test_compose_with_noncallable
     c = Class.new {
       def f(x) x * 2 end
     }
     f = c.new.method(:f)
+    g = f * 5
 
-    assert_raise(TypeError) {
-      f * 5
+    assert_raise(NoMethodError) {
+      g.call(2)
     }
   end
 end

test/ruby/test_proc.rb

@@ -1460,11 +1460,22 @@ def g(x) x + 1 end
     assert_equal(6, h.call(2))
   end
 
-  def test_compose_with_nonproc_or_method
+  def test_compose_with_callable
     f = proc {|x| x * 2}
+    c = Class.new {
+      def call(x) x + 1 end
+    }
+    g = f * c.new
+
+    assert_equal(6, g.call(2))
+  end
+
+  def test_compose_with_noncallable
+    f = proc {|x| x * 2}
+    g = f * 5
 
-    assert_raise(TypeError) {
-      f * 5
+    assert_raise(NoMethodError) {
+      g.call(2)
     }
   end
 end