oxc_estree 0.157.0

A collection of JavaScript tools written in Rust.
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

use std::borrow::Cow;

use super::{ESTree, Serializer};

/// [`ESTree`] implementation for a `&` reference to any type that implements `ESTree`.
impl<T> ESTree for &T
where
    T: ESTree + ?Sized,
{
    #[inline(always)]
    fn serialize<S: Serializer>(&self, serializer: S) {
        (**self).serialize(serializer);
    }
}

/// [`ESTree`] implementation for a `&mut` reference to any type that implements `ESTree`.
impl<T> ESTree for &mut T
where
    T: ESTree + ?Sized,
{
    #[inline(always)]
    fn serialize<S: Serializer>(&self, serializer: S) {
        (**self).serialize(serializer);
    }
}

/// [`ESTree`] implementation for `Option<T>`.
impl<T: ESTree> ESTree for Option<T> {
    fn serialize<S: Serializer>(&self, mut serializer: S) {
        if let Some(value) = self {
            value.serialize(serializer);
        } else {
            serializer.buffer_mut().print_str("null");
        }
    }
}

/// [`ESTree`] implementation for a `Cow` wrapping any type that implements `ESTree`.
impl<T> ESTree for Cow<'_, T>
where
    T: ESTree + ToOwned + ?Sized,
{
    #[inline(always)]
    fn serialize<S: Serializer>(&self, serializer: S) {
        (**self).serialize(serializer);
    }
}

#[cfg(test)]
mod tests {
    use super::super::CompactSerializer;
    use super::*;

    #[expect(clippy::needless_borrow)]
    #[test]
    fn serialize_ref() {
        let cases = [(&"foo", r#""foo""#), (&&"bar", r#""bar""#)];

        for (input, output) in cases {
            let mut serializer = CompactSerializer::default();
            input.serialize(&mut serializer);
            let s = serializer.into_string();
            assert_eq!(&s, output);
        }
    }

    #[expect(clippy::mut_mut)]
    #[test]
    fn serialize_mut_ref() {
        let cases = [(&mut "foo", r#""foo""#), (&mut &mut "bar", r#""bar""#)];

        for (input, output) in cases {
            let mut serializer = CompactSerializer::default();
            input.serialize(&mut serializer);
            let s = serializer.into_string();
            assert_eq!(&s, output);
        }
    }

    #[test]
    fn serialize_option() {
        let cases = [(None, "null"), (Some(123.0f64), "123")];

        for (input, output) in cases {
            let mut serializer = CompactSerializer::default();
            input.serialize(&mut serializer);
            let s = serializer.into_string();
            assert_eq!(&s, output);
        }
    }

    #[test]
    fn serialize_cow() {
        let cases =
            [(Cow::Borrowed("foo"), r#""foo""#), (Cow::Owned("bar".to_string()), r#""bar""#)];

        for (input, output) in cases {
            let mut serializer = CompactSerializer::default();
            input.serialize(&mut serializer);
            let s = serializer.into_string();
            assert_eq!(&s, output);
        }
    }
}