Skip to main content

sk_runtime/
host.rs

1//! Building blocks for the native objects the host crates install: promises settled later from Rust,
2//! errors, JSON values as JS values, accessors on plain objects.
3
4use std::cell::RefCell;
5use std::collections::HashSet;
6use std::ffi::c_void;
7
8use redjs::ffi::{redjs_promise_create, redjs_protect, redjs_unprotect};
9use redjs::glue;
10use redjs::webapi::domexception;
11use redjs::webapi::util::*;
12
13pub unsafe fn global(g: *mut c_void) -> u64 {
14    glue::rjs_global(g)
15}
16
17/// A `TypeError` (or `RangeError`) or a `DOMException` named `name`, as a value.
18pub unsafe fn error(g: *mut c_void, name: &str, msg: &str) -> u64 {
19    if matches!(name, "TypeError" | "RangeError" | "Error") {
20        let ctor = get(g, global(g), name);
21        return call(g, ctor, UNDEF, &[js_string(g, msg)]).unwrap_or(UNDEF);
22    }
23    domexception::create(g, name, msg)
24}
25
26/// Throws `error(name, msg)`; the host function returns what this returns.
27pub unsafe fn throw(g: *mut c_void, name: &str, msg: &str) -> u64 {
28    glue::rjs_throw(g, error(g, name, msg));
29    UNDEF
30}
31
32/// The resolve and reject of a promise kept alive until one of them runs.
33pub struct Settler {
34    resolve: u64,
35    reject: u64,
36}
37
38impl Settler {
39    pub unsafe fn resolve(self, g: *mut c_void, v: u64) {
40        let _ = call(g, self.resolve, UNDEF, &[v]);
41        self.release(g);
42    }
43
44    pub unsafe fn reject(self, g: *mut c_void, e: u64) {
45        let _ = call(g, self.reject, UNDEF, &[e]);
46        self.release(g);
47    }
48
49    pub unsafe fn settle(self, g: *mut c_void, outcome: Result<u64, u64>) {
50        match outcome {
51            Ok(v) => self.resolve(g, v),
52            Err(e) => self.reject(g, e),
53        }
54    }
55
56    /// Lets the promise stay pending forever, releasing what kept it settleable.
57    pub unsafe fn abandon(self, g: *mut c_void) {
58        self.release(g);
59    }
60
61    unsafe fn release(self, g: *mut c_void) {
62        redjs_unprotect(g, self.resolve);
63        redjs_unprotect(g, self.reject);
64    }
65}
66
67/// A pending promise and what settles it.
68pub unsafe fn deferred(g: *mut c_void) -> (u64, Settler) {
69    let (mut resolve, mut reject, mut promise) = (UNDEF, UNDEF, UNDEF);
70    redjs_promise_create(g, &mut resolve, &mut reject, &mut promise);
71    redjs_protect(g, resolve);
72    redjs_protect(g, reject);
73    (promise, Settler { resolve, reject })
74}
75
76pub unsafe fn rejected_with(g: *mut c_void, reason: u64) -> u64 {
77    let (p, s) = deferred(g);
78    s.reject(g, reason);
79    p
80}
81
82pub unsafe fn rejected(g: *mut c_void, name: &str, msg: &str) -> u64 {
83    rejected_with(g, error(g, name, msg))
84}
85
86pub unsafe fn resolved(g: *mut c_void, v: u64) -> u64 {
87    resolved_promise(g, v)
88}
89
90pub unsafe fn to_js(g: *mut c_void, v: &serde_json::Value) -> u64 {
91    use serde_json::Value as J;
92    match v {
93        J::Null => NULL,
94        J::Bool(b) => enc_bool(*b),
95        J::Number(n) => enc_f64(n.as_f64().unwrap_or(0.0)),
96        J::String(s) => js_string(g, s),
97        J::Array(a) => {
98            let arr = new_array(g);
99            for (i, x) in a.iter().enumerate() {
100                set_i(g, arr, i as u32, to_js(g, x));
101            }
102            arr
103        }
104        J::Object(m) => {
105            let obj = new_object(g, UNDEF);
106            for (k, x) in m {
107                define(g, obj, k, to_js(g, x), 0);
108            }
109            obj
110        }
111    }
112}
113
114/// `JSON.stringify(v)`, or `None` when it throws or gives `undefined`.
115pub unsafe fn stringify(g: *mut c_void, v: u64) -> Option<String> {
116    let json = get(g, global(g), "JSON");
117    let s = call(g, get(g, json, "stringify"), json, &[v]).ok()?;
118    if s == UNDEF {
119        return None;
120    }
121    read_string(g, s)
122}
123
124/// A frozen array of strings.
125pub unsafe fn frozen_strings(g: *mut c_void, items: &[impl AsRef<str>]) -> u64 {
126    let arr = new_array(g);
127    for (i, s) in items.iter().enumerate() {
128        set_i(g, arr, i as u32, js_string(g, s.as_ref()));
129    }
130    let object = get(g, global(g), "Object");
131    call(g, get(g, object, "freeze"), object, &[arr]).unwrap_or(arr)
132}
133
134pub unsafe fn is_string(g: *mut c_void, v: u64) -> bool {
135    const KIND_STRING: u32 = 5;
136    glue::rjs_kind(g, v) == KIND_STRING
137}
138
139pub unsafe fn truthy(g: *mut c_void, v: u64) -> bool {
140    call(g, get(g, global(g), "Boolean"), UNDEF, &[v]) == Ok(TRUE)
141}
142
143pub unsafe fn string_arg(g: *mut c_void, v: u64) -> Option<String> {
144    if v == UNDEF {
145        return None;
146    }
147    to_js_string(g, v).ok().and_then(|s| read_string(g, s))
148}
149
150pub unsafe fn method(g: *mut c_void, obj: u64, name: &str, arity: u32, f: HostFn) {
151    define(g, obj, name, make_fn(g, name, arity, f), 2);
152}
153
154pub unsafe fn getter(g: *mut c_void, obj: u64, name: &str, f: HostFn) {
155    let a = atom(g, name);
156    glue::rjs_define_accessor(
157        g,
158        obj,
159        a,
160        make_fn(g, &format!("get {name}"), 0, f),
161        UNDEF,
162        0,
163    );
164    glue::rjs_atom_free(g, a);
165}
166
167/// An object for a host API, held for the context and reachable as the hidden global `name`.
168pub unsafe fn install_object(g: *mut c_void, name: &str, proto: u64) -> u64 {
169    let obj = new_object(g, proto);
170    redjs_protect(g, obj);
171    define(g, global(g), name, obj, 2);
172    obj
173}
174
175thread_local! {
176    static WARNED: RefCell<HashSet<String>> = RefCell::new(HashSet::new());
177}
178
179/// `console.warn` once per `key` for this thread; false when `key` was already said.
180pub unsafe fn warn_compat(g: *mut c_void, key: &str, msg: &str) -> bool {
181    warn_once(g, key.to_string(), &format!("[skathi compat] {msg}"))
182}
183
184unsafe fn warn_once(g: *mut c_void, key: String, line: &str) -> bool {
185    if !WARNED.with(|w| w.borrow_mut().insert(key)) {
186        return false;
187    }
188    let console = get(g, global(g), "console");
189    if is_cell(console) {
190        let _ = call(g, get(g, console, "warn"), console, &[js_string(g, line)]);
191    }
192    true
193}
194
195pub fn has_warned(key: &str) -> bool {
196    WARNED.with(|w| w.borrow().contains(key))
197}
198
199crate::host_fn!(fn js_advise(g, args) {
200    let key = unsafe { string_arg(g, args.arg(0).0) }.unwrap_or_default();
201    let msg = unsafe { string_arg(g, args.arg(1).0) }.unwrap_or_default();
202    enc_bool(unsafe { warn_compat(g, &key, &msg) })
203});
204
205crate::host_fn!(fn js_advised(g, args) {
206    let key = unsafe { string_arg(g, args.arg(0).0) }.unwrap_or_default();
207    enc_bool(has_warned(&key))
208});
209
210crate::host_fn!(fn js_perf_advise(g, args) {
211    let code = match unsafe { string_arg(g, args.arg(0).0) }.as_deref() {
212        Some("wasted-render") => "wasted-render",
213        Some("long-list") => "long-list",
214        Some("host-writes") => "host-writes",
215        _ => return UNDEF,
216    };
217    let key = unsafe { string_arg(g, args.arg(1).0) }.unwrap_or_default();
218    let msg = unsafe { string_arg(g, args.arg(2).0) }.unwrap_or_default();
219    redjs::profiling::hint(code, &msg);
220    enc_bool(unsafe { warn_once(g, format!("perf:{code}:{key}"), &format!("[skathi perf] {msg}")) })
221});
222
223/// `__sk_advise(key, message)` and `__sk_advised(key)`: the runtime's one-shot advisories share the
224/// host's set. `__sk_perf_advise(code, key, message)`: a dev-build performance advisory, a hint on the
225/// recorded frame each time and a console line once per key.
226pub(crate) unsafe fn install(g: *mut c_void) {
227    define(
228        g,
229        global(g),
230        "__sk_perf_advise",
231        make_fn(g, "__sk_perf_advise", 3, js_perf_advise),
232        2,
233    );
234    define(
235        g,
236        global(g),
237        "__sk_advise",
238        make_fn(g, "__sk_advise", 2, js_advise),
239        2,
240    );
241    define(
242        g,
243        global(g),
244        "__sk_advised",
245        make_fn(g, "__sk_advised", 1, js_advised),
246        2,
247    );
248}
249
250#[cfg(test)]
251mod tests {
252    use crate::JsRuntime;
253
254    #[test]
255    fn the_runtime_and_the_host_share_one_advisory_set() {
256        crate::testing::on_js_thread(|| {
257            JsRuntime::with(|rt| {
258                let read = |src: &str| {
259                    rt.ctx()
260                        .to_rust_string(rt.ctx().eval(src).unwrap())
261                        .unwrap()
262                };
263                assert!(unsafe { super::warn_compat(rt.raw(), "host-first", "said by the host") });
264                assert_eq!(
265                    read("[__sk_advised('host-first'), __sk_advise('host-first', 'x'), __sk_advise('js-first', 'y'), __sk_advise('js-first', 'y')].join()"),
266                    "true,false,true,false"
267                );
268                assert!(super::has_warned("js-first"));
269            });
270        });
271    }
272}