use super::item_head::{Visibility, in_attribute, in_macro_body, visibility_before};
use super::path_vocab::canonical_module_path;
use super::token_tree::{Delimiter, Kind, TokenTree};
const MAX_USE_TREE_NESTING: usize = 128;
pub(super) struct UseStatement {
pub at: usize,
pub end: usize,
pub visibility: Visibility,
pub leaves: Result<Vec<UseLeaf>, String>,
}
pub(super) fn use_statements(tree: &TokenTree) -> Vec<UseStatement> {
statements_where(tree, false)
}
pub(super) fn macro_use_statements(tree: &TokenTree) -> Vec<UseStatement> {
statements_where(tree, true)
}
fn statements_where(tree: &TokenTree, in_macro: bool) -> Vec<UseStatement> {
let mut statements = Vec::new();
for at in 0..tree.len() {
if tree.kind(at) != Kind::Keyword
|| tree.text(at) != "use"
|| tree.is(at + 1, "<")
|| in_macro_body(tree, at) != in_macro
|| in_attribute(tree, at)
{
continue;
}
let Some(end) = statement_end(tree, at + 1) else {
continue;
};
let body = render(tree, at + 1, end);
let mut leaves = Vec::new();
let read = read_tree(tree, at + 1, end, &Path::default(), 0, &mut leaves).map_err(
|unread| match unread {
Unread::PastCap(depth) => {
format!("cannot judge a `use` tree nested past {depth} brace levels: '{body}'")
}
Unread::Token(k) if k < end => format!(
"cannot judge a `use` tree holding `{}` where a path segment stands: '{body}'",
tree.written(k)
),
Unread::Token(_) => {
format!("cannot judge a `use` tree whose path ends in `::`: '{body}'")
}
},
);
statements.push(UseStatement {
at,
end,
visibility: visibility_before(tree, at),
leaves: read.map(|()| leaves),
});
}
statements
}
fn statement_end(tree: &TokenTree, from: usize) -> Option<usize> {
let mut k = from;
while k < tree.len() {
match tree.kind(k) {
Kind::Open(_) => k = tree.partner(k) + 1,
Kind::Close(_) => return None,
_ if tree.is(k, ";") => return Some(k),
_ => k += 1,
}
}
None
}
fn render(tree: &TokenTree, from: usize, to: usize) -> String {
let word = |k: usize| {
matches!(
tree.kind(k),
Kind::Ident | Kind::RawIdent | Kind::Keyword | Kind::Literal | Kind::Lifetime
)
};
let mut out = String::new();
for k in from..to {
if k > from && word(k) && word(k - 1) {
out.push(' ');
}
out.push_str(tree.written(k));
}
out
}
#[derive(Debug, PartialEq, Eq)]
pub(super) enum UseLeaf {
Name {
path: String,
binds: String,
},
Glob(String),
SelfLeaf {
module: String,
binds: String,
},
Empty(String),
}
#[derive(Clone, Default)]
struct Path {
global: bool,
segments: Vec<String>,
}
impl Path {
fn written(&self) -> String {
let joined = self.segments.join("::");
if self.global {
format!("::{joined}")
} else {
joined
}
}
fn last(&self) -> Option<&str> {
self.segments.last().map(String::as_str)
}
}
#[derive(Debug)]
enum Unread {
PastCap(usize),
Token(usize),
}
fn read_tree(
tree: &TokenTree,
from: usize,
to: usize,
prefix: &Path,
depth: usize,
out: &mut Vec<UseLeaf>,
) -> Result<(), Unread> {
if depth > MAX_USE_TREE_NESTING {
return Err(Unread::PastCap(MAX_USE_TREE_NESTING));
}
let mut path = prefix.clone();
let mut k = from;
if k < to && tree.is(k, "::") && path.segments.is_empty() {
path.global = true;
k += 1;
} else if path.segments.is_empty() && tree.is(k, "$") && k + 1 < to && tree.is(k + 1, "crate") {
k += 1;
}
while k < to {
if tree.is(k, "*") {
out.push(UseLeaf::Glob(if path.segments.is_empty() {
"::".to_string()
} else {
path.written()
}));
return Ok(());
}
if tree.kind(k) == Kind::Open(Delimiter::Brace) {
let close = tree.partner(k).min(to);
if close == k + 1 {
if !path.segments.is_empty() {
out.push(UseLeaf::Empty(path.written()));
}
return Ok(());
}
let mut part = k + 1;
while part < close {
let mut end = part;
while end < close && !tree.is(end, ",") {
end = match tree.kind(end) {
Kind::Open(_) => tree.partner(end) + 1,
_ => end + 1,
};
}
read_part(tree, part, end.min(close), &path, depth + 1, out)?;
part = end + 1;
}
return Ok(());
}
if !matches!(tree.kind(k), Kind::Ident | Kind::RawIdent | Kind::Keyword) {
return Err(Unread::Token(k));
}
let segment = tree.written(k);
path.segments.push(segment.to_string());
k += 1;
if k < to && tree.is(k, "::") {
k += 1;
continue;
}
let binds = if tree.is(k, "as") && k + 1 < to {
tree.written(k + 1)
} else {
segment
};
out.push(UseLeaf::Name {
path: path.written(),
binds: canonical_module_path(binds),
});
return Ok(());
}
Err(Unread::Token(to))
}
fn read_part(
tree: &TokenTree,
from: usize,
to: usize,
prefix: &Path,
depth: usize,
out: &mut Vec<UseLeaf>,
) -> Result<(), Unread> {
if from >= to {
return Ok(());
}
if tree.is(from, "self") && (from + 1 == to || tree.is(from + 1, "as")) {
let Some(last) = prefix.last() else {
return Ok(());
};
let named = if tree.is(from + 1, "as") && from + 2 < to {
tree.written(from + 2)
} else {
last
};
out.push(UseLeaf::SelfLeaf {
module: prefix.written(),
binds: canonical_module_path(named),
});
return Ok(());
}
read_tree(tree, from, to, prefix, depth, out)
}