Add rb_arithmetic_sequence_beg_len_step function

Fix test/mri/tests/cext-ruby/arith_seq/test_arith_seq_beg_len_step.rb
test failed with error:

```
assert_separately failed with error message
pid 23810 exit 1
| <internal:core> core/truffle/polyglot.rb:324:in `marshal_dump': Foreign exception cannot be dumped: #<Polyglot::ForeignException:0x4a3bf37c: External LLVMFunction rb_arithmetic_sequence_beg_len_step cannot be found.> (TypeError)
| 	from <internal:core> core/marshal.rb:1289:in `serialize_user_marshal'
| 	from <internal:core> core/marshal.rb:1107:in `serialize'
| 	from <internal:core> core/marshal.rb:1453:in `dump'
| 	from /Users/graal/slave/e/main/test/mri/tests/lib/core_assertions.rb:260:in `block in separated_runner'
| /Users/graal/slave/e/main/test/mri/tests/cext-c/arith_seq/beg_len_step/beg_len_step.c:4:in `arith_seq_s_beg_len_step': External LLVMFunction rb_arithmetic_sequence_beg_len_step cannot be found. (Polyglot::ForeignException)
| 	from /Users/graal/slave/e/graal/sdk/mxbuild/darwin-amd64/GRAALVM_A629582E5D_JAVA21/graalvm-a629582e5d-java21-23.1.0-dev/Contents/Home/languages/ruby/lib/truffle/truffle/cext_ruby.rb:42:in `<unknown>'
| 	from /Users/graal/slave/e/graal/sdk/mxbuild/darwin-amd64/GRAALVM_A629582E5D_JAVA21/graalvm-a629582e5d-java21-23.1.0-dev/Contents/Home/languages/ruby/lib/truffle/truffle/cext_ruby.rb:42:in `Enumerator::ArithmeticSequence.__beg_len_step_
```

Author: andrykonchin

lib/cext/include/ruby/internal/globals.h

@@ -72,6 +72,7 @@ RUBY_EXTERN VALUE rb_cClass;                  /**< `Class` class. */
 RUBY_EXTERN VALUE rb_cDir;                    /**< `Dir` class. */
 RUBY_EXTERN VALUE rb_cEncoding;               /**< `Encoding` class. */
 RUBY_EXTERN VALUE rb_cEnumerator;             /**< `Enumerator` class. */
+RUBY_EXTERN VALUE rb_cArithSeq;               /**< `Enumerator::ArithmeticSequence` class. */
 RUBY_EXTERN VALUE rb_cFalseClass;             /**< `FalseClass` class. */
 RUBY_EXTERN VALUE rb_cFile;                   /**< `File` class. */
 RUBY_EXTERN VALUE rb_cComplex;                /**< `Complex` class. */

lib/cext/include/truffleruby/truffleruby-abi-version.h

@@ -20,6 +20,6 @@
 // $RUBY_VERSION must be the same as TruffleRuby.LANGUAGE_VERSION.
 // $ABI_NUMBER starts at 1 and is incremented for every ABI-incompatible change.
 
-#define TRUFFLERUBY_ABI_VERSION "3.3.7.1"
+#define TRUFFLERUBY_ABI_VERSION "3.3.7.2"
 
 #endif

lib/truffle/truffle/cext_constants.rb

@@ -8,7 +8,7 @@
 # GNU General Public License version 2, or
 # GNU Lesser General Public License version 2.1.
 
-# GENERATED BY tool/generate-cext-constants.rb
+# GENERATED BY tool/generate-cext-constants.rb AND SHOULD NOT BE MODIFIED MANUALLY
 
 module Truffle::CExt
   def rb_cArray
@@ -51,6 +51,10 @@ def rb_cEnumerator
     Enumerator
   end
 
+  def rb_cArithSeq
+    Enumerator::ArithmeticSequence
+  end
+
   def rb_cFalseClass
     FalseClass
   end

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

@@ -38,11 +38,49 @@ VALUE range_spec_rb_range_beg_len(VALUE self, VALUE range, VALUE begpv, VALUE le
   return ary;
 }
 
