+use arrayvec::ArrayString;

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

+pub struct TopSubtree(Box<[TokenTree]>);

+ pub fn from_serialized(tt: Vec<TokenTree>) -> Self {

+ Self(tt.into_boxed_slice())

+ }

+

+ pub fn top_subtree(&self) -> Subtree {

+ pub fn set_top_subtree_delimiter_kind(&mut self, kind: DelimiterKind) {

+ self.top_subtree_mut().delimiter.kind = kind;

+ }

+

+ pub fn set_top_subtree_delimiter_span(&mut self, span: DelimSpan) {

+ let top_subtree = self.top_subtree_mut();

+ top_subtree.delimiter.open = span.open;

+ top_subtree.delimiter.close = span.close;

+ }

+

+ fn top_subtree_mut(&mut self) -> &mut Subtree {

+ subtree

+ }

+

+ pub fn set_token(&mut self, idx: usize, leaf: Leaf) {

+ assert!(matches!(self.0[idx], TokenTree::Leaf(_)), "cannot replace a subtree by a leaf");

+ self.0[idx] = leaf.into();

+

+ pub fn as_token_trees(&self) -> TokenTreesView<'_> {

+ self.view().as_token_trees()

+ }

+

+ pub fn change_every_ast_id(&mut self, mut callback: impl FnMut(&mut span::ErasedFileAstId)) {

+ for tt in &mut self.0 {

+ match tt {

+ TokenTree::Leaf(Leaf::Ident(Ident { span, .. }))

+ | TokenTree::Leaf(Leaf::Literal(Literal { span, .. }))

+ | TokenTree::Leaf(Leaf::Punct(Punct { span, .. })) => {

+ callback(&mut span.anchor.ast_id);

+ }

+ TokenTree::Subtree(subtree) => {

+ callback(&mut subtree.delimiter.open.anchor.ast_id);

+ callback(&mut subtree.delimiter.close.anchor.ast_id);

+ }

+ }

+ }

+ }

+ pub fn expected_delimiters(&self) -> impl Iterator<Item = DelimiterKind> {

+ subtree.delimiter.kind

+ fn new(tts: &'a [TokenTree]) -> Self {

+ pub fn empty() -> Self {

+ Self(&[])

+ }

+

+ Cursor::new(*self)

+

+ pub fn first_span(&self) -> Option<Span> {

+ Some(self.0.first()?.first_span())

+ }

+

+ pub fn last_span(&self) -> Option<Span> {

+ Some(match self.0.last()? {

+ TokenTree::Leaf(it) => *it.span(),

+ TokenTree::Subtree(it) => it.delimiter.close,

+ })

+ }

+

+ pub fn iter_flat_tokens(&self) -> impl ExactSizeIterator<Item = TokenTree> + use<'a> {

+ self.0.iter().cloned()

+ }

+ fmt::Display::fmt(&p, f)?;

+ TtElement::Leaf(leaf) => fmt::Display::fmt(&leaf, f)?,

+ subtree_display(&subtree, f, subtree_iter)?

+ pub fn top_subtree(&self) -> Subtree {

+ *subtree

+ /// Escaped, text then suffix concatenated.

+ pub text_and_suffix: Symbol,

+ pub suffix_len: u8,

+impl Literal {

+ #[inline]

+ pub fn text_and_suffix(&self) -> (&str, &str) {

+ let text_and_suffix = self.text_and_suffix.as_str();

+ text_and_suffix.split_at(text_and_suffix.len() - usize::from(self.suffix_len))

+ }

+

+ #[inline]

+ pub fn text(&self) -> &str {

+ self.text_and_suffix().0

+ }

+

+ #[inline]

+ pub fn suffix(&self) -> &str {

+ self.text_and_suffix().1

+ }

+

+ pub fn new(text: &str, span: Span, kind: LitKind, suffix: &str) -> Self {

+ const MAX_INLINE_CAPACITY: usize = 30;

+ let text_and_suffix = if suffix.is_empty() {

+ Symbol::intern(text)

+ } else if (text.len() + suffix.len()) < MAX_INLINE_CAPACITY {

+ let mut text_and_suffix = ArrayString::<MAX_INLINE_CAPACITY>::new();

+ text_and_suffix.push_str(text);

+ text_and_suffix.push_str(suffix);

+ Symbol::intern(&text_and_suffix)

+ } else {

+ let mut text_and_suffix = String::with_capacity(text.len() + suffix.len());

+ text_and_suffix.push_str(text);

+ text_and_suffix.push_str(suffix);

+ Symbol::intern(&text_and_suffix)

+ };

+

+ Self { text_and_suffix, span, kind, suffix_len: suffix.len().try_into().unwrap() }

+ }

+

+ #[inline]

+ pub fn new_no_suffix(text: &str, span: Span, kind: LitKind) -> Self {

+ Self { text_and_suffix: Symbol::intern(text), span, kind, suffix_len: 0 }

+ }

+}

+

+pub fn token_to_literal(text: &str, span: Span) -> Literal {

+ return Literal::new_no_suffix(text, span, LitKind::Err(()));

+ "" | "_" => "",

+ return Literal::new_no_suffix(text, span, LitKind::Err(()));

+ suffix => suffix,

+ Literal::new(lit, span, kind, suffix)

+ let (text, suffix) = lit.text_and_suffix();

+ write!(f, "{}LITERAL {:?} {}{} {:#?}", align, lit.kind, text, suffix, lit.span)?;

+ print_debug_subtree(f, &subtree, level, subtree_iter)?;

+ let (text, suffix) = self.text_and_suffix();

+ LitKind::Byte => write!(f, "b'{}'", text),

+ LitKind::Char => write!(f, "'{}'", text),

+ LitKind::Integer | LitKind::Float | LitKind::Err(_) => write!(f, "{}", text),

+ LitKind::Str => write!(f, "\"{}\"", text),

+ LitKind::ByteStr => write!(f, "b\"{}\"", text),

+ LitKind::CStr => write!(f, "c\"{}\"", text),

+ write!(f, r#"r{0:#<num_of_hashes$}"{text}"{0:#<num_of_hashes$}"#, "", text = text)

+ write!(f, r#"br{0:#<num_of_hashes$}"{text}"{0:#<num_of_hashes$}"#, "", text = text)

+ write!(f, r#"cr{0:#<num_of_hashes$}"{text}"{0:#<num_of_hashes$}"#, "", text = text)

+ write!(f, "{suffix}")?;

+ Leaf::Literal(it) => it.text().to_owned(),

+pub fn pretty(tkns: TokenTreesView<'_>) -> String {

+ let content = pretty(TokenTreesView(subtree_content));

+ let mut tkns = tkns.0;

+

+#[derive(Debug)]

+pub enum TransformTtAction<'a> {

+ Keep,

+ ReplaceWith(TokenTreesView<'a>),

+}

+

+impl TransformTtAction<'_> {

+ #[inline]

+ pub fn remove() -> Self {

+ Self::ReplaceWith(TokenTreesView::empty())

+ }

+}

+

+/// This function takes a token tree, and calls `callback` with each token tree in it.

+/// Then it does what the callback says: keeps the tt or replaces it with a (possibly empty)

+/// tts view.

+pub fn transform_tt<'b>(

+ tt: &mut TopSubtree,

+ mut callback: impl FnMut(TokenTree) -> TransformTtAction<'b>,

+) {

+ let mut tt_vec = std::mem::take(&mut tt.0).into_vec();

+

+ // We need to keep a stack of the currently open subtrees, because we need to update

+ // them if we change the number of items in them.

+ let mut subtrees_stack = Vec::new();

+ let mut i = 0;

+ while i < tt_vec.len() {

+ 'pop_finished_subtrees: while let Some(&subtree_idx) = subtrees_stack.last() {

+ let TokenTree::Subtree(subtree) = &tt_vec[subtree_idx] else {

+ unreachable!("non-subtree on subtrees stack");

+ };

+ if i >= subtree_idx + 1 + subtree.usize_len() {

+ subtrees_stack.pop();

+ } else {

+ break 'pop_finished_subtrees;

+ }

+ }

+

+ let current = match &tt_vec[i] {

+ TokenTree::Leaf(leaf) => TokenTree::Leaf(match leaf {

+ Leaf::Literal(leaf) => Leaf::Literal(leaf.clone()),

+ Leaf::Punct(leaf) => Leaf::Punct(*leaf),

+ Leaf::Ident(leaf) => Leaf::Ident(leaf.clone()),

+ }),

+ TokenTree::Subtree(subtree) => TokenTree::Subtree(*subtree),

+ };

+ let action = callback(current);

+ match action {

+ TransformTtAction::Keep => {

+ // This cannot be shared with the replaced case, because then we may push the same subtree

+ // twice, and will update it twice which will lead to errors.

+ if let TokenTree::Subtree(_) = &tt_vec[i] {

+ subtrees_stack.push(i);

+ }

+

+ i += 1;

+ }

+ TransformTtAction::ReplaceWith(replacement) => {

+ let old_len = 1 + match &tt_vec[i] {

+ TokenTree::Leaf(_) => 0,

+ TokenTree::Subtree(subtree) => subtree.usize_len(),

+ };

+ let len_diff = replacement.len() as i64 - old_len as i64;

+ tt_vec.splice(i..i + old_len, replacement.0.iter().cloned());

+ // Skip the newly inserted replacement, we don't want to visit it.

+ i += replacement.len();

+

+ for &subtree_idx in &subtrees_stack {

+ let TokenTree::Subtree(subtree) = &mut tt_vec[subtree_idx] else {

+ unreachable!("non-subtree on subtrees stack");

+ };

+ subtree.len = (i64::from(subtree.len) + len_diff).try_into().unwrap();

+ }

+ }

+ }

+ }

+

+ tt.0 = tt_vec.into_boxed_slice();

+}