proc.c: proc without block

* proc.c (proc_new): promoted lambda/proc/Proc.new with no block
  in a method called with a block to a warning/error.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@66772 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

NEWS

@@ -17,6 +17,11 @@ sufficient information, see the ChangeLog file or Redmine
 * Method reference operator, <code>.:</code> is introduced as an
   experimental feature.  [Feature #12125] [Feature #13581]
 
+* Proc.new and proc with no block in a method called with a block is warned
+  now.
+
+* lambda with no block in a method called with a block errs.
+
 === Core classes updates (outstanding ones only)
 
 === Stdlib updates (outstanding ones only)

lib/matrix.rb

@@ -514,12 +514,11 @@ class Matrix
   #     # => prints the numbers 1 to 4
   #   Matrix[ [1,2], [3,4] ].each(:strict_lower).to_a # => [3]
   #
-  def each(which = :all) # :yield: e
+  def each(which = :all, &block) # :yield: e
     return to_enum :each, which unless block_given?
     last = column_count - 1
     case which
     when :all
-      block = Proc.new
       @rows.each do |row|
         row.each(&block)
       end

lib/prime.rb

@@ -283,9 +283,9 @@ class Prime
     end
 
     # see +Enumerator+#with_index.
-    def with_index(offset = 0)
-      return enum_for(:with_index, offset) { Float::INFINITY } unless block_given?
-      return each_with_index(&proc) if offset == 0
+    def with_index(offset = 0, &block)
+      return enum_for(:with_index, offset) { Float::INFINITY } unless block
+      return each_with_index(&block) if offset == 0
 
       each do |prime|
         yield prime, offset

proc.c

@@ -707,6 +707,9 @@ proc_new(VALUE klass, int8_t is_lambda)
 
 	if ((block_handler = rb_vm_frame_block_handler(cfp)) != VM_BLOCK_HANDLER_NONE) {
 	    if (is_lambda) {
+                rb_raise(rb_eArgError, proc_without_block);
+            }
+            else {
 		rb_warn(proc_without_block);
 	    }
 	}

spec/ruby/core/kernel/proc_spec.rb

@@ -36,6 +36,7 @@ describe "Kernel.proc" do
 end
 
 describe "Kernel#proc" do
+  ruby_version_is ""..."2.7" do
     it "uses the implicit block from an enclosing method" do
       def some_method
         proc
@@ -45,6 +46,19 @@ describe "Kernel#proc" do
 
       prc.call.should == "hello"
     end
+  end
+
+  ruby_version_is "2.7" do
+    it "can be created when called with no block" do
+      def some_method
+        proc
+      end
+
+      -> {
+        some_method { "hello" }
+      }.should complain(/tried to create Proc object without a block/)
+    end
+  end
 
   it "needs to be reviewed for spec completeness"
 end

spec/ruby/core/proc/block_pass_spec.rb

@@ -20,7 +20,8 @@ describe "Proc as a block pass argument" do
   end
 end
 
-describe "Proc as an implicit block pass argument" do
+ruby_version_is ""..."2.7" do
+  describe "Proc as an implicit block pass argument" do
     def revivify
       Proc.new
     end
@@ -38,4 +39,20 @@ describe "Proc as an implicit block pass argument" do
       p.should equal p2
       p.should == p2
     end
+  end
+end
+
+ruby_version_is "2.7" do
+  describe "Proc called with no block" do
+    def revivify
+      Proc.new
+    end
+
+    it "raises ArgumentError when called with no block" do
+      p = Proc.new {}
+      -> {
+        revivify(&p)
+      }.should
+    end
+  end
 end

spec/ruby/core/proc/new_spec.rb

@@ -95,6 +95,7 @@ describe "Proc.new with an associated block" do
     obj.second.should == 2
   end
 
+  ruby_version_is ""..."2.7" do
     it "returns a new Proc instance from the block passed to the containing method" do
       prc = ProcSpecs.new_proc_in_method { "hello" }
       prc.should be_an_instance_of(Proc)
@@ -106,6 +107,7 @@ describe "Proc.new with an associated block" do
       prc.should be_an_instance_of(ProcSpecs::ProcSubclass)
       prc.call.should == "hello"
     end
+  end
 end
 
 describe "Proc.new with a block argument" do
@@ -178,6 +180,7 @@ describe "Proc.new without a block" do
     lambda { ProcSpecs.new_proc_subclass_in_method }.should raise_error(ArgumentError)
   end
 
+  ruby_version_is ""..."2.7" do
     it "uses the implicit block from an enclosing method" do
       def some_method
         Proc.new
@@ -187,4 +190,26 @@ describe "Proc.new without a block" do
 
       prc.call.should == "hello"
     end
+  end
+
+  ruby_version_is "2.7" do
+    it "can be created if invoked from within a method with a block" do
+      lambda { ProcSpecs.new_proc_in_method { "hello" } }.should complain(/tried to create Proc object without a block/)
+    end
+
+    it "can be created if invoked on a subclass from within a method with a block" do
+      lambda { ProcSpecs.new_proc_subclass_in_method { "hello" } }.should complain(/tried to create Proc object without a block/)
+    end
+
+
+    it "can be create when called with no block" do
+      def some_method
+        Proc.new
+      end
+
+      -> {
+        some_method { "hello" }
+      }.should complain(/tried to create Proc object without a block/)
+    end
+  end
 end

spec/ruby/language/lambda_spec.rb

@@ -310,6 +310,7 @@ describe "A lambda expression 'lambda { ... }'" do
       def meth; lambda; end
     end
 
+    ruby_version_is ""..."2.7" do
       it "can be created" do
         implicit_lambda = nil
         -> {
@@ -321,6 +322,16 @@ describe "A lambda expression 'lambda { ... }'" do
       end
     end
 
+    ruby_version_is "2.7" do
+      it "raises ArgumentError" do
+        implicit_lambda = nil
+        -> {
+          meth { 1 }
+        }.should raise_error(ArgumentError, /tried to create Proc object without a block/)
+      end
+    end
+  end
+
   context "assigns no local variables" do
     evaluate <<-ruby do
         @a = lambda { }

spec/ruby/optional/capi/proc_spec.rb

@@ -69,6 +69,7 @@ describe "C-API when calling Proc.new from a C function" do
   # For example: C -> Ruby <- C -> Ruby means a C function called into Ruby
   # code which returned to C, then C called into Ruby code again.
 
+  ruby_version_is ""..."2.7" do
     #   Ruby -> C -> rb_funcall(Proc.new)
     it "returns the Proc passed by the Ruby code calling the C function" do
       prc = @p.rb_Proc_new(0) { :called }
@@ -80,6 +81,7 @@ describe "C-API when calling Proc.new from a C function" do
       prc = @p.rb_Proc_new(1) { :called }
       prc.call.should == :called
     end
+  end
 
   # Ruby -> C -> Ruby -> Proc.new
   it "raises an ArgumentError when the C function calls a Ruby method that calls Proc.new" do
@@ -93,6 +95,7 @@ describe "C-API when calling Proc.new from a C function" do
     lambda { @p.rb_Proc_new(3) { :called } }.should raise_error(ArgumentError)
   end
 
+  ruby_version_is ""..."2.7" do
     # Ruby -> C -> Ruby -> C (with new block) -> rb_funcall(Proc.new)
     it "returns the most recent Proc passed when the Ruby method called the C function" do
       prc = @p.rb_Proc_new(4) { :called }
@@ -104,6 +107,7 @@ describe "C-API when calling Proc.new from a C function" do
       prc = @p.rb_Proc_new(5) { :called }
       prc.call.should == :called
     end
+  end
 
   # Ruby -> C -> Ruby -> block_given?
   it "returns false from block_given? in a Ruby method called by the C function" do

test/ruby/test_proc.rb

@@ -424,14 +424,14 @@ class TestProc < Test::Unit::TestCase
       1.times { b = lambda }
       b
     end
-    assert_equal(:foo, o.foo { :foo }.call)
+    assert_raise(ArgumentError) {o.foo { :foo }.call}
 
     def o.foo(&b)
       b = nil
       1.times { b = lambda }
       b
     end
-    assert_equal(:foo, o.foo { :foo }.call)
+    assert_raise(ArgumentError) {o.foo { :foo }.call}
   end
 
   def test_arity2