+VALUE range_spec_rb_arithmetic_sequence_extract(VALUE self, VALUE object) {
+  VALUE ary = rb_ary_new();
+  rb_arithmetic_sequence_components_t components;
+
+  int status = rb_arithmetic_sequence_extract(object, &components);
+
+  if (!status) {
+      rb_ary_store(ary, 0, LONG2FIX(status));
+      return ary;
+  }
+
+  rb_ary_store(ary, 0, LONG2FIX(status));
+  rb_ary_store(ary, 1, components.begin);
+  rb_ary_store(ary, 2, components.end);
+  rb_ary_store(ary, 3, components.step);
+  rb_ary_store(ary, 4, components.exclude_end ? Qtrue : Qfalse);
+  return ary;
+}
+
+VALUE range_spec_rb_arithmetic_sequence_beg_len_step(VALUE self, VALUE aseq, VALUE lenv, VALUE errv) {
+  long begp, lenp, stepp;
+
+  long len = FIX2LONG(lenv);
+  int err = FIX2INT(errv);
+
+  VALUE success = rb_arithmetic_sequence_beg_len_step(aseq, &begp, &lenp, &stepp, len, err);
+
+  VALUE ary = rb_ary_new();
+  rb_ary_store(ary, 0, success);
+  rb_ary_store(ary, 1, LONG2FIX(begp));
+  rb_ary_store(ary, 2, LONG2FIX(lenp));
+  rb_ary_store(ary, 3, LONG2FIX(stepp));
+
+  return ary;
+}
+
 void Init_range_spec(void) {
   VALUE cls = rb_define_class("CApiRangeSpecs", rb_cObject);
   rb_define_method(cls, "rb_range_new", range_spec_rb_range_new, -1);
   rb_define_method(cls, "rb_range_values", range_spec_rb_range_values, 1);
   rb_define_method(cls, "rb_range_beg_len", range_spec_rb_range_beg_len, 5);
+  rb_define_method(cls, "rb_arithmetic_sequence_extract", range_spec_rb_arithmetic_sequence_extract, 1);
+  rb_define_method(cls, "rb_arithmetic_sequence_beg_len_step", range_spec_rb_arithmetic_sequence_beg_len_step, 3);
 }
 
 #ifdef __cplusplus

spec/ruby/optional/capi/range_spec.rb

@@ -92,4 +92,140 @@ def range_like.exclude_end?
       result.should be_nil
     end
   end
+
+  describe "rb_arithmetic_sequence_extract" do
+    it "returns begin, end, step, exclude end of an instance of an Enumerator::ArithmeticSequence" do
+      enum = (10..20).step(5)
+      enum.should.kind_of?(Enumerator::ArithmeticSequence)
+
+      @s.rb_arithmetic_sequence_extract(enum).should == [1, 10, 20, 5, false]
+    end
+
+    it "returns begin, end, step, exclude end of an instance of a Range" do
+      range = (10..20)
+      @s.rb_arithmetic_sequence_extract(range).should == [1, 10, 20, 1, false]
+    end
+
+    it "returns begin, end, step, exclude end of a non-Range object with Range properties" do
+      object = Object.new
+      def object.begin
+        10
+      end
+      def object.end
+        20
+      end
+      def object.exclude_end?
+        false
+      end
+
+      @s.rb_arithmetic_sequence_extract(object).should == [1, 10, 20, 1, false]
+    end
+
+    it "returns failed status if given object is not Enumerator::ArithmeticSequence or Range or Range-like object" do
+      object = Object.new
+      @s.rb_arithmetic_sequence_extract(object).should == [0]
+    end
+  end
+
+  describe "rb_arithmetic_sequence_beg_len_step" do
+    it "returns correct begin, length, step and result" do
+      as = (2..5).step(5)
+      error_code = 0
+
+      success, beg, len, step = @s.rb_arithmetic_sequence_beg_len_step(as, 6, error_code)
+      success.should be_true
+
+      beg.should == 2
+      len.should == 4
+      step.should == 5
+    end
+
+    it "takes into account excluded end boundary" do
+      as = (2...5).step(1)
+      error_code = 0
+
+      success, _, len, _ = @s.rb_arithmetic_sequence_beg_len_step(as, 6, error_code)
+      success.should be_true
+      len.should == 3
+    end
+
+    it "adds length to negative begin boundary" do
+      as = (-2..5).step(1)
+      error_code = 0
+
+      success, beg, len, _ = @s.rb_arithmetic_sequence_beg_len_step(as, 6, error_code)
+      success.should be_true
+
+      beg.should == 4
+      len.should == 2
+    end
+
+    it "adds length to negative end boundary" do
+      as = (2..-1).step(1)
+      error_code = 0
+
+      success, beg, len, _ = @s.rb_arithmetic_sequence_beg_len_step(as, 6, error_code)
+      success.should be_true
+
+      beg.should == 2
+      len.should == 4
+    end
+
+    it "truncates arithmetic sequence length if end boundary greater than specified length value" do
+      as = (2..10).step(1)
+      error_code = 0
+
+      success, _, len, _ = @s.rb_arithmetic_sequence_beg_len_step(as, 6, error_code)
+      success.should be_true
+      len.should == 4
+    end
+
+    it "returns inverted begin and end boundaries when step is negative" do
+      as = (2..5).step(-2)
+      error_code = 0
+
+      success, beg, len, step = @s.rb_arithmetic_sequence_beg_len_step(as, 6, error_code)
+      success.should be_true
+
+      beg.should == 5
+      len.should == 0
+      step.should == -2
+    end
+
+    it "returns nil when not in range and error code = 0" do
+      as = (2..5).step(1)
+      error_code = 0
+
+      success, = @s.rb_arithmetic_sequence_beg_len_step(as, 1, error_code)
+      success.should be_nil
+    end
+
+    it "returns nil when not in range, negative boundaries and error code = 0" do
+      as = (-5..-1).step(1)
+      error_code = 0
+
+      success, = @s.rb_arithmetic_sequence_beg_len_step(as, 1, 0)
+      success.should be_nil
+    end
+
+    it "returns begin, length and step and doesn't raise a RangeError when not in range and error code = 1" do
+      as = (2..5).step(1)
+      error_code = 1
+
+      success, beg, len, step = @s.rb_arithmetic_sequence_beg_len_step(as, 1, error_code)
+      success.should be_true
+
+      beg.should == 2
+      len.should == 4
+      step.should == 1
+    end
+
+    it "returns nil and doesn't raise a RangeError when not in range, negative boundaries and error code = 1" do
+      as = (-5..-1).step(1)
+      error_code = 1
+
+      success, = @s.rb_arithmetic_sequence_beg_len_step(as, 1, error_code)
+      success.should be_nil
+    end
+  end
 end

