Decide lambdaness of (f << g) using g (#2729)

* Deciding lambdaness of (f << g) using g

* Use version guards for spec changes

proc.c

@@ -3386,8 +3386,14 @@ rb_proc_compose_to_left(VALUE self, VALUE g)
     procs[1] = g;
     args = rb_ary_tmp_new_from_values(0, 2, procs);
 
-    GetProcPtr(self, procp);
-    is_lambda = procp->is_lambda;
+    if (rb_obj_is_proc(g)) {
+        GetProcPtr(g, procp);
+        is_lambda = procp->is_lambda;
+    }
+    else {
+        VM_ASSERT(rb_obj_is_method(g) || rb_obj_respond_to(g, idCall, TRUE));
+        is_lambda = 1;
+    }
 
     proc = rb_proc_new(compose, args);
     GetProcPtr(proc, procp);

spec/ruby/core/method/compose_spec.rb

@@ -39,7 +39,8 @@ ruby_version_is "2.6" do
         double = proc { |x| x + x }
 
         (pow_2 << double).is_a?(Proc).should == true
-        (pow_2 << double).lambda?.should == true
+        ruby_version_is(''...'2.8') { (pow_2 << double).lambda?.should == true }
+        ruby_version_is('2.8') { (pow_2 << double).lambda?.should == false }
       end
 
       it "may accept multiple arguments" do

test/ruby/test_proc.rb

@@ -1413,9 +1413,13 @@ class TestProc < Test::Unit::TestCase
   def test_compose_with_lambda
     f = lambda {|x| x * 2}
     g = lambda {|x| x}
+    not_lambda = proc {|x| x}
 
     assert_predicate((f << g), :lambda?)
     assert_predicate((g >> f), :lambda?)
+    assert_predicate((not_lambda << f), :lambda?)
+    assert_not_predicate((f << not_lambda), :lambda?)
+    assert_not_predicate((not_lambda >> f), :lambda?)
   end
 
   def test_compose_with_method
@@ -1427,6 +1431,7 @@ class TestProc < Test::Unit::TestCase
 
     assert_equal(6, (f << g).call(2))
     assert_equal(5, (f >> g).call(2))
+    assert_predicate((f << g), :lambda?)
   end
 
   def test_compose_with_callable
@@ -1438,6 +1443,7 @@ class TestProc < Test::Unit::TestCase
 
     assert_equal(6, (f << g).call(2))
     assert_equal(5, (f >> g).call(2))
+    assert_predicate((f << g), :lambda?)
   end
 
   def test_compose_with_noncallable