From 41544a40883874553f570e2999bf56d172bd6246 Mon Sep 17 00:00:00 2001 From: Edwin Cheng Date: Wed, 18 Dec 2019 11:47:26 +0800 Subject: Refactoring --- crates/ra_mbe/src/mbe_expander/matcher.rs | 2 +- crates/ra_mbe/src/subtree_source.rs | 8 +-- crates/ra_mbe/src/syntax_bridge.rs | 92 +++++++++++++++---------------- 3 files changed, 50 insertions(+), 52 deletions(-) (limited to 'crates/ra_mbe') diff --git a/crates/ra_mbe/src/mbe_expander/matcher.rs b/crates/ra_mbe/src/mbe_expander/matcher.rs index c67ae4110..e36b5a412 100644 --- a/crates/ra_mbe/src/mbe_expander/matcher.rs +++ b/crates/ra_mbe/src/mbe_expander/matcher.rs @@ -106,7 +106,7 @@ fn match_subtree( } Op::TokenTree(tt::TokenTree::Subtree(lhs)) => { let rhs = src.expect_subtree().map_err(|()| err!("expected subtree"))?; - if lhs.delimiter.map(|it| it.kind) != rhs.delimiter.map(|it| it.kind) { + if lhs.delimiter_kind() != rhs.delimiter_kind() { bail!("mismatched delimiter") } let mut src = TtIter::new(rhs); diff --git a/crates/ra_mbe/src/subtree_source.rs b/crates/ra_mbe/src/subtree_source.rs index 5a03a372a..b841c39d3 100644 --- a/crates/ra_mbe/src/subtree_source.rs +++ b/crates/ra_mbe/src/subtree_source.rs @@ -70,11 +70,11 @@ impl<'a> SubtreeTokenSource<'a> { } Some(tt::TokenTree::Subtree(subtree)) => { self.cached_cursor.set(cursor.subtree().unwrap()); - cached.push(Some(convert_delim(subtree.delimiter, false))); + cached.push(Some(convert_delim(subtree.delimiter_kind(), false))); } None => { if let Some(subtree) = cursor.end() { - cached.push(Some(convert_delim(subtree.delimiter, true))); + cached.push(Some(convert_delim(subtree.delimiter_kind(), true))); self.cached_cursor.set(cursor.bump()); } } @@ -114,8 +114,8 @@ impl<'a> TokenSource for SubtreeTokenSource<'a> { } } -fn convert_delim(d: Option, closing: bool) -> TtToken { - let (kinds, texts) = match d.map(|it| it.kind) { +fn convert_delim(d: Option, closing: bool) -> TtToken { + let (kinds, texts) = match d { Some(tt::DelimiterKind::Parenthesis) => ([T!['('], T![')']], "()"), Some(tt::DelimiterKind::Brace) => ([T!['{'], T!['}']], "{}"), Some(tt::DelimiterKind::Bracket) => ([T!['['], T![']']], "[]"), diff --git a/crates/ra_mbe/src/syntax_bridge.rs b/crates/ra_mbe/src/syntax_bridge.rs index d585d57af..2c60430d1 100644 --- a/crates/ra_mbe/src/syntax_bridge.rs +++ b/crates/ra_mbe/src/syntax_bridge.rs @@ -269,35 +269,33 @@ impl Convertor { .take(token.text().len() - 1) .chain(std::iter::once(last_spacing)); for (char, spacing) in token.text().chars().zip(spacing_iter) { - let id = self.alloc(token.text_range()); - token_trees - .push(tt::Leaf::from(tt::Punct { char, spacing, id }).into()); + token_trees.push( + tt::Leaf::from(tt::Punct { + char, + spacing, + id: self.alloc(token.text_range()), + }) + .into(), + ); } } else { + macro_rules! make_leaf { + ($i:ident) => { + tt::$i { + id: self.alloc(token.text_range()), + text: token.text().clone(), + } + .into() + }; + } + let child: tt::Leaf = match token.kind() { - T![true] | T![false] => { - let id = self.alloc(token.text_range()); - let text = token.text().clone(); - tt::Literal { text, id }.into() - } - IDENT | LIFETIME => { - let id = self.alloc(token.text_range()); - let text = token.text().clone(); - tt::Ident { text, id }.into() - } - k if k.is_keyword() => { - let id = self.alloc(token.text_range()); - let text = token.text().clone(); - tt::Ident { text, id }.into() - } - k if k.is_literal() => { - let id = self.alloc(token.text_range()); - let text = token.text().clone(); - tt::Literal { text, id }.into() - } + T![true] | T![false] => make_leaf!(Literal), + IDENT | LIFETIME => make_leaf!(Ident), + k if k.is_keyword() => make_leaf!(Ident), + k if k.is_literal() => make_leaf!(Literal), _ => return None, }; - token_trees.push(child.into()); } } @@ -370,8 +368,8 @@ impl<'a> TtTreeSink<'a> { } } -fn delim_to_str(d: Option, closing: bool) -> SmolStr { - let texts = match d.map(|it| it.kind) { +fn delim_to_str(d: Option, closing: bool) -> SmolStr { + let texts = match d { Some(tt::DelimiterKind::Parenthesis) => "()", Some(tt::DelimiterKind::Brace) => "{}", Some(tt::DelimiterKind::Bracket) => "[]", @@ -395,7 +393,7 @@ impl<'a> TreeSink for TtTreeSink<'a> { break; } - let text: Option = match self.cursor.token_tree() { + let text: SmolStr = match self.cursor.token_tree() { Some(tt::TokenTree::Leaf(leaf)) => { // Mark the range if needed let id = match leaf { @@ -407,35 +405,35 @@ impl<'a> TreeSink for TtTreeSink<'a> { let range = TextRange::offset_len(self.text_pos, TextUnit::of_str(&text)); self.token_map.insert(id, range); self.cursor = self.cursor.bump(); - Some(text) + text } Some(tt::TokenTree::Subtree(subtree)) => { self.cursor = self.cursor.subtree().unwrap(); if let Some(id) = subtree.delimiter.map(|it| it.id) { self.open_delims.insert(id, self.text_pos); } - Some(delim_to_str(subtree.delimiter, false)) + delim_to_str(subtree.delimiter_kind(), false) } - None => self.cursor.end().and_then(|parent| { - self.cursor = self.cursor.bump(); - if let Some(id) = parent.delimiter.map(|it| it.id) { - if let Some(open_delim) = self.open_delims.get(&id) { - let open_range = - TextRange::offset_len(*open_delim, TextUnit::from_usize(1)); - let close_range = - TextRange::offset_len(self.text_pos, TextUnit::from_usize(1)); - self.token_map.insert_delim(id, open_range, close_range); + None => { + if let Some(parent) = self.cursor.end() { + self.cursor = self.cursor.bump(); + if let Some(id) = parent.delimiter.map(|it| it.id) { + if let Some(open_delim) = self.open_delims.get(&id) { + let open_range = + TextRange::offset_len(*open_delim, TextUnit::from_usize(1)); + let close_range = + TextRange::offset_len(self.text_pos, TextUnit::from_usize(1)); + self.token_map.insert_delim(id, open_range, close_range); + } } + delim_to_str(parent.delimiter_kind(), true) + } else { + continue; } - - Some(delim_to_str(parent.delimiter, true)) - }), + } }; - - if let Some(text) = text { - self.buf += &text; - self.text_pos += TextUnit::of_str(&text); - } + self.buf += &text; + self.text_pos += TextUnit::of_str(&text); } let text = SmolStr::new(self.buf.as_str()); @@ -583,7 +581,7 @@ mod tests { let token_tree = ast::TokenTree::cast(token_tree).unwrap(); let tt = ast_to_token_tree(&token_tree).unwrap().0; - assert_eq!(tt.delimiter.map(|it| it.kind), Some(tt::DelimiterKind::Brace)); + assert_eq!(tt.delimiter_kind(), Some(tt::DelimiterKind::Brace)); } #[test] -- cgit v1.2.3