rquickjs 0.11.0

High level bindings to the QuickJS 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

#![allow(dead_code)]

use rquickjs::{
    class::{JsClass, Readable, Trace, Tracer},
    Class, Context, JsLifetime, Null, Runtime,
};
use std::sync::Mutex;

static VALIDATE: Mutex<(bool, bool, bool)> = Mutex::new((false, false, false));

pub struct A;

impl<'js> Trace<'js> for A {
    fn trace(&self, _tracer: Tracer<'_, 'js>) {
        VALIDATE.lock().unwrap().0 = true;
    }
}

pub struct B;

impl<'js> Trace<'js> for B {
    fn trace(&self, _tracer: Tracer<'_, 'js>) {
        VALIDATE.lock().unwrap().1 = true;
    }
}

pub struct C;

impl<'js> Trace<'js> for C {
    fn trace(&self, _tracer: Tracer<'_, 'js>) {
        VALIDATE.lock().unwrap().2 = true;
    }
}

#[derive(Trace, JsLifetime)]
pub struct TraceStruct {
    a: A,
    #[qjs(skip_trace)]
    b: B,
    c: C,
}

impl<'js> JsClass<'js> for TraceStruct {
    const NAME: &'static str = "TraceStruct";

    type Mutable = Readable;

    fn prototype(_ctx: &rquickjs::Ctx<'js>) -> rquickjs::Result<Option<rquickjs::Object<'js>>> {
        Ok(None)
    }

    fn constructor(
        _ctx: &rquickjs::Ctx<'js>,
    ) -> rquickjs::Result<Option<rquickjs::function::Constructor<'js>>> {
        Ok(None)
    }
}

#[derive(Trace, JsLifetime)]
pub enum TraceEnum {
    A(A),
    B(#[qjs(skip_trace)] B),
    C,
}

impl<'js> JsClass<'js> for TraceEnum {
    const NAME: &'static str = "TraceEnum";

    type Mutable = Readable;

    fn prototype(_ctx: &rquickjs::Ctx<'js>) -> rquickjs::Result<Option<rquickjs::Object<'js>>> {
        Ok(None)
    }

    fn constructor(
        _ctx: &rquickjs::Ctx<'js>,
    ) -> rquickjs::Result<Option<rquickjs::function::Constructor<'js>>> {
        Ok(None)
    }
}

pub fn main() {
    let rt = Runtime::new().unwrap();
    let ctx = Context::full(&rt).unwrap();

    ctx.with(|ctx| {
        let cls = Class::instance(ctx.clone(), TraceStruct { a: A, b: B, c: C }).unwrap();
        ctx.globals().set("t", cls).unwrap();
    });

    rt.run_gc();

    assert_eq!(*VALIDATE.lock().unwrap(), (true, false, true));

    ctx.with(|ctx| {
        ctx.globals().set("t", Null).unwrap();
    });

    rt.run_gc();

    *VALIDATE.lock().unwrap() = (false, false, false);

    ctx.with(|ctx| {
        let cls = Class::instance(ctx.clone(), TraceEnum::A(A)).unwrap();
        ctx.globals().set("t", cls).unwrap();
    });

    rt.run_gc();
    assert_eq!(*VALIDATE.lock().unwrap(), (true, false, false));
}