boa_gc 0.21.1

Garbage collector for the Boa JavaScript engine.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::any::TypeId;

use boa_macros::{Finalize, Trace};

use super::run_test;
use crate::{Gc, GcBox, GcErased, force_collect, test::Harness};

#[test]
fn erased_gc() {
    run_test(|| {
        let value = vec![1, 2, 3];
        let gc = Gc::new(value.clone());

        assert_eq!(Gc::type_id(&gc), TypeId::of::<Vec<i32>>());

        let erased = GcErased::new(gc.clone());

        assert_eq!(erased.type_id(), TypeId::of::<Vec<i32>>());
        assert!(erased.is::<Vec<i32>>());

        assert_eq!(erased.clone().downcast::<i32>(), None);

        let gc_from_erased = erased.downcast::<Vec<i32>>().unwrap();
        assert_eq!(**gc_from_erased, value);

        assert!(Gc::ptr_eq(&gc, &gc_from_erased));
    });
}

#[test]
fn nested_erased_gc() {
    #[derive(Debug, Trace, Finalize)]
    struct List {
        value: i32,
        next: Option<GcErased>,
    }

    run_test(|| {
        let mut root = GcErased::new(Gc::new(List {
            value: 0,
            next: None,
        }));

        for value in 1..100 {
            root = GcErased::new(Gc::new(List {
                value,
                next: Some(root),
            }));
        }

        Harness::assert_exact_bytes_allocated(100 * size_of::<GcBox<List>>());
        force_collect();
        Harness::assert_exact_bytes_allocated(100 * size_of::<GcBox<List>>());

        let mut head = root.downcast::<List>();
        for value in (0..100).rev() {
            let head_unwrap = head.as_ref().unwrap();

            assert_eq!(head_unwrap.value, value);

            head = head_unwrap
                .next
                .clone()
                .and_then(GcErased::downcast::<List>);
        }
    });
}

#[test]
fn c_style_inheritance() {
    #[repr(C)]
    #[derive(Debug, Trace, Finalize, PartialEq, Eq)]
    struct Base {
        base_field: Vec<i32>,
    }

    #[repr(C)]
    #[derive(Debug, Trace, Finalize, PartialEq, Eq)]
    struct Derived {
        base: Base,
        derived_field: Vec<i64>,
    }

    run_test(|| {
        let value = vec![1, 2, 3];
        let derived = Gc::new(Derived {
            base: Base {
                base_field: value.clone(),
            },
            derived_field: vec![4, 5, 6],
        });

        assert_eq!(Gc::type_id(&derived), TypeId::of::<Derived>());
        assert!(Gc::is::<Derived>(&derived));

        // SAFETY: The structs have #[repr(C)] so this is safe.
        let base = unsafe { Gc::cast_unchecked::<Base>(derived.clone()) };

        assert_eq!(Gc::type_id(&base), TypeId::of::<Derived>());
        assert!(Gc::is::<Derived>(&base));

        assert_eq!(base.base_field, value);
        assert_eq!(base.base_field, derived.base.base_field);

        assert!(Gc::ptr_eq(&base, &derived));

        assert_eq!(Gc::downcast::<i32>(base.clone()), None);
        assert_eq!(*Gc::downcast::<Derived>(base).unwrap(), *derived);
    });
}