tree_sitter_facade_sg/
language.rs

1#[cfg(not(target_arch = "wasm32"))]
2mod native {
3    use std::{borrow::Cow, convert::TryFrom};
4
5    #[derive(Clone, Eq, PartialEq)]
6    pub struct Language {
7        pub(crate) inner: tree_sitter::Language,
8    }
9
10    impl Language {
11        #[inline]
12        pub fn field_count(&self) -> u16 {
13            u16::try_from(self.inner.field_count()).unwrap()
14        }
15
16        #[inline]
17        pub fn field_id_for_name(&self, field_name: impl AsRef<[u8]>) -> Option<u16> {
18            let field_name = field_name.as_ref();
19            self.inner.field_id_for_name(field_name).map(|f| f.get())
20        }
21
22        #[inline]
23        pub fn field_name_for_id(&self, field_id: u16) -> Option<Cow<str>> {
24            self.inner.field_name_for_id(field_id).map(Into::into)
25        }
26
27        #[inline]
28        pub fn id_for_node_kind(&self, kind: &str, named: bool) -> u16 {
29            self.inner.id_for_node_kind(kind, named)
30        }
31
32        #[inline]
33        pub fn node_kind_count(&self) -> u16 {
34            u16::try_from(self.inner.node_kind_count()).unwrap()
35        }
36
37        #[inline]
38        pub fn node_kind_for_id(&self, id: u16) -> Option<Cow<str>> {
39            self.inner.node_kind_for_id(id).map(Into::into)
40        }
41
42        #[inline]
43        pub fn node_kind_is_named(&self, id: u16) -> bool {
44            self.inner.node_kind_is_named(id)
45        }
46
47        #[inline]
48        pub fn node_kind_is_visible(&self, id: u16) -> bool {
49            self.inner.node_kind_is_visible(id)
50        }
51
52        #[inline]
53        pub fn abi_version(&self) -> u32 {
54            u32::try_from(self.inner.abi_version()).unwrap()
55        }
56    }
57
58    impl std::fmt::Debug for Language {
59        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
60            std::fmt::Debug::fmt(&self.inner, fmt)
61        }
62    }
63
64    impl From<tree_sitter::Language> for Language {
65        #[inline]
66        fn from(inner: tree_sitter::Language) -> Self {
67            Self { inner }
68        }
69    }
70
71    impl From<tree_sitter_language::LanguageFn> for Language {
72        #[inline]
73        fn from(inner: tree_sitter_language::LanguageFn) -> Self {
74            let inner = tree_sitter::Language::from(inner);
75            Self { inner }
76        }
77    }
78
79    impl std::panic::RefUnwindSafe for Language {
80    }
81
82    unsafe impl Send for Language {
83    }
84
85    unsafe impl Sync for Language {
86    }
87
88    impl Unpin for Language {
89    }
90
91    impl std::panic::UnwindSafe for Language {
92    }
93}
94
95#[cfg(not(target_arch = "wasm32"))]
96pub use native::*;
97
98#[cfg(target_arch = "wasm32")]
99mod wasm {
100    use std::borrow::Cow;
101
102    #[derive(Clone, PartialEq)]
103    pub struct Language {
104        pub(crate) inner: web_tree_sitter_sg::Language,
105    }
106
107    impl Language {
108        #[inline]
109        pub fn field_count(&self) -> u16 {
110            self.inner.field_count()
111        }
112
113        #[inline]
114        pub fn field_id_for_name(&self, field_name: impl AsRef<[u8]>) -> Option<u16> {
115            let field_name = field_name.as_ref();
116            let field_name = unsafe { std::str::from_utf8_unchecked(field_name) };
117            self.inner.field_id_for_name(field_name)
118        }
119
120        #[inline]
121        pub fn field_name_for_id(&self, field_id: u16) -> Option<Cow<str>> {
122            self.inner.field_name_for_id(field_id).map(Into::into)
123        }
124
125        #[inline]
126        pub fn id_for_node_kind(&self, kind: &str, named: bool) -> u16 {
127            self.inner.id_for_node_kind(kind, named)
128        }
129
130        #[inline]
131        pub fn node_kind_count(&self) -> u16 {
132            self.inner.node_kind_count()
133        }
134
135        #[inline]
136        pub fn node_kind_for_id(&self, id: u16) -> Option<Cow<str>> {
137            self.inner.node_kind_for_id(id).map(Into::into)
138        }
139
140        #[inline]
141        pub fn node_kind_is_named(&self, id: u16) -> bool {
142            self.inner.node_kind_is_named(id)
143        }
144
145        #[inline]
146        pub fn node_kind_is_visible(&self, id: u16) -> bool {
147            self.inner.node_kind_is_visible(id)
148        }
149
150        #[inline]
151        pub fn abi_version(&self) -> u32 {
152            self.inner.abi_version()
153        }
154    }
155
156    impl std::fmt::Debug for Language {
157        fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
158            std::fmt::Debug::fmt(&self.inner, fmt)
159        }
160    }
161
162    impl From<web_tree_sitter_sg::Language> for Language {
163        #[inline]
164        fn from(inner: web_tree_sitter_sg::Language) -> Self {
165            Self { inner }
166        }
167    }
168
169    impl std::panic::RefUnwindSafe for Language {
170    }
171
172    unsafe impl Send for Language {
173    }
174
175    unsafe impl Sync for Language {
176    }
177
178    impl Unpin for Language {
179    }
180
181    impl std::panic::UnwindSafe for Language {
182    }
183}
184
185#[cfg(target_arch = "wasm32")]
186pub use wasm::*;