language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-27 04:19:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

internal: rename

Browse source
This commit is contained in:
Aleksey Kladov 2021-12-25 21:59:02 +03:00
parent d0d05075ed
commit 74de79b1da
13 changed files with 106 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/mbe/src/lib.rs
View file

@ -10,7 +10,7 @@ mod parser;
mod expander;
mod syntax_bridge;
mod tt_iter;
mod to_parser_tokens;
mod to_parser_input;
#[cfg(test)]
mod benchmark;

16
crates/mbe/src/syntax_bridge.rs
View file

@ -10,7 +10,7 @@ use syntax::{
use tt::buffer::{Cursor, TokenBuffer};
use crate::{
to_parser_tokens::to_parser_tokens, tt_iter::TtIter, ExpandError, ParserEntryPoint, TokenMap,
to_parser_input::to_parser_input, tt_iter::TtIter, ExpandError, ParserEntryPoint, TokenMap,
};
/// Convert the syntax node to a `TokenTree` (what macro
@ -54,17 +54,17 @@ pub fn token_tree_to_syntax_node(
}
_ => TokenBuffer::from_subtree(tt),
};
let parser_tokens = to_parser_tokens(&buffer);
let tree_traversal = parser::parse(&parser_tokens, entry_point);
let parser_input = to_parser_input(&buffer);
let parser_output = parser::parse(&parser_input, entry_point);
let mut tree_sink = TtTreeSink::new(buffer.begin());
for event in tree_traversal.iter() {
for event in parser_output.iter() {
match event {
parser::TraversalStep::Token { kind, n_raw_tokens } => {
parser::Step::Token { kind, n_input_tokens: n_raw_tokens } => {
tree_sink.token(kind, n_raw_tokens)
}
parser::TraversalStep::EnterNode { kind } => tree_sink.start_node(kind),
parser::TraversalStep::LeaveNode => tree_sink.finish_node(),
parser::TraversalStep::Error { msg } => tree_sink.error(msg.to_string()),
parser::Step::Enter { kind } => tree_sink.start_node(kind),
parser::Step::Exit => tree_sink.finish_node(),
parser::Step::Error { msg } => tree_sink.error(msg.to_string()),
}
}
if tree_sink.roots.len() != 1 {

4
crates/mbe/src/to_parser_tokens.rs → crates/mbe/src/to_parser_input.rs
View file

@ -4,8 +4,8 @@
use syntax::{SyntaxKind, SyntaxKind::*, T};
use tt::buffer::TokenBuffer;
pub(crate) fn to_parser_tokens(buffer: &TokenBuffer) -> parser::Tokens {
let mut res = parser::Tokens::default();
pub(crate) fn to_parser_input(buffer: &TokenBuffer) -> parser::Input {
let mut res = parser::Input::default();
let mut current = buffer.begin();

16
crates/mbe/src/tt_iter.rs
View file

@ -1,7 +1,7 @@
//! A "Parser" structure for token trees. We use this when parsing a declarative
//! macro definition into a list of patterns and templates.
use crate::{to_parser_tokens::to_parser_tokens, ExpandError, ExpandResult, ParserEntryPoint};
use crate::{to_parser_input::to_parser_input, ExpandError, ExpandResult, ParserEntryPoint};
use syntax::SyntaxKind;
use tt::buffer::TokenBuffer;
@ -94,23 +94,23 @@ impl<'a> TtIter<'a> {
entry_point: ParserEntryPoint,
) -> ExpandResult<Option<tt::TokenTree>> {
let buffer = TokenBuffer::from_tokens(self.inner.as_slice());
let parser_tokens = to_parser_tokens(&buffer);
let tree_traversal = parser::parse(&parser_tokens, entry_point);
let parser_input = to_parser_input(&buffer);
let tree_traversal = parser::parse(&parser_input, entry_point);
let mut cursor = buffer.begin();
let mut error = false;
for step in tree_traversal.iter() {
match step {
parser::TraversalStep::Token { kind, mut n_raw_tokens } => {
parser::Step::Token { kind, mut n_input_tokens } => {
if kind == SyntaxKind::LIFETIME_IDENT {
n_raw_tokens = 2;
n_input_tokens = 2;
}
for _ in 0..n_raw_tokens {
for _ in 0..n_input_tokens {
cursor = cursor.bump_subtree();
}
}
parser::TraversalStep::EnterNode { .. } | parser::TraversalStep::LeaveNode => (),
parser::TraversalStep::Error { .. } => error = true,
parser::Step::Enter { .. } | parser::Step::Exit => (),
parser::Step::Error { .. } => error = true,
}
}