arity-parser 0.7.0

Lossless CST parser, typed AST wrappers, and incremental reparser for the R language
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

//! Rd-specific rowan kinds. These are independent of the R and DCF kinds.

macro_rules! syntax_kinds {
    ($($kind:ident),+ $(,)?) => {
        /// A node or token in the lossless Rd tree.
        #[allow(non_camel_case_types)]
        #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash,
                 serde::Serialize, serde::Deserialize)]
        #[repr(u16)]
        pub enum SyntaxKind { $($kind),+ }

        impl SyntaxKind {
            /// Every kind in discriminant order.
            pub const ALL: &'static [Self] = &[$(Self::$kind),+];
        }
    };
}

syntax_kinds! {
    ROOT, MACRO, ARGUMENT, GROUP, OPTION, CONDITIONAL,
    MACRO_NAME, LBRACE, RBRACE, LBRACKET, RBRACKET,
    TEXT, RCODE, VERBATIM, ESCAPED_TEXT, ESCAPED_RCODE, ESCAPED_VERBATIM, R_STRING_ESCAPE,
    COMMENT, DIRECTIVE, TARGET, ERROR,
}

impl From<SyntaxKind> for rowan::SyntaxKind {
    fn from(kind: SyntaxKind) -> Self {
        Self(kind as u16)
    }
}

/// The Rd grammar's rowan language.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RdLanguage {}

impl rowan::Language for RdLanguage {
    type Kind = SyntaxKind;

    fn kind_from_raw(raw: rowan::SyntaxKind) -> Self::Kind {
        SyntaxKind::ALL
            .get(usize::from(raw.0))
            .copied()
            .unwrap_or(SyntaxKind::ERROR)
    }

    fn kind_to_raw(kind: Self::Kind) -> rowan::SyntaxKind {
        kind.into()
    }
}

pub type SyntaxNode = rowan::SyntaxNode<RdLanguage>;
pub type SyntaxToken = rowan::SyntaxToken<RdLanguage>;
pub type SyntaxElement = rowan::SyntaxElement<RdLanguage>;

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

    #[test]
    fn kinds_round_trip() {
        for &kind in SyntaxKind::ALL {
            assert_eq!(
                RdLanguage::kind_from_raw(RdLanguage::kind_to_raw(kind)),
                kind
            );
        }
        assert_eq!(
            RdLanguage::kind_from_raw(rowan::SyntaxKind(u16::MAX)),
            SyntaxKind::ERROR
        );
    }
}