artichoke_backend/extn/core/array/
trampoline.rs

1use crate::convert::{implicitly_convert_to_int, implicitly_convert_to_string};
2use crate::extn::core::array::Array;
3use crate::extn::prelude::*;
4
5pub fn plus(interp: &mut Artichoke, mut ary: Value, mut other: Value) -> Result<Value, Error> {
6    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
7    let result = if let Ok(other) = unsafe { Array::unbox_from_value(&mut other, interp) } {
8        let mut result = Array::with_capacity(array.len() + other.len());
9        result.concat(array.as_slice());
10        result.concat(other.as_slice());
11        result
12    } else if other.respond_to(interp, "to_ary")? {
13        let mut other_converted = other.funcall(interp, "to_ary", &[], None)?;
14        let Ok(other) = (unsafe { Array::unbox_from_value(&mut other_converted, interp) }) else {
15            let mut message = String::from("can't convert ");
16            let name = interp.inspect_type_name_for_value(other);
17            message.push_str(name);
18            message.push_str(" to Array (");
19            message.push_str(name);
20            message.push_str("#to_ary gives ");
21            message.push_str(interp.inspect_type_name_for_value(other_converted));
22            return Err(TypeError::from(message).into());
23        };
24        let mut result = Array::with_capacity(array.len() + other.len());
25        result.concat(array.as_slice());
26        result.concat(other.as_slice());
27        result
28    } else {
29        let mut message = String::from("no implicit conversion of ");
30        message.push_str(interp.inspect_type_name_for_value(other));
31        message.push_str(" into Array");
32        return Err(TypeError::from(message).into());
33    };
34    Array::alloc_value(result, interp)
35}
36
37pub fn mul(interp: &mut Artichoke, mut ary: Value, mut joiner: Value) -> Result<Value, Error> {
38    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
39    // SAFETY: Convert separator to an owned byte vec to ensure the `RString*`
40    // backing `joiner` is not garbage collected when invoking `to_s` during
41    // `join`.
42    if let Ok(separator) = unsafe { implicitly_convert_to_string(interp, &mut joiner) } {
43        let separator = separator.to_vec();
44        let s = super::join(interp, &array, &separator)?;
45        interp.try_convert_mut(s)
46    } else {
47        let n = implicitly_convert_to_int(interp, joiner)?;
48        let Ok(n) = usize::try_from(n) else {
49            return Err(ArgumentError::with_message("negative argument").into());
50        };
51        let value = super::repeat(&array, n)?;
52        let result = Array::alloc_value(value, interp)?;
53        let result_value = result.inner();
54        let ary_value = ary.inner();
55        unsafe {
56            let ary_rbasic = ary_value.value.p.cast::<sys::RBasic>();
57            let result_rbasic = result_value.value.p.cast::<sys::RBasic>();
58            (*result_rbasic).c = (*ary_rbasic).c;
59        }
60        Ok(result)
61    }
62}
63
64pub fn push_single(interp: &mut Artichoke, mut ary: Value, value: Value) -> Result<Value, Error> {
65    check_frozen(interp, ary)?;
66
67    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
68
69    // SAFETY: The array is repacked without any intervening interpreter heap
70    // allocations.
71    let array_mut = unsafe { array.as_inner_mut() };
72    array_mut.push(value);
73
74    unsafe {
75        let inner = array.take();
76        Array::box_into_value(inner, ary, interp)?;
77    }
78
79    Ok(ary)
80}
81
82pub fn element_reference(
83    interp: &mut Artichoke,
84    mut ary: Value,
85    first: Value,
86    second: Option<Value>,
87) -> Result<Value, Error> {
88    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
89    let elem = super::aref(interp, &array, first, second)?;
90    Ok(interp.convert(elem))
91}
92
93pub fn element_assignment(
94    interp: &mut Artichoke,
95    mut ary: Value,
96    first: Value,
97    second: Value,
98    third: Option<Value>,
99) -> Result<Value, Error> {
100    check_frozen(interp, ary)?;
101
102    // TODO: properly handle self-referential sets.
103    if ary == first || ary == second || Some(ary) == third {
104        return Ok(Value::nil());
105    }
106    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
107
108    // XXX: Ensure that `array_mut` does not allocate in between mruby
109    // allocations.
110    let array_mut = unsafe { array.as_inner_mut() };
111    let result = super::aset(interp, array_mut, first, second, third);
112
113    unsafe {
114        let inner = array.take();
115        Array::box_into_value(inner, ary, interp)?;
116    }
117
118    result
119}
120
121pub fn clear(interp: &mut Artichoke, mut ary: Value) -> Result<Value, Error> {
122    check_frozen(interp, ary)?;
123
124    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
125
126    // SAFETY: Clearing a `Vec` does not reallocate it, but it does change its
127    // length. The array is repacked before any intervening interpreter heap
128    // allocations occur.
129    unsafe {
130        let array_mut = array.as_inner_mut();
131        array_mut.clear();
132
133        let inner = array.take();
134        Array::box_into_value(inner, ary, interp)?;
135    }
136
137    Ok(ary)
138}
139
140pub fn push<I>(interp: &mut Artichoke, mut ary: Value, others: I) -> Result<Value, Error>
141where
142    I: IntoIterator<Item = Value>,
143    I::IntoIter: Clone,
144{
145    check_frozen(interp, ary)?;
146
147    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
148
149    // SAFETY: The array is repacked without any intervening interpreter heap
150    // allocations.
151    let array_mut = unsafe { array.as_inner_mut() };
152
153    array_mut.extend(others);
154
155    unsafe {
156        let inner = array.take();
157        Array::box_into_value(inner, ary, interp)?;
158    }
159
160    Ok(ary)
161}
162
163pub fn concat<I>(interp: &mut Artichoke, mut ary: Value, others: I) -> Result<Value, Error>
164where
165    I: IntoIterator<Item = Value>,
166    I::IntoIter: Clone,
167{
168    // Assumption for the average length of an `Array` that will be concatenated
169    // into `ary`.
170    const OTHER_ARRAYS_AVG_LENGTH: usize = 5;
171
172    check_frozen(interp, ary)?;
173
174    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
175    let others = others.into_iter();
176
177    // Allocate a new buffer and concatenate into it to allow preserving the
178    // original `Array`'s items if `ary` is concatenated with itself.
179    //
180    // This allocation assumes that each `Array` yielded by the iterator is
181    // "small", where small means 5 elements or fewer.
182    let mut replacement = Array::with_capacity(array.len() + others.clone().count() * OTHER_ARRAYS_AVG_LENGTH);
183    replacement.concat(array.as_slice());
184
185    for mut other in others {
186        if let Ok(other) = unsafe { Array::unbox_from_value(&mut other, interp) } {
187            replacement.reserve(other.len());
188            replacement.concat(other.as_slice());
189        } else if other.respond_to(interp, "to_ary")? {
190            let mut other_converted = other.funcall(interp, "to_ary", &[], None)?;
191            let Ok(other) = (unsafe { Array::unbox_from_value(&mut other_converted, interp) }) else {
192                let mut message = String::from("can't convert ");
193                let name = interp.inspect_type_name_for_value(other);
194                message.push_str(name);
195                message.push_str(" to Array (");
196                message.push_str(name);
197                message.push_str("#to_ary gives ");
198                message.push_str(interp.inspect_type_name_for_value(other_converted));
199                return Err(TypeError::from(message).into());
200            };
201
202            replacement.reserve(other.len());
203            replacement.concat(other.as_slice());
204        } else {
205            let mut message = String::from("no implicit conversion of ");
206            message.push_str(interp.inspect_type_name_for_value(other));
207            message.push_str(" into Array");
208            return Err(TypeError::from(message).into());
209        }
210    }
211
212    unsafe {
213        let _old = array.take();
214        Array::box_into_value(replacement, ary, interp)?;
215    }
216
217    Ok(ary)
218}
219
220pub fn first(interp: &mut Artichoke, mut ary: Value, num: Option<Value>) -> Result<Value, Error> {
221    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
222    let Some(num) = num else {
223        let first = array.first();
224        return Ok(interp.convert(first));
225    };
226    // Hack to detect `BigNum`
227    if let Ruby::Float = num.ruby_type() {
228        return Err(RangeError::with_message("bignum too big to convert into `long'").into());
229    }
230    let n = implicitly_convert_to_int(interp, num)?;
231    let Ok(n) = usize::try_from(n) else {
232        return Err(ArgumentError::with_message("negative array size").into());
233    };
234    let slice = array.first_n(n);
235    let result = Array::from(slice);
236    Array::alloc_value(result, interp)
237}
238
239pub fn initialize(
240    interp: &mut Artichoke,
241    mut value: Value,
242    first: Option<Value>,
243    second: Option<Value>,
244    block: Option<Block>,
245) -> Result<Value, Error> {
246    check_frozen(interp, value)?;
247
248    // If we are calling `initialize` on an already initialized `Array`,
249    // pluck out the inner buffer and drop it so we don't leak memory.
250    if let Ok(a) = unsafe { Array::unbox_from_value(&mut value, interp) } {
251        unsafe {
252            let inner = a.take();
253            drop(inner);
254        }
255    }
256    // Pack an empty `Array` into the given uninitialized `RArray *` so it can
257    // be safely marked if an mruby allocation occurs and a GC is triggered in
258    // `Array::initialize`.
259    //
260    // Allocations are likely in the case where a block is passed to
261    // `Array#initialize` or when the first and second args must be coerced with
262    // the `#to_*` family of methods.
263    Array::box_into_value(Array::new(), value, interp)?;
264    let array = super::initialize(interp, first, second, block)?;
265    Array::box_into_value(array, value, interp)
266}
267
268pub fn initialize_copy(interp: &mut Artichoke, ary: Value, mut from: Value) -> Result<Value, Error> {
269    check_frozen(interp, ary)?;
270
271    // Pack an empty `Array` into the given uninitialized `RArray *` so it can
272    // be safely marked if an mruby allocation occurs and a GC is triggered in
273    // `Array::initialize`.
274    //
275    // This ensures the given `RArry *` is initialized even if a non-`Array`
276    // object is called with `Array#initialize_copy` and the
277    // `Array::unbox_from_value` call below short circuits with an error.
278    Array::box_into_value(Array::new(), ary, interp)?;
279    let from = unsafe { Array::unbox_from_value(&mut from, interp)? };
280    let result = from.clone();
281    Array::box_into_value(result, ary, interp)
282}
283
284pub fn last(interp: &mut Artichoke, mut ary: Value, num: Option<Value>) -> Result<Value, Error> {
285    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
286    let Some(num) = num else {
287        let last = array.last();
288        return Ok(interp.convert(last));
289    };
290    // Hack to detect `BigNum`
291    if let Ruby::Float = num.ruby_type() {
292        return Err(RangeError::with_message("bignum too big to convert into `long'").into());
293    }
294    let n = implicitly_convert_to_int(interp, num)?;
295    let Ok(n) = usize::try_from(n) else {
296        return Err(ArgumentError::with_message("negative array size").into());
297    };
298    let slice = array.last_n(n);
299    let result = Array::from(slice);
300    Array::alloc_value(result, interp)
301}
302
303pub fn len(interp: &mut Artichoke, mut ary: Value) -> Result<usize, Error> {
304    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
305    Ok(array.len())
306}
307
308pub fn pop(interp: &mut Artichoke, mut ary: Value) -> Result<Value, Error> {
309    check_frozen(interp, ary)?;
310
311    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
312
313    // SAFETY: The array is repacked without any intervening interpreter heap
314    // allocations.
315    let result = unsafe {
316        let array_mut = array.as_inner_mut();
317        let result = array_mut.pop();
318
319        let inner = array.take();
320        Array::box_into_value(inner, ary, interp)?;
321
322        result
323    };
324
325    Ok(interp.convert(result))
326}
327
328pub fn reverse(interp: &mut Artichoke, mut ary: Value) -> Result<Value, Error> {
329    let array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
330    let mut reversed = array.clone();
331    reversed.reverse();
332    Array::alloc_value(reversed, interp)
333}
334
335pub fn reverse_bang(interp: &mut Artichoke, mut ary: Value) -> Result<Value, Error> {
336    check_frozen(interp, ary)?;
337
338    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
339
340    // SAFETY: Reversing an `Array` in place does not reallocate it. The array
341    // is repacked without any intervening interpreter heap allocations.
342    unsafe {
343        let array_mut = array.as_inner_mut();
344        array_mut.reverse();
345
346        let inner = array.take();
347        Array::box_into_value(inner, ary, interp)?;
348    }
349
350    Ok(ary)
351}
352
353pub fn shift(interp: &mut Artichoke, mut ary: Value, count: Option<Value>) -> Result<Value, Error> {
354    check_frozen(interp, ary)?;
355
356    let mut array = unsafe { Array::unbox_from_value(&mut ary, interp)? };
357    if let Some(count) = count {
358        let count = implicitly_convert_to_int(interp, count)?;
359        let count = usize::try_from(count).map_err(|_| ArgumentError::with_message("negative array size"))?;
360
361        // SAFETY: The call to `Array::shift_n` will potentially invalidate the
362        // raw parts stored in `ary`'s `RArray*`.
363        //
364        // The below call to `Array::alloc_value` will trigger an mruby heap
365        // allocation which may trigger a garbage collection.
366        //
367        // The raw parts in `ary`'s `RArray*` must be repacked before a potential
368        // garbage collection, otherwise marking the children in `ary` will have
369        // undefined behavior.
370        //
371        // The call to `Array::alloc_value` happens outside this block after
372        // the `Array` has been repacked.
373        let shifted = unsafe {
374            let array_mut = array.as_inner_mut();
375            let shifted = array_mut.shift_n(count);
376
377            let inner = array.take();
378            Array::box_into_value(inner, ary, interp)?;
379
380            shifted
381        };
382
383        Array::alloc_value(shifted, interp)
384    } else {
385        // SAFETY: The call to `Array::shift` will potentially invalidate the
386        // raw parts stored in `ary`'s `RArray*`.
387        //
388        // The raw parts in `ary`'s `RArray *` must be repacked before a
389        // potential garbage collection, otherwise marking the children in `ary`
390        // will have undefined behavior.
391        //
392        // The call to `interp.convert` happens outside this block after the
393        // `Array` has been repacked.
394        let shifted = unsafe {
395            let array_mut = array.as_inner_mut();
396            let shifted = array_mut.shift();
397
398            let inner = array.take();
399            Array::box_into_value(inner, ary, interp)?;
400
401            shifted
402        };
403
404        Ok(interp.convert(shifted))
405    }
406}
407
408fn check_frozen(interp: &mut Artichoke, value: Value) -> Result<(), Error> {
409    if !value.is_frozen(interp) {
410        return Ok(());
411    }
412    let mut message = "can't modify frozen Array: ".as_bytes().to_vec();
413    // FIXME: This is a workaround for `Array#inspect` not being implemented in
414    // native code.
415    let inspect = value
416        .funcall(interp, "inspect", &[], None)?
417        .try_convert_into_mut::<&[u8]>(interp)?;
418    message.extend_from_slice(inspect);
419    Err(FrozenError::from(message).into())
420}
421
422#[cfg(test)]
423mod tests {
424    use bstr::ByteSlice;
425
426    use super::*;
427    use crate::test::prelude::*;
428
429    #[test]
430    fn mutating_methods_may_raise_frozen_error() {
431        #[track_caller]
432        fn assert_is_frozen_err(result: Result<Value, Error>) {
433            let err = result.unwrap_err();
434            let message = err.message();
435            let class_name = err.name();
436            // ``console
437            // $ irb
438            // [3.4.2] > [1,2,3].freeze.pop
439            // (irb):1:in 'Array#pop': can't modify frozen Array: [1, 2, 3] (FrozenError)
440            // ```
441            assert_eq!(class_name, "FrozenError");
442            assert_eq!(message.as_bstr(), b"can't modify frozen Array: [1, 2, 3]".as_bstr());
443        }
444
445        let mut interp = interpreter();
446        let mut slf = interp.eval(b"[1, 2, 3]").unwrap();
447
448        slf.freeze(&mut interp).unwrap();
449
450        let value = interp.convert(0);
451        let first = interp.convert(0);
452        let second = interp.try_convert_mut(vec![42_i64]).unwrap();
453
454        assert_is_frozen_err(push_single(&mut interp, slf, value));
455        assert_is_frozen_err(element_assignment(&mut interp, slf, first, second, None));
456        assert_is_frozen_err(clear(&mut interp, slf));
457        assert_is_frozen_err(push(&mut interp, slf, None));
458        assert_is_frozen_err(concat(&mut interp, slf, []));
459        assert_is_frozen_err(initialize(&mut interp, slf, Some(first), Some(second), None));
460        assert_is_frozen_err(initialize_copy(&mut interp, slf, value));
461        assert_is_frozen_err(pop(&mut interp, slf));
462        assert_is_frozen_err(reverse_bang(&mut interp, slf));
463        assert_is_frozen_err(shift(&mut interp, slf, None));
464    }
465}
artichoke_backend/extn/core/array/trampoline.rs

artichoke_backend/extn/core/array/
trampoline.rs
