Remove rb_iterate deprecated since 1.9

Author: nobu

ext/-test-/cxxanyargs/cxxanyargs.cpp

@@ -97,31 +97,6 @@ struct test_rb_define_hooked_variable {
 };
 VALUE test_rb_define_hooked_variable::v = Qundef;
 
-namespace test_rb_iterate {
-    VALUE
-    iter(VALUE self)
-    {
-        return rb_funcall(self, rb_intern("yield"), 0);
-    }
-
-    VALUE
-    block(RB_BLOCK_CALL_FUNC_ARGLIST(arg, param))
-    {
-        return rb_funcall(arg, rb_intern("=="), 1, param);
-    }
-
-    VALUE
-    test(VALUE self)
-    {
-#ifdef HAVE_NULLPTR
-        rb_iterate(iter, self, nullptr, self);
-#endif
-
-        rb_iterate(iter, self, RUBY_METHOD_FUNC(block), self); // old
-        return rb_iterate(iter, self, block, self); // new
-    }
-}
-
 namespace test_rb_block_call {
     VALUE
     block(RB_BLOCK_CALL_FUNC_ARGLIST(arg, param))
@@ -936,7 +911,6 @@ Init_cxxanyargs(void)
 
     test(rb_define_virtual_variable);
     test(rb_define_hooked_variable);
-    test(rb_iterate);
     test(rb_block_call);
     test(rb_rescue);
     test(rb_rescue2);

include/ruby/backward/cxxanyargs.hpp

@@ -190,33 +190,6 @@ rb_define_hooked_variable(const char *q, VALUE *w, std::nullptr_t e, void_type *
 /// @name Exceptions and tag jumps
 /// @{
 
-// RUBY_CXX_DEPRECATED("by rb_block_call since 1.9")
-RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
-/// @brief       Old way to implement iterators.
-/// @param[in]   q  A function that can yield.
-/// @param[in]   w  Passed to `q`.
-/// @param[in]   e  What is to be yielded.
-/// @param[in]   r  Passed to `e`.
-/// @return      The return value of `q`.
-/// @note        `e` can be nullptr.
-/// @deprecated  This function is obsoleted since  long before 2.x era.  Do not
-///              use it any longer.  rb_block_call() is provided instead.
-inline VALUE
-rb_iterate(onearg_type *q, VALUE w, type *e, VALUE r)
-{
-    rb_block_call_func_t t = reinterpret_cast<rb_block_call_func_t>(e);
-    return backward::rb_iterate_deprecated(q, w, t, r);
-}
-
-#ifdef HAVE_NULLPTR
-RUBY_CXX_DEPRECATED("by rb_block_call since 1.9")
-inline VALUE
-rb_iterate(onearg_type *q, VALUE w, std::nullptr_t e, VALUE r)
-{
-    return backward::rb_iterate_deprecated(q, w, e, r);
-}
-#endif
-
 RUBY_CXX_DEPRECATED("Use of ANYARGS in this function is deprecated")
 /// @brief       Call a method with a block.
 /// @param[in]   q  The self.

include/ruby/internal/iterator.h

@@ -265,48 +265,6 @@ int rb_block_given_p(void);
  */
 void rb_need_block(void);
 
-#ifndef __cplusplus
-RBIMPL_ATTR_DEPRECATED(("by: rb_block_call since 1.9"))
-#endif
-/**
- * Old way to iterate a block.
- *
- * @deprecated     This is an old API.  Use rb_block_call() instead.
- * @warning        The passed  function must at  least once call a  ruby method
- *                 (to handle interrupts etc.)
- * @param[in]      func1  A function that could yield a value.
- * @param[in,out]  data1  Passed to `func1`
- * @param[in]      proc   A function acts as a block.
- * @param[in,out]  data2  Passed to `proc` as the data2 parameter.
- * @return         What `func1` returns.
- */
-VALUE rb_iterate(VALUE (*func1)(VALUE), VALUE data1, rb_block_call_func_t proc, VALUE data2);
-
-#ifdef __cplusplus
-namespace ruby {
-namespace backward {
-/**
- * Old way to iterate a block.
- *
- * @deprecated     This is an old API.  Use rb_block_call() instead.
- * @warning        The passed  function must at  least once call a  ruby method
- *                 (to handle interrupts etc.)
- * @param[in]      iter   A function that could yield a value.
- * @param[in,out]  data1  Passed to `func1`
- * @param[in]      bl     A function acts as a block.
- * @param[in,out]  data2  Passed to `proc` as the data2 parameter.
- * @return         What `func1` returns.
- */
-static inline VALUE
-rb_iterate_deprecated(VALUE (*iter)(VALUE), VALUE data1, rb_block_call_func_t bl, VALUE data2)
-{
-    return ::rb_iterate(iter, data1, bl, data2);
-}}}
-
-RBIMPL_ATTR_DEPRECATED(("by: rb_block_call since 1.9"))
-VALUE rb_iterate(VALUE (*func1)(VALUE), VALUE data1, rb_block_call_func_t proc, VALUE data2);
-#endif
-
 /**
  * Identical to  rb_funcallv(), except it  additionally passes a function  as a
  * block.  When the  method yields, `proc` is called with  the yielded value as

spec/ruby/optional/capi/array_spec.rb

@@ -343,37 +343,39 @@
     end
   end
 
-  describe "rb_iterate" do
-    it "calls an callback function as a block passed to an method" do
-      s = [1,2,3,4]
-      s2 = @s.rb_iterate(s)
+  ruby_version_is ""..."4.0" do
+    describe "rb_iterate" do
+      it "calls an callback function as a block passed to an method" do
+        s = [1,2,3,4]
+        s2 = @s.rb_iterate(s)
 
-      s2.should == s
+        s2.should == s
 
-      # Make sure they're different objects
-      s2.equal?(s).should be_false
-    end
+        # Make sure they're different objects
+        s2.equal?(s).should be_false
+      end
 
-    it "calls a function with the other function available as a block" do
-      h = {a: 1, b: 2}
+      it "calls a function with the other function available as a block" do
+        h = {a: 1, b: 2}
 
-      @s.rb_iterate_each_pair(h).sort.should == [1,2]
-    end
+        @s.rb_iterate_each_pair(h).sort.should == [1,2]
+      end
 
-    it "calls a function which can yield into the original block" do
-      s2 = []
+      it "calls a function which can yield into the original block" do
+        s2 = []
 
-      o = Object.new
-      def o.each
-        yield 1
-        yield 2
-        yield 3
-        yield 4
-      end
+        o = Object.new
+        def o.each
+          yield 1
+          yield 2
+          yield 3
+          yield 4
+        end
 
-      @s.rb_iterate_then_yield(o) { |x| s2 << x }
+        @s.rb_iterate_then_yield(o) { |x| s2 << x }
 
-      s2.should == [1,2,3,4]
+        s2.should == [1,2,3,4]
+      end
     end
   end
 

spec/ruby/optional/capi/ext/array_spec.c

@@ -196,13 +196,15 @@ static VALUE copy_ary(RB_BLOCK_CALL_FUNC_ARGLIST(el, new_ary)) {
   return rb_ary_push(new_ary, el);
 }
 
+#ifndef RUBY_VERSION_IS_4_0
 static VALUE array_spec_rb_iterate(VALUE self, VALUE ary) {
   VALUE new_ary = rb_ary_new();
 
   rb_iterate(rb_each, ary, copy_ary, new_ary);
 
   return new_ary;
 }
+#endif
 
 static VALUE array_spec_rb_block_call(VALUE self, VALUE ary) {
   VALUE new_ary = rb_ary_new();
@@ -216,6 +218,7 @@ static VALUE sub_pair(RB_BLOCK_CALL_FUNC_ARGLIST(el, holder)) {
   return rb_ary_push(holder, rb_ary_entry(el, 1));
 }
 
+#ifndef RUBY_VERSION_IS_4_0
 static VALUE each_pair(VALUE obj) {
   return rb_funcall(obj, rb_intern("each_pair"), 0);
 }
@@ -227,6 +230,7 @@ static VALUE array_spec_rb_iterate_each_pair(VALUE self, VALUE obj) {
 
   return new_ary;
 }
+#endif
 
 static VALUE array_spec_rb_block_call_each_pair(VALUE self, VALUE obj) {
   VALUE new_ary = rb_ary_new();
@@ -241,10 +245,12 @@ static VALUE iter_yield(RB_BLOCK_CALL_FUNC_ARGLIST(el, ary)) {
   return Qnil;
 }
 
+#ifndef RUBY_VERSION_IS_4_0
 static VALUE array_spec_rb_iterate_then_yield(VALUE self, VALUE obj) {
   rb_iterate(rb_each, obj, iter_yield, obj);
   return Qnil;
 }
+#endif
 
 static VALUE array_spec_rb_block_call_then_yield(VALUE self, VALUE obj) {
   rb_block_call(obj, rb_intern("each"), 0, 0, iter_yield, obj);
@@ -308,9 +314,11 @@ void Init_array_spec(void) {
   rb_define_method(cls, "rb_ary_plus", array_spec_rb_ary_plus, 2);
   rb_define_method(cls, "rb_ary_unshift", array_spec_rb_ary_unshift, 2);
   rb_define_method(cls, "rb_assoc_new", array_spec_rb_assoc_new, 2);
+#ifndef RUBY_VERSION_IS_4_0
   rb_define_method(cls, "rb_iterate", array_spec_rb_iterate, 1);
   rb_define_method(cls, "rb_iterate_each_pair", array_spec_rb_iterate_each_pair, 1);
   rb_define_method(cls, "rb_iterate_then_yield", array_spec_rb_iterate_then_yield, 1);
+#endif
   rb_define_method(cls, "rb_block_call", array_spec_rb_block_call, 1);
   rb_define_method(cls, "rb_block_call_each_pair", array_spec_rb_block_call_each_pair, 1);
   rb_define_method(cls, "rb_block_call_then_yield", array_spec_rb_block_call_then_yield, 1);

vm_eval.c

@@ -1533,13 +1533,6 @@ rb_iterate_internal(VALUE (* it_proc)(VALUE), VALUE data1,
                        GET_EC());
 }
 
-VALUE
-rb_iterate(VALUE (* it_proc)(VALUE), VALUE data1,
-           rb_block_call_func_t bl_proc, VALUE data2)
-{
-    return rb_iterate_internal(it_proc, data1, bl_proc, data2);
-}
-
 struct iter_method_arg {
     VALUE obj;
     ID mid;