use buffer::Cursor;

use intern::Symbol;

use stdx::{impl_from, itertools::Itertools as _};

pub use text_size::{TextRange, TextSize};

pub const MAX_GLUED_PUNCT_LEN: usize = 3;

#[derive(Clone, PartialEq, Debug)]

}

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

}

match self {

TokenTree::Leaf(l) => *l.span(),

TokenTree::Subtree(s) => s.delimiter.open,

}

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

}

match self {

Leaf::Literal(it) => &it.span,

Leaf::Punct(it) => &it.span,

}

}

}

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

/// Number of following token trees that belong to this subtree, excluding this subtree.

pub len: u32,

}

pub fn usize_len(&self) -> usize {

self.len as usize

}

}

#[derive(Clone, PartialEq, Eq, Hash)]

Self(Box::new([TokenTree::Subtree(Subtree {

delimiter: Delimiter::invisible_delim_spanned(span),

len: 0,

})]))

}

let mut builder = TopSubtreeBuilder::new(Delimiter::invisible_spanned(delim_span));

builder.extend(leaves);

builder.build()

}

let mut builder = TopSubtreeBuilder::new(delimiter);

builder.extend_with_tt(token_trees);

builder.build()

}

Self(subtree.0.into())

}

SubtreeView::new(&self.0)

}

self.view().iter()

}

self.view().top_subtree()

}

let TokenTree::Subtree(subtree) = &mut self.0[0] else {

unreachable!("the first token tree is always the top subtree");

};

&mut subtree.delimiter

}

self.view().token_trees()

}

}

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

unclosed_subtree_indices: Vec<usize>,

last_closed_subtree: Option<usize>,

}

let mut result = Self {

unclosed_subtree_indices: Vec::new(),

token_trees: Vec::new(),

result

}

self.unclosed_subtree_indices.push(self.token_trees.len());

self.token_trees.push(TokenTree::Subtree(Subtree {

delimiter: Delimiter {

}));

}

let last_unclosed_index = self

.unclosed_subtree_indices

.pop()

}

}

self.token_trees.push(TokenTree::Leaf(leaf));

}

self.token_trees.extend(leaves.into_iter().map(TokenTree::Leaf));

}

/// This does not check the token trees are valid, beware!

self.token_trees.extend(tt);

}

self.token_trees.extend(tt.0.iter().cloned());

}

/// Like [`Self::extend_with_tt()`], but makes sure the new tokens will never be

/// joint with whatever comes after them.

if let Some((last, before_last)) = tt.0.split_last() {

self.token_trees.reserve(tt.0.len());

self.token_trees.extend(before_last.iter().cloned());

}

}

self.unclosed_subtree_indices.iter().rev().map(|&subtree_idx| {

let TokenTree::Subtree(subtree) = &self.token_trees[subtree_idx] else {

unreachable!("unclosed token tree is always a subtree")

}

/// Builds, and remove the top subtree if it has only one subtree child.

let top_tts = TokenTreesView::new(&self.token_trees[1..]);

match top_tts.try_into_subtree() {

Some(_) => {

}

}

assert!(

self.unclosed_subtree_indices.is_empty(),

"attempt to build an unbalanced `TopSubtreeBuilder`"

}

#[derive(Clone, Copy)]

if cfg!(debug_assertions) {

tts.iter().enumerate().for_each(|(idx, tt)| {

if let TokenTree::Subtree(tt) = &tt {

Self(tts)

}

TtIter::new(self.0)

}

Cursor::new(self.0)

}

self.0.is_empty()

}

if let Some(TokenTree::Subtree(subtree)) = self.0.first()

&& subtree.usize_len() == (self.0.len() - 1)

{

None

}

self.try_into_subtree().map(|subtree| subtree.strip_invisible()).unwrap_or(self)

}

/// This returns a **flat** structure of tokens (subtrees will be represented by a single node

/// preceding their children), so it isn't suited for most use cases, only for matching leaves

/// at the beginning/end with no subtrees before them. If you need a structured pass, use [`TtIter`].

self.0

}

