josephine 0.2.0

Josephine: using JavaScript to safely manage the lifetimes of Rust data
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

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use super::InCompartment;
use super::JSContext;
use super::JSManaged;
use super::JSString;

use std::fmt::Debug;
use std::hash::Hash;
use std::marker::PhantomData;

/// A marker trait for JS compartments.
/// We mark it as `Copy` so that anything that uses `[#derive{Copy)]` will be copyable.
/// Ditto `Eq` and `Hash`.
pub trait Compartment: Copy + Debug + Eq + Hash {}

/// A wildcard compartment name.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct SOMEWHERE(());

/// A compartment name that remembers the lifetime it was bound for.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct BOUND<'a>(PhantomData<&'a mut &'a ()>);
impl<'a> Compartment for BOUND<'a> {}

/// Data which can be transplanted from compartment C into compartment D.
pub unsafe trait JSCompartmental<C, D> {
    type ChangeCompartment;
    fn is_in_compartment<S>(&self, _cx: &JSContext<S>) -> bool where
        S: InCompartment<D>;
}

unsafe impl<C, D> JSCompartmental<C, D> for String {
    type ChangeCompartment = String;
    fn is_in_compartment<S>(&self, _cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        true
    }
}

unsafe impl<C, D> JSCompartmental<C, D> for usize {
    type ChangeCompartment = usize;
    fn is_in_compartment<S>(&self, _cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        true
    }
}

unsafe impl<C, D> JSCompartmental<C, D> for () {
    type ChangeCompartment = ();
    fn is_in_compartment<S>(&self, _cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        true
    }
}

unsafe impl<C, D, T> JSCompartmental<C, D> for Option<T> where
    T: JSCompartmental<C, D>
{
    type ChangeCompartment = Option<T::ChangeCompartment>;
    fn is_in_compartment<S>(&self, cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        self.iter().all(|this| this.is_in_compartment(cx))
    }
}

unsafe impl<C, D, T> JSCompartmental<C, D> for Vec<T> where
    T: JSCompartmental<C, D>
{
    type ChangeCompartment = Vec<T::ChangeCompartment>;
    fn is_in_compartment<S>(&self, cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        self.iter().all(|this| this.is_in_compartment(cx))
    }
}

unsafe impl<'a, C, D, T> JSCompartmental<C, D> for JSManaged<'a, C, T> where
    T: JSCompartmental<C, D>
{
    type ChangeCompartment = JSManaged<'a, D, T::ChangeCompartment>;
    fn is_in_compartment<S>(&self, cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        self.in_compartment(cx).is_some()
    }
}


unsafe impl<'a, C, D> JSCompartmental<C, D> for JSString<'a, C> {
    type ChangeCompartment = JSString<'a, D>;
    fn is_in_compartment<S>(&self, _cx: &JSContext<S>) -> bool where
        S: InCompartment<D>
    {
        // Rather annoyingly the Rust jsapi bindings don't export
        // GetStringZone which we'd need in order to implement this properly
        false
    }
}