Skip to content

Commit

Permalink
#14 Deduplicate field logic into runtime utility (#47)
Browse files Browse the repository at this point in the history 
* Deduplicate field logic into runtime utility #14

* output of insta snapshot tests changed intentionally

* moved macro functions to __private subpackage with warning

* lint

* more lint

* improved generated output, moved parse to runtime

---------

Co-authored-by: ilonachan <[email protected]>
  • Loading branch information
@ilonachan
ilonachan and ilonachan authored Nov 4, 2023
1 parent fa2b07c commit c5c78ef
Show file tree
Hide file tree
Showing 13 changed files with 663 additions and 1,946 deletions.
386 changes: 133 additions & 253 deletions macro/src/expansion.rs
View file

Large diffs are not rendered by default.

290 changes: 55 additions & 235 deletions macro/src/snapshots/rust_sitter_macro__tests__enum_prec_left.snap
View file

Large diffs are not rendered by default.

240 changes: 50 additions & 190 deletions macro/src/snapshots/rust_sitter_macro__tests__enum_recursive.snap
View file
Original file line number Diff line number Diff line change
@@ -1,191 +1,64 @@
---
source: macro/src/lib.rs
expression: "rustfmt_code(&expand_grammar(parse_quote! {\n #[rust_sitter :: grammar(\"test\")] mod grammar\n {\n #[rust_sitter :: language] pub enum Expression\n {\n Number(#[rust_sitter ::\n leaf(pattern = r\"\\d+\", transform = | v |\n v.parse().unwrap())] i32),\n Neg(#[rust_sitter :: leaf(text = \"-\")] (), Box < Expression\n >),\n }\n }\n }).to_token_stream().to_string())"
expression: "rustfmt_code(&expand_grammar(parse_quote! {\n #[rust_sitter :: grammar(\"test\")] mod grammar\n {\n #[rust_sitter :: language] pub enum Expression\n {\n Number(#[rust_sitter ::\n leaf(pattern = r\"\\d+\", transform = | v |\n v.parse().unwrap())] i32),\n Neg(#[rust_sitter :: leaf(text = \"-\")] (), Box < Expression\n >),\n }\n }\n })?.to_token_stream().to_string())"
---
mod grammar {
pub enum Expression {
Number(i32),
Neg((), Box<Expression>),
}
impl rust_sitter::Extract<Expression> for Expression {
impl ::rust_sitter::Extract<Expression> for Expression {
type LeafFn = ();
#[allow(non_snake_case)]
fn extract(
node: Option<rust_sitter::tree_sitter::Node>,
node: Option<::rust_sitter::tree_sitter::Node>,
source: &[u8],
_last_idx: usize,
_leaf_fn: Option<&Self::LeafFn>,
) -> Self {
let node = node.unwrap();
#[allow(non_snake_case)]
#[allow(clippy::unused_unit)]
fn extract_Expression_Number_0(
cursor_opt: &mut Option<rust_sitter::tree_sitter::TreeCursor>,
source: &[u8],
last_idx: &mut usize,
) -> i32 {
if let Some(cursor) = cursor_opt.as_mut() {
loop {
let n = cursor.node();
if let Some(name) = cursor.field_name() {
if name == "0" {
let node: Option<rust_sitter::tree_sitter::Node> = Some(n);
let out = < rust_sitter :: WithLeaf < i32 > as rust_sitter :: Extract < _ > > :: extract (node , source , * last_idx , Some (& | v | v . parse () . unwrap ())) ;
if !cursor.goto_next_sibling() {
*cursor_opt = None;
};
*last_idx = n.end_byte();
return out;
} else {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return < rust_sitter :: WithLeaf < i32 > as rust_sitter :: Extract < _ > > :: extract (node , source , * last_idx , Some (& | v | v . parse () . unwrap ())) ;
}
} else {
*last_idx = n.end_byte();
}
if !cursor.goto_next_sibling() {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return < rust_sitter :: WithLeaf < i32 > as rust_sitter :: Extract < _ > > :: extract (node , source , * last_idx , Some (& | v | v . parse () . unwrap ())) ;
}
}
} else {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <rust_sitter::WithLeaf<i32> as rust_sitter::Extract<_>>::extract(
node,
source,
*last_idx,
Some(&|v| v.parse().unwrap()),
);
}
}
#[allow(non_snake_case)]
fn extract_Expression_Number(
node: rust_sitter::tree_sitter::Node,
source: &[u8],
) -> Expression {
let mut last_idx = node.start_byte();
let mut parent_cursor = node.walk();
let mut cursor = if parent_cursor.goto_first_child() {
Some(parent_cursor)
} else {
None
};
Expression::Number(extract_Expression_Number_0(
&mut cursor,
source,
&mut last_idx,
))
}
#[allow(non_snake_case)]
#[allow(clippy::unused_unit)]
fn extract_Expression_Neg_0(
cursor_opt: &mut Option<rust_sitter::tree_sitter::TreeCursor>,
source: &[u8],
last_idx: &mut usize,
) -> () {
if let Some(cursor) = cursor_opt.as_mut() {
loop {
let n = cursor.node();
if let Some(name) = cursor.field_name() {
if name == "0" {
let node: Option<rust_sitter::tree_sitter::Node> = Some(n);
let out = <() as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
if !cursor.goto_next_sibling() {
*cursor_opt = None;
};
*last_idx = n.end_byte();
return out;
} else {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <() as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
}
} else {
*last_idx = n.end_byte();
}
if !cursor.goto_next_sibling() {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <() as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
}
}
} else {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <() as rust_sitter::Extract<_>>::extract(node, source, *last_idx, None);
}
}
#[allow(non_snake_case)]
#[allow(clippy::unused_unit)]
fn extract_Expression_Neg_1(
cursor_opt: &mut Option<rust_sitter::tree_sitter::TreeCursor>,
source: &[u8],
last_idx: &mut usize,
) -> Box<Expression> {
if let Some(cursor) = cursor_opt.as_mut() {
loop {
let n = cursor.node();
if let Some(name) = cursor.field_name() {
if name == "1" {
let node: Option<rust_sitter::tree_sitter::Node> = Some(n);
let out = <Box<Expression> as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
if !cursor.goto_next_sibling() {
*cursor_opt = None;
};
*last_idx = n.end_byte();
return out;
} else {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <Box<Expression> as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
}
} else {
*last_idx = n.end_byte();
}
if !cursor.goto_next_sibling() {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <Box<Expression> as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
}
}
} else {
let node: Option<rust_sitter::tree_sitter::Node> = None;
return <Box<Expression> as rust_sitter::Extract<_>>::extract(
node, source, *last_idx, None,
);
}
}
#[allow(non_snake_case)]
fn extract_Expression_Neg(
node: rust_sitter::tree_sitter::Node,
source: &[u8],
) -> Expression {
let mut last_idx = node.start_byte();
let mut parent_cursor = node.walk();
let mut cursor = if parent_cursor.goto_first_child() {
Some(parent_cursor)
} else {
None
};
Expression::Neg(
extract_Expression_Neg_0(&mut cursor, source, &mut last_idx),
extract_Expression_Neg_1(&mut cursor, source, &mut last_idx),
)
}
let mut cursor = node.walk();
assert!(cursor.goto_first_child());
assert!(
cursor.goto_first_child(),
"Could not find a child corresponding to any enum branch"
);
loop {
let n = cursor.node();
match n.kind() {
"Expression_Number" => return extract_Expression_Number(n, source),
"Expression_Neg" => return extract_Expression_Neg(n, source),
let node = cursor.node();
match node.kind() {
"Expression_Number" => {
return ::rust_sitter::__private::extract_struct_or_variant(
node,
move |cursor, last_idx| {
Expression::Number({
::rust_sitter::__private::extract_field::<
rust_sitter::WithLeaf<i32>,
_,
>(
cursor, source, last_idx, "0", Some(&|v| v.parse().unwrap())
)
})
},
)
}
"Expression_Neg" => {
return ::rust_sitter::__private::extract_struct_or_variant(
node,
move |cursor, last_idx| {
Expression::Neg(
{
::rust_sitter::__private::extract_field::<(), _>(
cursor, source, last_idx, "0", None,
)
},
{
::rust_sitter::__private::extract_field::<Box<Expression>, _>(
cursor, source, last_idx, "1", None,
)
},
)
},
)
}
_ => {
if !cursor.goto_next_sibling() {
panic!("Could not find a child corresponding to any enum branch")
Expand All @@ -196,31 +69,18 @@ mod grammar {
}
}
extern "C" {
fn tree_sitter_test() -> rust_sitter::tree_sitter::Language;
fn tree_sitter_test() -> ::rust_sitter::tree_sitter::Language;
}
pub fn language() -> rust_sitter::tree_sitter::Language {
pub fn language() -> ::rust_sitter::tree_sitter::Language {
unsafe { tree_sitter_test() }
}
#[doc = r" Parse an input string according to the grammar. Returns either any parsing errors that happened, or a"]
#[doc = "[`Expression`]"]
#[doc = r" instance containing the parsed structured data."]
pub fn parse(
input: &str,
) -> core::result::Result<Expression, Vec<rust_sitter::errors::ParseError>> {
let mut parser = rust_sitter::tree_sitter::Parser::new();
parser.set_language(language()).unwrap();
let tree = parser.parse(input, None).unwrap();
let root_node = tree.root_node();
if root_node.has_error() {
let mut errors = vec![];
rust_sitter::errors::collect_parsing_errors(&root_node, input.as_bytes(), &mut errors);
Err(errors)
} else {
use rust_sitter::Extract;
Ok(<Expression as rust_sitter::Extract<_>>::extract(
Some(root_node),
input.as_bytes(),
0,
None,
))
}
) -> core::result::Result<Expression, Vec<::rust_sitter::errors::ParseError>> {
::rust_sitter::__private::parse::<Expression>(input, language)
}
}

Loading

0 comments on commit c5c78ef

Please sign in to comment.