115 lines
3.0 KiB
Rust
115 lines
3.0 KiB
Rust
/// Write the implementation of From<> to convert a borrow of the type to an AstNode
|
|
macro_rules! to_ast_node {
|
|
($inp:ty, $enum:expr) => {
|
|
impl<'r, 's> From<$inp> for AstNode<'r, 's> {
|
|
fn from(value: $inp) -> Self {
|
|
$enum(value)
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub(crate) use to_ast_node;
|
|
|
|
/// Create iterators for ast nodes where it only has to iterate over children
|
|
macro_rules! children_iter {
|
|
($astnodetype:ty, $itertype:ident, $innertype:ty) => {
|
|
pub struct $itertype<'r, 's> {
|
|
next: $innertype,
|
|
}
|
|
|
|
impl<'r, 's> Iterator for $itertype<'r, 's> {
|
|
type Item = AstNode<'r, 's>;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
self.next.next().map(Into::<AstNode>::into)
|
|
}
|
|
}
|
|
|
|
impl<'r, 's> IntoIterator for &'r $astnodetype {
|
|
type Item = AstNode<'r, 's>;
|
|
|
|
type IntoIter = $itertype<'r, 's>;
|
|
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
$itertype {
|
|
next: self.children.iter(),
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub(crate) use children_iter;
|
|
|
|
/// Create iterators for ast nodes that do not contain any ast node children.
|
|
macro_rules! empty_iter {
|
|
($astnodetype:ty, $itertype:ident) => {
|
|
pub struct $itertype<'r, 's> {
|
|
phantom: PhantomData<&'r $astnodetype>,
|
|
}
|
|
|
|
impl<'r, 's> Iterator for $itertype<'r, 's> {
|
|
type Item = AstNode<'r, 's>;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
None
|
|
}
|
|
}
|
|
|
|
impl<'r, 's> IntoIterator for &'r $astnodetype {
|
|
type Item = AstNode<'r, 's>;
|
|
|
|
type IntoIter = $itertype<'r, 's>;
|
|
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
$itertype {
|
|
phantom: PhantomData,
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub(crate) use empty_iter;
|
|
|
|
/// Create iterators for ast nodes where it has to iterate over multiple child lists.
|
|
macro_rules! multi_field_iter {
|
|
($astnodetype:ty, $itertype:ident, $firstfieldname: ident, $firstinnertype:ty, $($fieldname: ident, $innertype:ty),*) => {
|
|
pub struct $itertype<'r, 's> {
|
|
$firstfieldname: $firstinnertype,
|
|
$(
|
|
$fieldname: $innertype,
|
|
),*
|
|
}
|
|
|
|
impl<'r, 's> Iterator for $itertype<'r, 's> {
|
|
type Item = AstNode<'r, 's>;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
self.$firstfieldname.next().map(Into::<AstNode>::into)
|
|
$(
|
|
.or_else(|| self.$fieldname.next().map(Into::<AstNode>::into))
|
|
),*
|
|
}
|
|
}
|
|
|
|
impl<'r, 's> IntoIterator for &'r $astnodetype {
|
|
type Item = AstNode<'r, 's>;
|
|
|
|
type IntoIter = $itertype<'r, 's>;
|
|
|
|
fn into_iter(self) -> Self::IntoIter {
|
|
$itertype {
|
|
$firstfieldname: self.$firstfieldname.iter(),
|
|
$(
|
|
$fieldname: self.$fieldname.iter(),
|
|
),*
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
pub(crate) use multi_field_iter;
|