artichoke_backend/convert/
conv.rs

1//! Implicit conversion routines based on `convert_type_with_id` in CRuby.
2//!
3//! See: <https://github.com/ruby/ruby/blob/v3_4_1/object.c#L3095-L3235>.
4
5use artichoke_core::debug::Debug as _;
6use artichoke_core::value::Value as _;
7use mezzaluna_conversion_methods::{ConvMethod, InitError};
8use spinoso_exception::{Fatal, TypeError};
9
10use crate::ffi::InterpreterExtractError;
11use crate::types::Ruby;
12use crate::value::Value;
13use crate::{Artichoke, Error};
14
15impl From<InitError> for Error {
16    fn from(err: InitError) -> Self {
17        Self::from(Fatal::with_message(err.message()))
18    }
19}
20
21/// Strategy to use for handling errors in [`convert_type`].
22#[derive(Debug, Clone, Copy, PartialEq, Eq)]
23pub enum ConvertOnError {
24    /// Turn conversion errors into `TypeError`s.
25    Raise,
26    /// Turn conversion errors into a successful `nil` value.
27    ReturnNil,
28}
29
30impl Artichoke {
31    fn find_conversion_method(&mut self, method: &str) -> Result<ConvMethod, Error> {
32        let state = self.state.as_deref_mut().ok_or_else(InterpreterExtractError::new)?;
33        let symbols = &mut state.symbols;
34
35        let conv = state
36            .conv_method_table
37            .find_method(symbols, method)?
38            .ok_or_else(|| Fatal::from(format!("{method} is not a valid conversion method")))?;
39        Ok(conv)
40    }
41}
42
43/// Attempt a fallible conversion of a Ruby value to a given type tag.
44///
45/// This function can convert Ruby values at the granularity of a [`Ruby`] type
46/// tag. Conversion works as follows:
47///
48/// - If the given value has the same type tag as the given `convert_to`, return
49///   the given value.
50/// - Assert that the given conversion method is a valid conversion type.
51/// - Call the conversion method on the given value. If this method raises,
52///   return the error.
53/// - If the converted value does not match the given type tag, raise a
54///   [`TypeError`].
55/// - The converted value matches the target type, return it.
56///
57/// # Conversion types
58///
59/// The method to be called to perform the implicit conversion must be one of a
60/// permitted set. Valid method calls are:
61///
62/// - `to_int`
63/// - `to_ary`
64/// - `to_str`
65/// - `to_sym`
66/// - `to_hash`
67/// - `to_proc`
68/// - `to_io`
69/// - `to_a`
70/// - `to_s`
71/// - `to_i`
72/// - `to_f`
73/// - `to_r`
74///
75/// # MRI Compatibility
76///
77/// This function is modeled after the [`rb_convert_type`] C API in MRI Ruby.
78///
79/// [`rb_convert_type`]: https://github.com/ruby/ruby/blob/v3_1_2/object.c#L2993-L3004
80///
81/// # Panics
82///
83/// If the given method is not a valid conversion method, this function will
84/// panic.
85///
86/// # Errors
87///
88/// - If the call to the conversion method returns an error, that error is
89///   returned.
90/// - If the call to the conversion method returns a value that does not match
91///   the target type tag, a [`TypeError`] is returned.
92pub fn convert_type(
93    interp: &mut Artichoke,
94    value: Value,
95    convert_to: Ruby,
96    type_name: &str,
97    method: &str,
98    raise: ConvertOnError,
99) -> Result<Value, Error> {
100    if value.ruby_type() == convert_to {
101        return Ok(value);
102    }
103    let conversion = interp.find_conversion_method(method)?;
104    let converted = convert_type_inner(interp, value, type_name, &conversion, raise)?;
105
106    if converted.ruby_type() != convert_to {
107        return Err(conversion_mismatch(interp, value, type_name, method, converted).into());
108    }
109    Ok(converted)
110}
111
112/// Attempt a fallible conversion of a Ruby value to a given type tag or `nil`.
113///
114/// This function can convert Ruby values at the granularity of a [`Ruby`] type
115/// tag. Conversion works as follows:
116///
117/// - If the given value has the same type tag as the given `convert_to`, return
118///   the given value.
119/// - Assert that the given conversion method is a valid conversion type.
120/// - Call the conversion method on the given value. If this method raises,
121///   return the error.
122/// - If the converted value is `nil`, return `nil`.
123/// - If the converted value does not match the given type tag, raise a
124///   [`TypeError`].
125/// - The converted value matches the target type, return it.
126///
127/// # Conversion types
128///
129/// The method to be called to perform the implicit conversion must be one of a
130/// permitted set. Valid method calls are:
131///
132/// - `to_int`
133/// - `to_ary`
134/// - `to_str`
135/// - `to_sym`
136/// - `to_hash`
137/// - `to_proc`
138/// - `to_io`
139/// - `to_a`
140/// - `to_s`
141/// - `to_i`
142/// - `to_f`
143/// - `to_r`
144///
145/// # MRI Compatibility
146///
147/// This function is modeled after the [`rb_check_convert_type_with_id`] C API
148/// in MRI Ruby.
149///
150/// [`rb_check_convert_type_with_id`]: https://github.com/ruby/ruby/blob/v3_1_2/object.c#L3035-L3049
151///
152/// # Panics
153///
154/// If the given method is not a valid conversion method, this function will
155/// panic.
156///
157/// # Errors
158///
159/// - If the call to the conversion method returns an error, that error is
160///   returned.
161/// - If the call to the conversion method returns a value that does is non-`nil`
162///   and not match the target type tag, a [`TypeError`] is returned.
163pub fn check_convert_type(
164    interp: &mut Artichoke,
165    value: Value,
166    convert_to: Ruby,
167    type_name: &str,
168    method: &str,
169) -> Result<Value, Error> {
170    // always convert T_DATA
171    if value.ruby_type() == convert_to && convert_to != Ruby::Data {
172        return Ok(value);
173    }
174    let conversion = interp.find_conversion_method(method)?;
175    let converted = convert_type_inner(interp, value, type_name, &conversion, ConvertOnError::ReturnNil)?;
176
177    match converted.ruby_type() {
178        Ruby::Nil => Ok(Value::nil()),
179        tt if tt == convert_to => Ok(converted),
180        _ => Err(conversion_mismatch(interp, value, type_name, method, converted).into()),
181    }
182}
183
184// https://github.com/ruby/ruby/blob/v3_1_2/object.c#L2948-L2971
185fn convert_type_inner(
186    interp: &mut Artichoke,
187    value: Value,
188    type_name: &str,
189    conversion: &ConvMethod,
190    raise: ConvertOnError,
191) -> Result<Value, Error> {
192    if value.respond_to(interp, conversion.name())? {
193        return value.funcall(interp, conversion.name(), &[], None);
194    }
195    let mut message = match raise {
196        ConvertOnError::ReturnNil => return Ok(Value::nil()),
197        ConvertOnError::Raise if conversion.is_implicit() => String::from("no implicit conversion of "),
198        ConvertOnError::Raise => String::from("can't convert "),
199    };
200    match value.try_convert_into::<Option<bool>>(interp) {
201        Ok(None) => message.push_str("nil"),
202        Ok(Some(true)) => message.push_str("true"),
203        Ok(Some(false)) => message.push_str("false"),
204        Err(_) => message.push_str(interp.class_name_for_value(value)),
205    }
206    message.push_str(" into ");
207    message.push_str(type_name);
208    Err(TypeError::from(message).into())
209}
210
211// https://github.com/ruby/ruby/blob/v3_1_2/object.c#L2982-L2991
212fn conversion_mismatch(
213    interp: &mut Artichoke,
214    value: Value,
215    type_name: &str,
216    method: &str,
217    result: Value,
218) -> TypeError {
219    let cname = interp.inspect_type_name_for_value(value);
220
221    let mut message = String::from("can't convert ");
222    message.push_str(cname);
223    message.push_str(" to ");
224    message.push_str(type_name);
225    message.push_str(" (");
226    message.push_str(cname);
227    message.push('#');
228    message.push_str(method);
229    message.push_str(" gives ");
230    message.push_str(interp.class_name_for_value(result));
231    message.push(')');
232
233    TypeError::from(message)
234}
235
236#[inline]
237fn try_to_int(interp: &mut Artichoke, val: Value, method: &str, raise: ConvertOnError) -> Result<Value, Error> {
238    let conversion = interp.find_conversion_method(method)?;
239    convert_type_inner(interp, val, "Integer", &conversion, raise)
240}
241
242/// Fallible conversion of the given value to a Ruby `Integer` via `#to_int`.
243///
244/// If the given value is an integer, it is returned. If the give value responds
245/// to a `#to_int` method, it is called. Otherwise, a [`TypeError`] is raised.
246///
247/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
248/// a non-`nil` Ruby `Integer`.
249///
250/// # Errors
251///
252/// - If the call to `#to_int` returns an error, that error is returned.
253/// - If the call to `#to_int` returns anything other than a `Integer`, a
254///   [`TypeError`] is returned.
255#[inline]
256pub fn to_int(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
257    // Fast path (no additional funcalls) for values that are already integers.
258    if let Ruby::Fixnum = value.ruby_type() {
259        return Ok(value);
260    }
261    convert_type(interp, value, Ruby::Fixnum, "Integer", "to_int", ConvertOnError::Raise)
262}
263
264/// Fallible conversion of the given value to a Ruby `Integer` or `nil` via
265/// `#to_int`.
266///
267/// If the given value is an integer, it is returned. If the give value responds
268/// to a `#to_int` method, it is called. Otherwise, a [`TypeError`] is raised.
269///
270/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
271/// either a Ruby `Integer` or `nil`.
272///
273/// # Errors
274///
275/// - If the call to `#to_int` returns an error, that error is returned.
276/// - If the call to `#to_int` returns anything other than an `Integer` or `nil`,
277///   a [`TypeError`] is returned.
278#[inline]
279pub fn check_to_int(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
280    // Fast path (no additional funcalls) for values that are already integers.
281    if let Ruby::Fixnum = value.ruby_type() {
282        return Ok(value);
283    }
284    let value = try_to_int(interp, value, "to_int", ConvertOnError::ReturnNil)?;
285    let Ruby::Fixnum = value.ruby_type() else {
286        return Ok(Value::nil());
287    };
288    Ok(value)
289}
290
291/// Fallible coercion of the given value to a Ruby `Integer` via `#to_i`.
292///
293/// If the given value is an integer, it is returned. If the give value responds
294/// to a `#to_i` method, it is called. Otherwise, a [`TypeError`] is raised.
295///
296/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
297/// a non-`nil` Ruby `Integer`.
298///
299/// # Errors
300///
301/// - If the call to `#to_i` returns an error, that error is returned.
302/// - If the call to `#to_i` returns anything other than a `Integer`, a
303///   [`TypeError`] is returned.
304#[inline]
305pub fn to_i(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
306    if let Ruby::Fixnum = value.ruby_type() {
307        return Ok(value);
308    }
309    convert_type(interp, value, Ruby::Fixnum, "Integer", "to_i", ConvertOnError::Raise)
310}
311
312// NOTE: A `check_to_i` variant is only used in `Kernel#Integer`.
313//
314// This API is not necessary in Artichoke since exceptions are passed by value
315// instead of via unwinding.
316//
317// See: https://github.com/ruby/ruby/blob/v3_1_2/object.c#L3149
318/*
319#[inline(always)]
320pub(crate) fn check_to_i(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
321    // Fast path (no additional funcalls) for values that are already integers.
322    if let Ruby::Fixnum = value.ruby_type() {
323        return Ok(value);
324    }
325    let val = try_to_int(interp, val, "to_i", ConvertOnError::ReturnNil)?;
326    if let Ruby::Fixnum = val.ruby_type() {
327        Ok(val)
328    } else {
329        Ok(Value::nil())
330    }
331}
332*/
333
334/// Fallible conversion of the given value to a Ruby `String` via `#to_str`.
335///
336/// If the given value is a string, it is returned. If the give value responds
337/// to a `#to_str` method, it is called. Otherwise, a [`TypeError`] is raised.
338///
339/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
340/// a non-`nil` Ruby `String`.
341///
342/// # Errors
343///
344/// - If the call to `#to_str` returns an error, that error is returned.
345/// - If the call to `#to_str` returns anything other than a `String`, a
346///   [`TypeError`] is returned.
347pub fn to_str(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
348    convert_type(interp, value, Ruby::String, "String", "to_str", ConvertOnError::Raise)
349}
350
351/// Fallible conversion of the given value to a Ruby `String` or `nil` via
352/// `#to_str`.
353///
354/// If the given value is a string, it is returned. If the give value responds
355/// to a `#to_str` method, it is called. Otherwise, a [`TypeError`] is raised.
356///
357/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
358/// either a Ruby `String` or `nil`.
359///
360/// # Errors
361///
362/// - If the call to `#to_str` returns an error, that error is returned.
363/// - If the call to `#to_str` returns anything other than a `String` or `nil`,
364///   a [`TypeError`] is returned.
365pub fn check_to_str(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
366    check_convert_type(interp, value, Ruby::String, "String", "to_str")
367}
368
369pub fn check_string_type(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
370    check_convert_type(interp, value, Ruby::String, "String", "to_str")
371}
372
373/// Fallible conversion of the given value to a Ruby `Array` via `#to_ary`.
374///
375/// If the given value is a array, it is returned. If the give value responds
376/// to a `#to_ary` method, it is called. Otherwise, a [`TypeError`] is raised.
377///
378/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
379/// a non-`nil` Ruby `Array`.
380///
381/// # Errors
382///
383/// - If the call to `#to_ary` returns an error, that error is returned.
384/// - If the call to `#to_ary` returns anything other than an `Array`, a
385///   [`TypeError`] is returned.
386pub fn to_ary(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
387    convert_type(interp, value, Ruby::Array, "Array", "to_ary", ConvertOnError::Raise)
388}
389
390/// Fallible conversion of the given value to a Ruby `Array` or `nil` via
391/// `#to_ary`.
392///
393/// If the given value is a array, it is returned. If the give value responds
394/// to a `#to_ary` method, it is called. Otherwise, a [`TypeError`] is raised.
395///
396/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
397/// either a Ruby `Array` or `nil`.
398///
399/// # Errors
400///
401/// - If the call to `#to_ary` returns an error, that error is returned.
402/// - If the call to `#to_ary` returns anything other than an `Array` or `nil`,
403///   a [`TypeError`] is returned.
404pub fn check_to_ary(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
405    check_convert_type(interp, value, Ruby::Array, "Array", "to_ary")
406}
407
408/// Fallible coercion of the given value to a Ruby `Array` via `#to_a`.
409///
410/// If the given value is a array, it is returned. If the give value responds
411/// to a `#to_a` method, it is called. Otherwise, a [`TypeError`] is raised.
412///
413/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
414/// a non-`nil` Ruby `Array`.
415///
416/// # Errors
417///
418/// - If the call to `#to_a` returns an error, that error is returned.
419/// - If the call to `#to_a` returns anything other than an `Array`, a
420///   [`TypeError`] is returned.
421pub fn to_a(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
422    convert_type(interp, value, Ruby::Array, "Array", "to_a", ConvertOnError::Raise)
423}
424
425/// Fallible coercion of the given value to a Ruby `Array` or `nil` via `#to_a`.
426///
427/// If the given value is a array, it is returned. If the give value responds
428/// to a `#to_a` method, it is called. Otherwise, a [`TypeError`] is raised.
429///
430/// If this function returns [`Ok`], the returned [`Value`] is guaranteed to be
431/// either a Ruby `Array` or `nil`.
432///
433/// # Errors
434///
435/// - If the call to `#to_a` returns an error, that error is returned.
436/// - If the call to `#to_a` returns anything other than an `Array` or `nil`,
437///   a [`TypeError`] is returned.
438pub fn check_to_a(interp: &mut Artichoke, value: Value) -> Result<Value, Error> {
439    check_convert_type(interp, value, Ruby::Array, "Array", "to_a")
440}
441
442#[cfg(test)]
443mod tests {
444    use bstr::ByteSlice;
445
446    use super::{ConvertOnError, convert_type, to_int};
447    use crate::test::prelude::*;
448
449    #[test]
450    fn implicit_to_int_reflexive() {
451        let mut interp = interpreter();
452        let i = interp.convert(17);
453        let converted =
454            convert_type(&mut interp, i, Ruby::Fixnum, "Integer", "to_int", ConvertOnError::Raise).unwrap();
455        let converted = converted.try_convert_into::<i64>(&interp).unwrap();
456        assert_eq!(17, converted);
457    }
458
459    #[test]
460    fn implicit_to_int_conv() {
461        let mut interp = interpreter();
462        interp.eval(b"class A; def to_int; 17; end; end").unwrap();
463        let value = interp.eval(b"A.new").unwrap();
464        let converted = convert_type(
465            &mut interp,
466            value,
467            Ruby::Fixnum,
468            "Integer",
469            "to_int",
470            ConvertOnError::Raise,
471        )
472        .unwrap();
473        let converted = converted.try_convert_into::<i64>(&interp).unwrap();
474        assert_eq!(17, converted);
475    }
476
477    // ```console
478    // [3.1.2] > a = []
479    // => []
480    // [3.1.2] > a[true]
481    // (irb):2:in `<main>': no implicit conversion of true into Integer (TypeError)
482    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
483    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
484    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
485    // ```
486    #[test]
487    fn implicit_to_int_true_type_error() {
488        let mut interp = interpreter();
489        let value = interp.convert(true);
490        let err = convert_type(
491            &mut interp,
492            value,
493            Ruby::Fixnum,
494            "Integer",
495            "to_int",
496            ConvertOnError::Raise,
497        )
498        .unwrap_err();
499        assert_eq!(err.name(), "TypeError");
500        assert_eq!(
501            err.message().as_bstr(),
502            b"no implicit conversion of true into Integer".as_bstr()
503        );
504    }
505
506    // ```console
507    // [3.1.2] > a = []
508    // => []
509    // [3.1.2] > a[false]
510    // (irb):3:in `<main>': no implicit conversion of false into Integer (TypeError)
511    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
512    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
513    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
514    // ```
515    #[test]
516    fn implicit_to_int_false_type_error() {
517        let mut interp = interpreter();
518        let value = interp.convert(false);
519        let err = convert_type(
520            &mut interp,
521            value,
522            Ruby::Fixnum,
523            "Integer",
524            "to_int",
525            ConvertOnError::Raise,
526        )
527        .unwrap_err();
528        assert_eq!(err.name(), "TypeError");
529        assert_eq!(
530            err.message().as_bstr(),
531            b"no implicit conversion of false into Integer".as_bstr()
532        );
533    }
534
535    // ```console
536    // [3.1.2] > a = []
537    // => []
538    // [3.1.2] > a[Object.new]
539    // (irb):3:in `<main>': no implicit conversion of Object into Integer (TypeError)
540    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
541    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
542    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
543    // ```
544    #[test]
545    fn implicit_to_int_object_type_error() {
546        let mut interp = interpreter();
547        let value = interp.eval(b"Object.new").unwrap();
548        let err = convert_type(
549            &mut interp,
550            value,
551            Ruby::Fixnum,
552            "Integer",
553            "to_int",
554            ConvertOnError::Raise,
555        )
556        .unwrap_err();
557        assert_eq!(err.name(), "TypeError");
558        assert_eq!(
559            err.message().as_bstr(),
560            b"no implicit conversion of Object into Integer".as_bstr()
561        );
562    }
563
564    // ```console
565    // [3.1.2] > a = []
566    // => []
567    // [3.1.2] > class C; def to_int; nil; end; end
568    // => :to_int
569    // [3.1.2] > a[C.new]
570    // (irb):5:in `<main>': can't convert C to Integer (C#to_int gives NilClass) (TypeError)
571    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
572    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
573    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
574    // ```
575    #[test]
576    fn implicit_to_int_object_with_nil_to_int_returns_nil() {
577        let mut interp = interpreter();
578        // define class
579        interp.eval(b"class C; def to_int; nil; end; end").unwrap();
580        let value = interp.eval(b"C.new").unwrap();
581        let err = convert_type(
582            &mut interp,
583            value,
584            Ruby::Fixnum,
585            "Integer",
586            "to_int",
587            ConvertOnError::Raise,
588        )
589        .unwrap_err();
590        assert_eq!(err.name(), "TypeError");
591        assert_eq!(
592            err.message().as_bstr(),
593            b"can't convert C to Integer (C#to_int gives NilClass)".as_bstr()
594        );
595    }
596
597    // ```console
598    // [3.1.2] > a = []
599    // => []
600    // [3.1.2] > class D; def to_int; 'not an integer'; end; end
601    // => :to_int
602    // [3.1.2] > a[D.new]
603    // (irb):7:in `<main>': can't convert D to Integer (D#to_int gives String) (TypeError)
604    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
605    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
606    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
607    // ```
608    #[test]
609    fn implicit_to_int_object_with_string_to_int_returns_type_error() {
610        let mut interp = interpreter();
611        // define class
612        interp.eval(b"class D; def to_int; 'not an integer'; end; end").unwrap();
613        let value = interp.eval(b"D.new").unwrap();
614        let err = convert_type(
615            &mut interp,
616            value,
617            Ruby::Fixnum,
618            "Integer",
619            "to_int",
620            ConvertOnError::Raise,
621        )
622        .unwrap_err();
623        assert_eq!(err.name(), "TypeError");
624        assert_eq!(
625            err.message().as_bstr(),
626            b"can't convert D to Integer (D#to_int gives String)".as_bstr()
627        );
628    }
629
630    // ```console
631    // [3.1.2] > a = []
632    // => []
633    // [3.1.2] > class F; def to_int; raise ArgumentError, 'not an integer'; end; end
634    // => :to_int
635    // [3.1.2] > a[F.new]
636    // (irb):8:in `to_int': not an integer (ArgumentError)
637    //         from (irb):9:in `<main>'
638    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
639    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
640    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
641    #[test]
642    fn implicit_to_int_object_with_raising_to_int_returns_raised_exception() {
643        let mut interp = interpreter();
644        // define class
645        interp
646            .eval(b"class F; def to_int; raise ArgumentError, 'not an integer'; end; end")
647            .unwrap();
648        let value = interp.eval(b"F.new").unwrap();
649        let err = convert_type(
650            &mut interp,
651            value,
652            Ruby::Fixnum,
653            "Integer",
654            "to_int",
655            ConvertOnError::Raise,
656        )
657        .unwrap_err();
658        assert_eq!(err.name(), "ArgumentError");
659        assert_eq!(err.message().as_bstr(), b"not an integer".as_bstr());
660    }
661
662    #[test]
663    fn to_int_reflexive() {
664        let mut interp = interpreter();
665        let i = interp.convert(17);
666        let converted = to_int(&mut interp, i).unwrap();
667        let converted = converted.try_convert_into::<i64>(&interp).unwrap();
668        assert_eq!(17, converted);
669    }
670
671    #[test]
672    fn to_int_conv() {
673        let mut interp = interpreter();
674        interp.eval(b"class A; def to_int; 17; end; end").unwrap();
675        let value = interp.eval(b"A.new").unwrap();
676        let converted = to_int(&mut interp, value).unwrap();
677        let converted = converted.try_convert_into::<i64>(&interp).unwrap();
678        assert_eq!(17, converted);
679    }
680
681    // ```console
682    // [3.1.2] > a = []
683    // => []
684    // [3.1.2] > a[true]
685    // (irb):2:in `<main>': no implicit conversion of true into Integer (TypeError)
686    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
687    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
688    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
689    // ```
690    #[test]
691    fn to_int_true_type_error() {
692        let mut interp = interpreter();
693        let value = interp.convert(true);
694        let err = to_int(&mut interp, value).unwrap_err();
695        assert_eq!(err.name(), "TypeError");
696        assert_eq!(
697            err.message().as_bstr(),
698            b"no implicit conversion of true into Integer".as_bstr()
699        );
700    }
701
702    // ```console
703    // [3.1.2] > a = []
704    // => []
705    // [3.1.2] > a[false]
706    // (irb):3:in `<main>': no implicit conversion of false into Integer (TypeError)
707    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
708    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
709    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
710    // ```
711    #[test]
712    fn to_int_false_type_error() {
713        let mut interp = interpreter();
714        let value = interp.convert(false);
715        let err = to_int(&mut interp, value).unwrap_err();
716        assert_eq!(err.name(), "TypeError");
717        assert_eq!(
718            err.message().as_bstr(),
719            b"no implicit conversion of false into Integer".as_bstr()
720        );
721    }
722
723    // ```console
724    // [3.1.2] > a = []
725    // => []
726    // [3.1.2] > a[Object.new]
727    // (irb):3:in `<main>': no implicit conversion of Object into Integer (TypeError)
728    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
729    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
730    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
731    // ```
732    #[test]
733    fn to_int_object_type_error() {
734        let mut interp = interpreter();
735        let value = interp.eval(b"Object.new").unwrap();
736        let err = to_int(&mut interp, value).unwrap_err();
737        assert_eq!(err.name(), "TypeError");
738        assert_eq!(
739            err.message().as_bstr(),
740            b"no implicit conversion of Object into Integer".as_bstr()
741        );
742    }
743
744    // ```console
745    // [3.1.2] > a = []
746    // => []
747    // [3.1.2] > class C; def to_int; nil; end; end
748    // => :to_int
749    // [3.1.2] > a[C.new]
750    // (irb):5:in `<main>': can't convert C to Integer (C#to_int gives NilClass) (TypeError)
751    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
752    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
753    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
754    // ```
755    #[test]
756    fn to_int_object_with_nil_to_int_returns_nil() {
757        let mut interp = interpreter();
758        // define class
759        interp.eval(b"class C; def to_int; nil; end; end").unwrap();
760        let value = interp.eval(b"C.new").unwrap();
761        let err = to_int(&mut interp, value).unwrap_err();
762        assert_eq!(err.name(), "TypeError");
763        assert_eq!(
764            err.message().as_bstr(),
765            b"can't convert C to Integer (C#to_int gives NilClass)".as_bstr()
766        );
767    }
768
769    // ```console
770    // [3.1.2] > a = []
771    // => []
772    // [3.1.2] > class D; def to_int; 'not an integer'; end; end
773    // => :to_int
774    // [3.1.2] > a[D.new]
775    // (irb):7:in `<main>': can't convert D to Integer (D#to_int gives String) (TypeError)
776    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
777    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
778    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
779    // ```
780    #[test]
781    fn to_int_object_with_string_to_int_returns_type_error() {
782        let mut interp = interpreter();
783        // define class
784        interp.eval(b"class D; def to_int; 'not an integer'; end; end").unwrap();
785        let value = interp.eval(b"D.new").unwrap();
786        let err = to_int(&mut interp, value).unwrap_err();
787        assert_eq!(err.name(), "TypeError");
788        assert_eq!(
789            err.message().as_bstr(),
790            b"can't convert D to Integer (D#to_int gives String)".as_bstr()
791        );
792    }
793
794    // ```console
795    // [3.1.2] > a = []
796    // => []
797    // [3.1.2] > class F; def to_int; raise ArgumentError, 'not an integer'; end; end
798    // => :to_int
799    // [3.1.2] > a[F.new]
800    // (irb):8:in `to_int': not an integer (ArgumentError)
801    //         from (irb):9:in `<main>'
802    //         from /usr/local/var/rbenv/versions/3.1.2/lib/ruby/gems/3.1.0/gems/irb-1.4.1/exe/irb:11:in `<top (required)>'
803    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `load'
804    //         from /usr/local/var/rbenv/versions/3.1.2/bin/irb:25:in `<main>'
805    #[test]
806    fn to_int_object_with_raising_to_int_returns_raised_exception() {
807        let mut interp = interpreter();
808        // define class
809        interp
810            .eval(b"class F; def to_int; raise ArgumentError, 'not an integer'; end; end")
811            .unwrap();
812        let value = interp.eval(b"F.new").unwrap();
813        let err = to_int(&mut interp, value).unwrap_err();
814        assert_eq!(err.name(), "ArgumentError");
815        assert_eq!(err.message().as_bstr(), b"not an integer".as_bstr());
816    }
817}
artichoke_backend/convert/conv.rs

artichoke_backend/convert/
conv.rs
