kataan 0.0.1

A high-performance JavaScript engine written in pure Rust. Library, C FFI, and CLI.
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

//! Source spans.

use core::fmt;

/// A half-open byte range `[start, end)` into the source text a token or AST
/// node came from.
///
/// Offsets are byte offsets (not UTF-16 code units or character counts) so
/// they map directly onto the `&str` source for slicing. They are `u32`,
/// which caps a single compilation unit at 4 GiB of source — far beyond any
/// real script and half the memory footprint of `usize` spans.
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Span {
    /// Byte offset of the first byte of the range.
    pub start: u32,
    /// Byte offset one past the last byte of the range.
    pub end: u32,
}

impl Span {
    /// A span covering the byte range `[start, end)`.
    #[inline]
    #[must_use]
    pub const fn new(start: u32, end: u32) -> Self {
        Self { start, end }
    }

    /// An empty span at `offset`, useful for synthesized nodes and for marking
    /// an insertion point (e.g. an ASI-inserted semicolon).
    #[inline]
    #[must_use]
    pub const fn point(offset: u32) -> Self {
        Self {
            start: offset,
            end: offset,
        }
    }

    /// The length of the span in bytes.
    #[inline]
    #[must_use]
    pub const fn len(self) -> u32 {
        self.end - self.start
    }

    /// Whether the span covers zero bytes.
    #[inline]
    #[must_use]
    pub const fn is_empty(self) -> bool {
        self.start == self.end
    }

    /// The smallest span covering both `self` and `other`.
    #[inline]
    #[must_use]
    pub fn to(self, other: Span) -> Span {
        Span {
            start: self.start.min(other.start),
            end: self.end.max(other.end),
        }
    }

    /// Slices `source` to the bytes this span covers.
    ///
    /// # Panics
    ///
    /// Panics if the span is out of bounds for `source` or does not fall on
    /// UTF-8 character boundaries — which cannot happen for spans the lexer
    /// produces, since they are always derived from char boundaries.
    #[inline]
    #[must_use]
    pub fn slice(self, source: &str) -> &str {
        &source[self.start as usize..self.end as usize]
    }
}

impl fmt::Debug for Span {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}..{}", self.start, self.end)
    }
}

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

    #[test]
    fn len_and_empty() {
        assert_eq!(Span::new(3, 8).len(), 5);
        assert!(Span::point(4).is_empty());
        assert!(!Span::new(3, 8).is_empty());
    }

    #[test]
    fn merge() {
        assert_eq!(Span::new(2, 5).to(Span::new(7, 9)), Span::new(2, 9));
        assert_eq!(Span::new(7, 9).to(Span::new(2, 5)), Span::new(2, 9));
    }

    #[test]
    fn slice() {
        let src = "let x = 42;";
        assert_eq!(Span::new(4, 5).slice(src), "x");
        assert_eq!(Span::new(8, 10).slice(src), "42");
    }
}