src/main/c/cext/cext_constants.c

@@ -8,7 +8,7 @@
  * GNU Lesser General Public License version 2.1.
  */
 
-// GENERATED BY tool/generate-cext-constants.rb
+// GENERATED BY tool/generate-cext-constants.rb AND SHOULD NOT BE MODIFIED MANUALLY
 
 #include <ruby.h>
 
@@ -22,6 +22,7 @@ VALUE rb_cDir;
 VALUE rb_cEncoding;
 VALUE rb_mEnumerable;
 VALUE rb_cEnumerator;
+VALUE rb_cArithSeq;
 VALUE rb_cFalseClass;
 VALUE rb_cFile;
 VALUE rb_mFileTest;
@@ -102,6 +103,7 @@ void rb_tr_init_global_constants(VALUE (*get_constant)(const char*)) {
   rb_cEncoding = get_constant("rb_cEncoding");
   rb_mEnumerable = get_constant("rb_mEnumerable");
   rb_cEnumerator = get_constant("rb_cEnumerator");
+  rb_cArithSeq = get_constant("rb_cArithSeq");
   rb_cFalseClass = get_constant("rb_cFalseClass");
   rb_cFile = get_constant("rb_cFile");
   rb_mFileTest = get_constant("rb_mFileTest");

src/main/c/cext/enum.c

@@ -11,6 +11,8 @@
 
 // Enumerable and Enumerator, rb_enum*
 
+VALUE rb_range_component_beg_len(VALUE b, VALUE e, int excl, long *begp, long *lenp, long len, int err);
+
 VALUE rb_enumeratorize(VALUE obj, VALUE meth, int argc, const VALUE *argv) {
   return RUBY_CEXT_INVOKE("rb_enumeratorize", obj, meth, rb_ary_new4(argc, argv));
 }
@@ -19,3 +21,63 @@ VALUE rb_enumeratorize(VALUE obj, VALUE meth, int argc, const VALUE *argv) {
 VALUE rb_enumeratorize_with_size(VALUE obj, VALUE meth, int argc, const VALUE *argv, rb_enumerator_size_func *size_fn) {
   return rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_enumeratorize_with_size", rb_tr_unwrap(obj), rb_tr_unwrap(meth), rb_tr_unwrap(rb_ary_new4(argc, argv)), size_fn));
 }
+
+int rb_arithmetic_sequence_extract(VALUE obj, rb_arithmetic_sequence_components_t *component) {
+    if (rb_obj_is_kind_of(obj, rb_cArithSeq)) {
+        component->begin       = rb_ivar_get(obj, rb_intern("@begin"));
+        component->end         = rb_ivar_get(obj, rb_intern("@end"));
+        component->step        = rb_ivar_get(obj, rb_intern("@step"));
+        component->exclude_end = rb_ivar_get(obj, rb_intern("@exclude_end"));
+        return 1;
+    } else if (rb_range_values(obj, &component->begin, &component->end, &component->exclude_end)) {
+        component->step  = INT2FIX(1);
+        return 1;
+    }
+
+    return 0;
+}
+
+VALUE rb_arithmetic_sequence_beg_len_step(VALUE obj, long *begp, long *lenp, long *stepp, long len, int err) {
+    RBIMPL_NONNULL_ARG(begp);
+    RBIMPL_NONNULL_ARG(lenp);
+    RBIMPL_NONNULL_ARG(stepp);
+
+    rb_arithmetic_sequence_components_t aseq;
+    if (!rb_arithmetic_sequence_extract(obj, &aseq)) {
+        return Qfalse;
+    }
+
+    long step = NIL_P(aseq.step) ? 1 : NUM2LONG(aseq.step);
+    *stepp = step;
+
+    if (step < 0) {
+        if (aseq.exclude_end && !NIL_P(aseq.end)) {
+            /* Handle exclusion before range reversal */
+            aseq.end = LONG2NUM(NUM2LONG(aseq.end) + 1);
+
+            /* Don't exclude the previous beginning */
+            aseq.exclude_end = 0;
+        }
+        VALUE tmp = aseq.begin;
+        aseq.begin = aseq.end;
+        aseq.end = tmp;
+    }
+
+    if (err == 0 && (step < -1 || step > 1)) {
+        if (rb_range_component_beg_len(aseq.begin, aseq.end, aseq.exclude_end, begp, lenp, len, 1) == Qtrue) {
+            if (*begp > len) {
+                goto out_of_range;
+            }
+            if (*lenp > len) {
+                goto out_of_range;
+            }
+            return Qtrue;
+        }
+    } else {
+        return rb_range_component_beg_len(aseq.begin, aseq.end, aseq.exclude_end, begp, lenp, len, err);
+    }
+
+  out_of_range:
+    rb_raise(rb_eRangeError, "%+"PRIsVALUE" out of range", obj);
+    return Qnil;
+}

src/main/c/cext/range.c

@@ -34,6 +34,72 @@ int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp) {
   return Qtrue;
 }
 
+// NOTE: this is not a public API function but a helper function from CRuby
+
+/* Extract the components of a Range.
+ *
+ * You can use +err+ to control the behavior of out-of-range and exception.
+ *
+ * When +err+ is 0 or 2, if the begin offset is greater than +len+,
+ * it is out-of-range.  The +RangeError+ is raised only if +err+ is 2,
+ * in this case.  If +err+ is 0, +Qnil+ will be returned.
+ *
+ * When +err+ is 1, the begin and end offsets won't be adjusted even if they
+ * are greater than +len+.  It allows +rb_ary_aset+ extends arrays.
+ *
+ * If the begin component of the given range is negative and is too-large
+ * abstract value, the +RangeError+ is raised only +err+ is 1 or 2.
+ *
+ * The case of <code>err = 0</code> is used in item accessing methods such as
+ * +rb_ary_aref+, +rb_ary_slice_bang+, and +rb_str_aref+.
+ *
+ * The case of <code>err = 1</code> is used in Array's methods such as
+ * +rb_ary_aset+ and +rb_ary_fill+.
+ *
+ * The case of <code>err = 2</code> is used in +rb_str_aset+.
+ */
+VALUE rb_range_component_beg_len(VALUE b, VALUE e, int excl, long *begp, long *lenp, long len, int err) {
+    long beg, end;
+
+    beg = NIL_P(b) ? 0 : NUM2LONG(b);
+    end = NIL_P(e) ? -1 : NUM2LONG(e);
+    if (NIL_P(e)) {
+        excl = 0;
+    }
+
+    if (beg < 0) {
+        beg += len;
+        if (beg < 0) {
+            goto out_of_range;
+        }
+    }
+    if (end < 0) {
+        end += len;
+    }
+    if (!excl) {
+        end++;         /* include end point */
+    }
+    if (err == 0 || err == 2) {
+        if (beg > len) {
+            goto out_of_range;
+        }
+        if (end > len) {
+            end = len;
+        }
+    }
+    len = end - beg;
+    if (len < 0) {
+        len = 0;
+    }
+
+    *begp = beg;
+    *lenp = len;
+    return Qtrue;
+
+  out_of_range:
+    return Qnil;
+}
+
 VALUE rb_range_beg_len(VALUE range, long *begp, long *lenp, long len, int err) {
   long beg, end, origbeg, origend;
   VALUE b, e;