bendns' repos / rust-analyzer
Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/mbe/src/expander/matcher.rs')
-rw-r--r--crates/mbe/src/expander/matcher.rs46
1 files changed, 23 insertions, 23 deletions
diff --git a/crates/mbe/src/expander/matcher.rs b/crates/mbe/src/expander/matcher.rs
index a21468fbb0..8f6627a60f 100644
--- a/crates/mbe/src/expander/matcher.rs
+++ b/crates/mbe/src/expander/matcher.rs
@@ -63,7 +63,6 @@ use std::{rc::Rc, sync::Arc};
use intern::{Symbol, sym};
use smallvec::{SmallVec, smallvec};
-use span::Span;
use tt::{
DelimSpan,
iter::{TtElement, TtIter},
@@ -114,7 +113,7 @@ impl Match<'_> {
pub(super) fn match_<'t>(
db: &dyn salsa::Database,
pattern: &'t MetaTemplate,
- input: &'t tt::TopSubtree<Span>,
+ input: &'t tt::TopSubtree,
) -> Match<'t> {
let mut res = match_loop(db, pattern, input);
res.bound_count = count(res.bindings.bindings());
@@ -339,7 +338,7 @@ struct MatchState<'t> {
bindings: BindingsIdx,
/// Cached result of meta variable parsing
- meta_result: Option<(TtIter<'t, Span>, ExpandResult<Option<Fragment<'t>>>)>,
+ meta_result: Option<(TtIter<'t>, ExpandResult<Option<Fragment<'t>>>)>,
/// Is error occurred in this state, will `poised` to "parent"
is_error: bool,
@@ -366,8 +365,8 @@ struct MatchState<'t> {
#[inline]
fn match_loop_inner<'t>(
db: &dyn salsa::Database,
- src: TtIter<'t, Span>,
- stack: &[TtIter<'t, Span>],
+ src: TtIter<'t>,
+ stack: &[TtIter<'t>],
res: &mut Match<'t>,
bindings_builder: &mut BindingsBuilder<'t>,
cur_items: &mut SmallVec<[MatchState<'t>; 1]>,
@@ -375,7 +374,7 @@ fn match_loop_inner<'t>(
next_items: &mut Vec<MatchState<'t>>,
eof_items: &mut SmallVec<[MatchState<'t>; 1]>,
error_items: &mut SmallVec<[MatchState<'t>; 1]>,
- delim_span: tt::DelimSpan<Span>,
+ delim_span: tt::DelimSpan,
) {
macro_rules! try_push {
($items: expr, $it:expr) => {
@@ -518,7 +517,8 @@ fn match_loop_inner<'t>(
}
OpDelimited::Op(Op::Literal(lhs)) => {
if let Ok(rhs) = src.clone().expect_leaf() {
- if matches!(rhs, tt::Leaf::Literal(it) if it.symbol == lhs.symbol) {
+ if matches!(&rhs, tt::Leaf::Literal(it) if it.text_and_suffix == lhs.text_and_suffix)
+ {
item.dot.next();
} else {
res.add_err(ExpandError::new(
@@ -538,7 +538,7 @@ fn match_loop_inner<'t>(
}
OpDelimited::Op(Op::Ident(lhs)) => {
if let Ok(rhs) = src.clone().expect_leaf() {
- if matches!(rhs, tt::Leaf::Ident(it) if it.sym == lhs.sym) {
+ if matches!(&rhs, tt::Leaf::Ident(it) if it.sym == lhs.sym) {
item.dot.next();
} else {
res.add_err(ExpandError::new(
@@ -623,11 +623,11 @@ fn match_loop_inner<'t>(
fn match_loop<'t>(
db: &dyn salsa::Database,
pattern: &'t MetaTemplate,
- src: &'t tt::TopSubtree<Span>,
+ src: &'t tt::TopSubtree,
) -> Match<'t> {
let span = src.top_subtree().delimiter.delim_span();
let mut src = src.iter();
- let mut stack: SmallVec<[TtIter<'_, Span>; 1]> = SmallVec::new();
+ let mut stack: SmallVec<[TtIter<'_>; 1]> = SmallVec::new();
let mut res = Match::default();
let mut error_recover_item = None;
@@ -702,7 +702,7 @@ fn match_loop<'t>(
|| !(bb_items.is_empty() || next_items.is_empty())
|| bb_items.len() > 1;
if has_leftover_tokens {
- res.unmatched_tts += src.remaining().flat_tokens().len();
+ res.unmatched_tts += src.remaining().len();
res.add_err(ExpandError::new(span.open, ExpandErrorKind::LeftoverTokens));
if let Some(error_recover_item) = error_recover_item {
@@ -774,8 +774,8 @@ fn match_loop<'t>(
fn match_meta_var<'t>(
db: &dyn salsa::Database,
kind: MetaVarKind,
- input: &mut TtIter<'t, Span>,
- delim_span: DelimSpan<Span>,
+ input: &mut TtIter<'t>,
+ delim_span: DelimSpan,
) -> ExpandResult<Fragment<'t>> {
let fragment = match kind {
MetaVarKind::Path => {
@@ -879,10 +879,10 @@ fn collect_vars(collector_fun: &mut impl FnMut(Symbol), pattern: &MetaTemplate)
}
}
impl MetaTemplate {
- fn iter_delimited_with(&self, delimiter: tt::Delimiter<Span>) -> OpDelimitedIter<'_> {
+ fn iter_delimited_with(&self, delimiter: tt::Delimiter) -> OpDelimitedIter<'_> {
OpDelimitedIter { inner: &self.0, idx: 0, delimited: delimiter }
}
- fn iter_delimited(&self, span: tt::DelimSpan<Span>) -> OpDelimitedIter<'_> {
+ fn iter_delimited(&self, span: tt::DelimSpan) -> OpDelimitedIter<'_> {
OpDelimitedIter {
inner: &self.0,
idx: 0,
@@ -901,7 +901,7 @@ enum OpDelimited<'a> {
#[derive(Debug, Clone, Copy)]
struct OpDelimitedIter<'a> {
inner: &'a [Op],
- delimited: tt::Delimiter<Span>,
+ delimited: tt::Delimiter,
idx: usize,
}
@@ -945,7 +945,7 @@ impl<'a> Iterator for OpDelimitedIter<'a> {
}
}
-fn expect_separator<S: Copy>(iter: &mut TtIter<'_, S>, separator: &Separator) -> bool {
+fn expect_separator(iter: &mut TtIter<'_>, separator: &Separator) -> bool {
let mut fork = iter.clone();
let ok = match separator {
Separator::Ident(lhs) => match fork.expect_ident_or_underscore() {
@@ -954,8 +954,8 @@ fn expect_separator<S: Copy>(iter: &mut TtIter<'_, S>, separator: &Separator) ->
},
Separator::Literal(lhs) => match fork.expect_literal() {
Ok(rhs) => match rhs {
- tt::Leaf::Literal(rhs) => rhs.symbol == lhs.symbol,
- tt::Leaf::Ident(rhs) => rhs.sym == lhs.symbol,
+ tt::Leaf::Literal(rhs) => rhs.text_and_suffix == lhs.text_and_suffix,
+ tt::Leaf::Ident(rhs) => rhs.sym == lhs.text_and_suffix,
tt::Leaf::Punct(_) => false,
},
Err(_) => false,
@@ -979,7 +979,7 @@ fn expect_separator<S: Copy>(iter: &mut TtIter<'_, S>, separator: &Separator) ->
ok
}
-fn expect_tt<S: Copy>(iter: &mut TtIter<'_, S>) -> Result<(), ()> {
+fn expect_tt(iter: &mut TtIter<'_>) -> Result<(), ()> {
if let Some(TtElement::Leaf(tt::Leaf::Punct(punct))) = iter.peek() {
if punct.char == '\'' {
expect_lifetime(iter)?;
@@ -992,7 +992,7 @@ fn expect_tt<S: Copy>(iter: &mut TtIter<'_, S>) -> Result<(), ()> {
Ok(())
}
-fn expect_lifetime<'a, S: Copy>(iter: &mut TtIter<'a, S>) -> Result<&'a tt::Ident<S>, ()> {
+fn expect_lifetime<'a>(iter: &mut TtIter<'a>) -> Result<tt::Ident, ()> {
let punct = iter.expect_single_punct()?;
if punct.char != '\'' {
return Err(());
@@ -1000,8 +1000,8 @@ fn expect_lifetime<'a, S: Copy>(iter: &mut TtIter<'a, S>) -> Result<&'a tt::Iden
iter.expect_ident_or_underscore()
}
-fn eat_char<S: Copy>(iter: &mut TtIter<'_, S>, c: char) {
- if matches!(iter.peek(), Some(TtElement::Leaf(tt::Leaf::Punct(tt::Punct { char, .. }))) if *char == c)
+fn eat_char(iter: &mut TtIter<'_>, c: char) {
+ if matches!(iter.peek(), Some(TtElement::Leaf(tt::Leaf::Punct(tt::Punct { char, .. }))) if char == c)
{
iter.next().expect("already peeked");
}