pub fn split(

self,

let mut subtree_iter = self.iter();

let mut need_to_yield_even_if_empty = true;

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

let mut iter = self.iter();

while let Some(tt) = iter.next() {

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

return token_trees_display(f, self.iter());

f: &mut fmt::Formatter<'_>,

) -> fmt::Result {

let (l, r) = match subtree.delimiter.kind {

DelimiterKind::Parenthesis => ("(", ")"),

Ok(())

}

let mut needs_space = false;

for child in iter {

if needs_space {

#[derive(Clone, Copy)]

// Invariant: always starts with `Subtree` that covers the entire thing.

if cfg!(debug_assertions) {

let TokenTree::Subtree(subtree) = &tts[0] else {

panic!("first token tree must be a subtree in `SubtreeView`");

Self(tts)

}

TokenTreesView::new(self.0)

}

TtIter::new(&self.0[1..])

}

let TokenTree::Subtree(subtree) = &self.0[0] else {

unreachable!("the first token tree is always the top subtree");

};

subtree

}

if self.top_subtree().delimiter.kind == DelimiterKind::Invisible {

TokenTreesView::new(&self.0[1..])

} else {

}

}

TokenTreesView::new(&self.0[1..])

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fmt::Debug::fmt(&TokenTreesView(self.0), f)

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fmt::Display::fmt(&TokenTreesView(self.0), f)

}

}

#[derive(Debug, Copy, Clone, PartialEq)]

}

pub fn from_single(sp: Span) -> Self {

DelimSpan { open: sp, close: sp }

}

}

}

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

pub kind: DelimiterKind,

}

Delimiter { open: span, close: span, kind: DelimiterKind::Invisible }

}

Delimiter { open: span.open, close: span.close, kind: DelimiterKind::Invisible }

}

DelimSpan { open: self.open, close: self.close }

}

}

}

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

// escaped

pub symbol: Symbol,

pub kind: LitKind,

pub suffix: Option<Symbol>,

}

where

{

use rustc_lexer::LiteralKind;

}

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

pub char: char,

pub spacing: Spacing,

}

/// Indicates whether a token can join with the following token to form a

/// Identifier or keyword.

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

pub sym: Symbol,

pub is_raw: IdentIsRaw,

}

// let raw_stripped = IdentIsRaw::split_from_symbol(text.as_ref());

let (is_raw, text) = IdentIsRaw::split_from_symbol(text);

Ident { sym: Symbol::intern(text), span, is_raw }

}

}

f: &mut fmt::Formatter<'_>,

level: usize,

) -> fmt::Result {

let align = " ".repeat(level);

Ok(())

}

let align = " ".repeat(level);

match tt {

Ok(())

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fmt::Debug::fmt(&self.view(), f)

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fmt::Display::fmt(&self.view(), f)

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self {

Leaf::Ident(it) => fmt::Display::fmt(it, f),

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fmt::Display::fmt(&self.is_raw.as_str(), f)?;

fmt::Display::fmt(&self.sym, f)

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

match self.kind {

LitKind::Byte => write!(f, "b'{}'", self.symbol),

}

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

fmt::Display::fmt(&self.char, f)

}

}

/// Count the number of tokens recursively

pub fn count(&self) -> usize {

self.usize_len()

}

}

/// A simple line string used for debugging

pub fn subtree_as_debug_string(&self, subtree_idx: usize) -> String {

output: &mut String,

) {

let delim = match subtree.delimiter.kind {

DelimiterKind::Brace => ("{", "}"),

output.push_str(delim.1);

}

output: &mut String,

) {

match tt {

TokenTree::Leaf(it) => {

}

}

match tkn {

TokenTree::Leaf(Leaf::Ident(ident)) => {

format!("{}{}", ident.is_raw.as_str(), ident.sym)